public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//div[contains(@class, 'deck-info')]//h1").InnerText);
                deck.Name = deckName;

                var cardNodes = doc.DocumentNode.SelectNodes("//ul[@class='listado mazo-cartas']/li");

                foreach (var cardNode in cardNodes)
                {
                    var count = int.Parse(cardNode.SelectSingleNode(".//span[@class='cantidad']").InnerText);
                    var name  = HttpUtility.HtmlDecode(cardNode.SelectSingleNode(".//span[@class='nombreCarta']").InnerText);
                    var card  = Database.GetCardFromName(name);
                    card.Count = count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck {
                    Name = doc.DocumentNode.SelectSingleNode("//h1[@id='deck-title']").InnerText
                };

                var cardList = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//table[@id='deck-guide']").Attributes["data-deck"].Value);
                cardList = cardList.Replace("\"", "").Replace("[", "").Replace("]", "").Replace("\\", "");

                foreach (var cardNode in cardList.Split(',').GroupBy(x => x))
                {
                    var card = Hearthstone.Database.GetCardFromId(cardNode.Key);
                    card.Count = cardNode.Count();
                    deck.Cards.Add(card);

                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();
                deck.Name = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("/html/body/div/div[4]/div/div[2]/div/div[1]/h3").InnerText.Trim());

                var cards = doc.DocumentNode.SelectNodes("//div[contains(@class, 'cardname')]/span");

                var deckInfo = doc.DocumentNode.SelectSingleNode("//div[@id='subinfo']").SelectNodes("//span[contains(@class, 'midlarge')]/span");
                if (deckInfo.Count == 2)
                {
                    deck.Class = HttpUtility.HtmlDecode(deckInfo[0].InnerText).Trim();

                    var decktype = HttpUtility.HtmlDecode(deckInfo[1].InnerText).Trim();
                    if (!string.IsNullOrEmpty(decktype) && decktype != "None" && Config.Instance.TagDecksOnImport)
                    {
                        if (!DeckList.Instance.AllTags.Contains(decktype))
                        {
                            DeckList.Instance.AllTags.Add(decktype);
                            DeckList.Save();
                            if (Helper.MainWindow != null)                             // to avoid errors when running tests
                            {
                                Core.MainWindow.ReloadTags();
                            }
                        }
                        deck.Tags.Add(decktype);
                    }
                }

                foreach (var cardNode in cards)
                {
                    var nameString = HttpUtility.HtmlDecode(cardNode.InnerText);
                    var match      = Regex.Match(nameString, @"^\s*(\d+)\s+(.*)\s*$");

                    if (match.Success)
                    {
                        var count = match.Groups[1].Value;
                        var name  = match.Groups[2].Value;

                        var card = Database.GetCardFromName(name);
                        card.Count = count.Equals("2") ? 2 : 1;
                        deck.Cards.Add(card);
                        if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                        {
                            deck.Class = card.PlayerClass;
                        }
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
Exemple #4
0
        private async Task <IDictionary <int, HsReplayArchetype> > GetHsReplayArchetypes()
        {
            var json = await ImportingHelper.JsonRequest($"https://hsreplay.net/api/v1/archetypes/");

            var archetypes = JsonConvert.DeserializeObject <List <HsReplayArchetype> >(json);

            return(archetypes.ToDictionary(a => a.Id, a => a));
        }
Exemple #5
0
        private static async Task <Deck> ImportHearthPwn(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName =
                    HttpUtility.HtmlDecode(
                        doc.DocumentNode.SelectSingleNode(
                            "//section[contains(@class,'deck-info')]/h2[contains(@class,'deck-title')]")
                        .InnerText);
                deck.Name = deckName;

                var cardNameNodes =
                    doc.DocumentNode.SelectNodes("//td[contains(@class,'col-name')]//a[contains(@href,'/cards/') and contains(@class,'rarity')]");
                var cardCountNodes = doc.DocumentNode.SelectNodes("//td[contains(@class,'col-name')]");
                //<span class="deck-type">Midrange</span>
                var decktype = doc.DocumentNode.SelectSingleNode("//span[contains(@class,'deck-type')]").InnerText;
                if (decktype != "None" && Config.Instance.TagDecksOnImport)
                {
                    if (!DeckList.Instance.AllTags.Contains(decktype))
                    {
                        DeckList.Instance.AllTags.Add(decktype);
                        DeckList.Save();
                        if (Core.MainWindow != null)                        // to avoid errors when running tests
                        {
                            Core.MainWindow.ReloadTags();
                        }
                    }
                    deck.Tags.Add(decktype);
                }


                var cardNames = cardNameNodes.Select(cardNameNode => HttpUtility.HtmlDecode(cardNameNode.InnerText));
                var cardCosts = cardCountNodes.Select(countNode => int.Parse(Regex.Match(countNode.LastChild.InnerText, @"\d+").Value));

                var cardInfo = cardNames.Zip(cardCosts, (n, c) => new { Name = n, Count = c });
                foreach (var info in cardInfo)
                {
                    var card = Database.GetCardFromName(info.Name.Trim());
                    card.Count = info.Count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
Exemple #6
0
        private static async Task <Deck> ImportHearthPwnDeckBuilder(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName =
                    HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//div[contains(@class,'deck-name-container')]/h2").InnerText);
                deck.Name = deckName;

                var cardNodes = doc.DocumentNode.SelectNodes("//tr[contains(@class,'deck-card-link')]");

                /* <tr class="deck-card-link odd" data-tooltip-href="//www.hearthpwn.com/cards/22385-power-word-glory"
                 *     data-description="Choose a minion. Whenever it attacks, restore 4 Health to your hero." data-race=""
                 *     data-rarity="1" data-class="6" data-cost="1" data-hp="0" data-attack="0"
                 *     data-image="http://media-Hearth.cursecdn.com/avatars/252/489/22385.png" data-type="5" data-id="22385"
                 *     data-name="Power Word: Glory" data-mechanics="">
                 */
                Dictionary <int, string> cardDatabase = new Dictionary <int, string>();
                foreach (var cardtr in cardNodes)
                {
                    var cardId   = cardtr.GetAttributeValue("data-id", -1);
                    var cardName = HttpUtility.HtmlDecode(cardtr.GetAttributeValue("data-name", ""));
                    cardDatabase[cardId] = cardName;
                }

                // http://www.hearthpwn.com/deckbuilder/priest#38:1;117:2;207:2;212:2;346:2;395:2;409:2;415:2;431:2;435:2;544:1;554:2;600:2;7750:2;7753:2;7755:2;
                var cardMatches = Regex.Matches(url, @"(\d+):(\d+)");

                foreach (Match cardMatch in cardMatches)
                {
                    var cardId    = int.Parse(cardMatch.Groups[1].Value);
                    var cardCount = int.Parse(cardMatch.Groups[2].Value);
                    var cardName  = cardDatabase[cardId];

                    var card = Database.GetCardFromName(cardName);
                    card.Count = cardCount;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                // check url looks correct
                var match = Regex.Match(url, "/decks/([^/]+)$");
                // get deck name from url, and post the json request
                if (match.Success && match.Groups.Count == 2)
                {
                    var slug  = match.Groups[1].ToString();
                    var param = "{\"where\":{\"slug\":\""
                                + slug
                                + "\"},\"fields\":{},\"include\":[{\"relation\":\"cards\",\"scope\":{\"include\":[\"card\"]}}]}";
                    var data = await ImportingHelper.JsonRequest("https://tempostorm.com/api/decks/findOne?filter=" + param);

                    //parse json
                    var jsonObject = JsonConvert.DeserializeObject <dynamic>(data);
                    if (jsonObject.error == null)
                    {
                        var deck = new Deck();

                        deck.Name = jsonObject.name.ToString();
                        var cards = jsonObject.cards;

                        foreach (var item in cards)
                        {
                            var card = Database.GetCardFromName(item.card.name.ToString());
                            card.Count = item.cardQuantity.ToString().Equals("2") ? 2 : 1;
                            deck.Cards.Add(card);
                            if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                            {
                                deck.Class = card.PlayerClass;
                            }
                        }

                        return(deck);
                    }
                    throw new Exception("JSON request failed for '" + slug + "'.");
                }
                throw new Exception("The url (" + url + ") is not a vaild TempoStorm deck.");
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Exemple #8
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                // check url looks correct
                var pattern = "/decks/([^/]+)$";
                var match   = Regex.Match(url, pattern);
                // get deck name from url, and post the json request
                if (match.Success && match.Groups.Count == 2)
                {
                    var slug = match.Groups[1].ToString();
                    var data = await ImportingHelper.PostJson("https://tempostorm.com/deck", "{\"slug\": \"" + slug + "\"}");

                    // parse json
                    var jsonObject = JsonConvert.DeserializeObject <dynamic>(data);
                    if (jsonObject.success.ToObject <bool>())
                    {
                        var deck = new Deck();

                        deck.Name = jsonObject.deck.name.ToString();
                        //deck.Class = jsonObject.deck.playerClass.ToString();
                        var cards = jsonObject.deck.cards;

                        foreach (var item in cards)
                        {
                            var card = Database.GetCardFromName(item.card.name.ToString());
                            card.Count = item.qty.ToString().Equals("2") ? 2 : 1;
                            deck.Cards.Add(card);
                            if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                            {
                                deck.Class = card.PlayerClass;
                            }
                        }

                        return(deck);
                    }
                    throw new Exception("JSON request failed for '" + slug + "'.");
                }
                throw new Exception("The url (" + url + ") is not a vaild TempoStorm deck.");
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//*[@id='deck-list-title']").InnerText);
                deck.Name = deckName;

                var cardNodes = doc.DocumentNode.SelectNodes("//div[contains(@class,'guide-deck-list')]/div/div[contains(@class,'card')]");
                foreach (var cardNode in cardNodes)
                {
                    //silly names contain right-single quotation mark
                    var cardName =
                        cardNode.SelectSingleNode(".//span[contains(@class, 'card-title')]")
                        .InnerText.Replace("&#8217", "&#39")
                        .Replace("&#8216", "&#39");

                    var name = HttpUtility.HtmlDecode(cardName);

                    //no count there if count == 1
                    var countNode = cardNode.SelectSingleNode(".//span[contains(@class, 'card-count')]");
                    var count     = 1;
                    if (countNode != null)
                    {
                        count = int.Parse(countNode.InnerText);
                    }

                    var card = Database.GetCardFromName(name);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                    card.Count = count;
                    deck.Cards.Add(card);
                }
                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckRoot = doc.DocumentNode.SelectSingleNode("//div[@class='decklist-meta-data']");
                var deckInfo = deckRoot.SelectNodes(".//div[@class='row']/div");
                if (deckInfo.Count != 3)
                {
                    Log.Error("Wrong number of columns.");
                    return(null);
                }

                // get metadata
                deck.Name = HttpUtility.HtmlDecode(deckRoot.SelectSingleNode(".//h2/a").InnerText).Trim();
                var deckType = HttpUtility.HtmlDecode(deckInfo[0].SelectNodes(".//p")[2].InnerText).Trim();
                if (!string.IsNullOrWhiteSpace(deckType) && Config.Instance.TagDecksOnImport)
                {
                    if (!DeckList.Instance.AllTags.Contains(deckType))
                    {
                        DeckList.Instance.AllTags.Add(deckType);
                        DeckList.Save();
                        if (Core.MainWindow != null)                        // to avoid errors when running tests
                        {
                            Core.MainWindow.ReloadTags();
                        }
                    }
                    deck.Tags.Add(deckType);
                }
                // get cards
                CardNodes(deckInfo[1], deck);
                CardNodes(deckInfo[2], deck);

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Exemple #11
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                if (!url.Contains("http://www."))
                {
                    url = "http://www." + url.Split('.').Skip(1).Aggregate((c, n) => c + "." + n);
                }

                // don't seem to need to Get with WebBrowser anymore
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//*[@id='deckguide-name']").InnerText);
                deck.Name = deckName;


                var cardNodes = doc.DocumentNode.SelectNodes("//*[contains(@class,'deckguide-cards-type')]//ul//li");

                foreach (var cardNode in cardNodes)
                {
                    var nameRaw = cardNode.SelectSingleNode(".//a").InnerText;
                    var name    = HttpUtility.HtmlDecode(nameRaw);
                    var count   = cardNode.InnerText.Remove(0, nameRaw.Length - 1).Contains("2") ? 2 : 1;
                    var card    = Database.GetCardFromName(name);
                    card.Count = count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
Exemple #12
0
        private async Task <string> MulliganWinrate(string cardName)
        {
            try
            {
                if (_doc == null)
                {
                    _doc = await ImportingHelper.GetHtmlDoc(ActiveDeckUrl());
                }


                var ournode = _doc.DocumentNode.SelectNodes("//span[@class=\"card-name\"]").First(x => x.InnerText == cardName);
                return(HttpUtility.HtmlDecode(ournode.SelectSingleNode("//ancestor::tr/td[@class=\"winrate-cell\"][1]").InnerText));
            }
            catch (Exception ex)
            {
                Log.Error("Unable to get Mulligan Winrate ->");
                Log.Error(ex);
                return("error");
            }
        }
Exemple #13
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName =
                    HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//div[contains(@class, 'single-deck-title-wrap')]/h2").InnerText);
                deck.Name = deckName;

                var cardNodes = doc.DocumentNode.SelectNodes("//table[contains(@class, 'cards-table')]/tbody/tr/td[1]/div");

                foreach (var cardNode in cardNodes)
                {
                    var nameString = HttpUtility.HtmlDecode(cardNode.InnerText);
                    var match      = Regex.Match(nameString, @"^\s*(.*)\s*(x 2)?\s*$");

                    if (match.Success)
                    {
                        var name  = match.Groups[1].Value;
                        var count = match.Groups[2].Value;

                        var card = Database.GetCardFromName(name);
                        card.Count = String.IsNullOrEmpty(count) ? 1 : 2;
                        deck.Cards.Add(card);
                        if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                        {
                            deck.Class = card.PlayerClass;
                        }
                    }
                }
                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
Exemple #14
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck {
                    IsArenaDeck = true
                };

                var cardNodes     = doc.DocumentNode.SelectSingleNode(".//ul[@class='deckList']");
                var nameNodes     = cardNodes.SelectNodes(".//span[@class='name']");
                var countNodes    = cardNodes.SelectNodes(".//span[@class='quantity']");
                var numberOfCards = nameNodes.Count;
                for (var i = 0; i < numberOfCards; i++)
                {
                    var nameRaw = nameNodes.ElementAt(i).InnerText;
                    var name    = HttpUtility.HtmlDecode(nameRaw);
                    var card    = Hearthstone.Database.GetCardFromName(name);
                    card.Count = int.Parse(countNodes.ElementAt(i).InnerText);
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }
                if (DeckList.Instance.AllTags.Contains("Arena"))
                {
                    deck.Tags.Add("Arena");
                }
                deck.Name = Helper.ParseDeckNameTemplate(Config.Instance.ArenaDeckNameTemplate, deck);
                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDocGzip(url);

                var deck = new Deck
                {
                    Name =
                        HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//header[@class='panel-heading']/h1[@class='panel-title']").InnerText)
                        .Trim()
                };
                var nodes = doc.DocumentNode.SelectNodes("//*[@id='list']/div/table/tbody/tr");

                foreach (var cardNode in nodes)
                {
                    var name = HttpUtility.HtmlDecode(cardNode.SelectSingleNode(".//a").Attributes[3].Value);

                    var temp  = HttpUtility.HtmlDecode(cardNode.SelectSingleNode(".//span[@class='text-muted']").InnerText[0].ToString());
                    var count = int.Parse(temp);

                    var card = Database.GetCardFromName(name);
                    card.Count = count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Exemple #16
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//h2[contains(@class, 'dname')]").InnerText);
                deck.Name = deckName;

                var cardNodes = doc.DocumentNode.SelectNodes("//ul[@class='vminionslist' or @class='vspellslist']/li");

                foreach (var cardNode in cardNodes)
                {
                    var count = int.Parse(cardNode.SelectSingleNode(".//span[@class='cantidad']").InnerText);
                    var name  =
                        HttpUtility.HtmlDecode(
                            cardNode.SelectSingleNode(
                                ".//span[@class='nombreCarta rarity_legendary' or @class='nombreCarta rarity_epic' or @class='nombreCarta rarity_rare' or @class='nombreCarta rarity_common' or @class='nombreCarta rarity_basic']")
                            .InnerText);
                    var card = Database.GetCardFromName(name);
                    card.Count = count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
Exemple #17
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck
                {
                    Name =
                        HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//*[@id='content']/div[contains(@class, 'deck')]/h1").InnerText).Trim()
                };

                var nodes = doc.DocumentNode.SelectNodes("//a[@real_id]");

                foreach (var cardNode in nodes)
                {
                    var id    = cardNode.Attributes["real_id"].Value;
                    var count = int.Parse(cardNode.Attributes["nb_card"].Value);

                    var card = Hearthstone.Database.GetCardFromId(id);
                    card.Count = count;

                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Exemple #18
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//h1[contains(@class,'page-title')]").FirstChild.InnerText);
                deck.Name = deckName;

                var cardNameNodes  = doc.DocumentNode.SelectNodes("//div[contains(@class,'name')]");
                var cardCountNodes = doc.DocumentNode.SelectNodes("//div[contains(@class,'qty')]");

                var cardNames = cardNameNodes.Select(cardNameNode => HttpUtility.HtmlDecode(cardNameNode.InnerText));
                var cardCosts = cardCountNodes.Select(countNode => int.Parse(countNode.InnerText));

                var cardInfo = cardNames.Zip(cardCosts, (n, c) => new { Name = n, Count = c });
                foreach (var info in cardInfo)
                {
                    var card = Database.GetCardFromName(info.Name);
                    card.Count = info.Count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var titleNode = doc.DocumentNode.SelectSingleNode("//div[contains(@class,'header__title internal')]/div[contains(@class,'container')]/h1");
                var cardNodes = doc.DocumentNode.SelectNodes("//ul[contains(@class,'list-unstyled cartas_list')]/li");

                var deck = new Deck();
                deck.Name = HttpUtility.HtmlDecode(titleNode.ChildNodes.FirstOrDefault(x => x.Name == "#text").InnerText);
                foreach (var node in cardNodes)
                {
                    var nameNode   = node.SelectSingleNode("span[contains(@class,'cartas__name')]/a");
                    var countNode  = node.SelectSingleNode("span[contains(@class,'cartas__qtd')]");
                    var validChild = countNode?.ChildNodes.SingleOrDefault(c => c.Name == "#text");

                    var id    = nameNode.Attributes.FirstOrDefault(a => a.Name == "data-hcfw-card-id").Value;
                    var count = validChild != null?int.Parse(countNode.InnerText) : 1;

                    var card = Database.GetCardFromId(id);
                    card.Count = count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName =
                    HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//header[@class='entry-header']/h1[@class='entry-title']").InnerText);
                deck.Name = deckName;


                var cardNodes = doc.DocumentNode.SelectNodes("//ul[contains(@class,'deck-class')]/li");

                foreach (var cardNode in cardNodes)
                {
                    var name  = HttpUtility.HtmlDecode(cardNode.SelectSingleNode(".//a/span[@class='card-name']").InnerText);
                    var count = int.Parse(HttpUtility.HtmlDecode(cardNode.SelectSingleNode(".//span[@class='card-count']").InnerText));

                    var card = Database.GetCardFromName(name.Replace("’", "'"));
                    card.Count = count;
                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }
Exemple #21
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck = new Deck();

                var deckName = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode("//span[contains(@class, 'deckName')]").InnerText).Trim();
                deck.Name = deckName;

                var cardNodes = doc.DocumentNode.SelectNodes("//table[@class='deck_card_list']/tbody/tr/td/a[@class='real_id']");

                foreach (var cardNode in cardNodes)
                {
                    var id    = cardNode.Attributes["real_id"].Value;
                    var count = int.Parse(cardNode.Attributes["nb_card"].Value);

                    var card = Database.GetCardFromId(id);
                    card.Count = count;

                    deck.Cards.Add(card);
                    if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                    {
                        deck.Class = card.PlayerClass;
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Logger.WriteLine(e.ToString(), "DeckImporter");
                return(null);
            }
        }
Exemple #22
0
        /// <summary>
        ///     Gets all decks from HSReplay.
        /// </summary>
        /// <param name="archetypes">The HSReplay archetypes</param>
        /// <param name="progress">Tuple of two integers holding the progress information for the UI</param>
        /// <returns>The list of all parsed decks</returns>
        private async Task <IList <Deck> > GetHsreplayDecks(IDictionary <int, HsReplayArchetype> archetypes, string gameType, IProgress <Tuple <int, int> > progress)
        {
            var pattern = @"(\[\d+,[12]{1}\])";

            var json = await ImportingHelper.JsonRequest($"https://hsreplay.net/analytics/query/list_decks_by_win_rate_v2/?GameType={gameType}");

            var decks = JsonConvert.DeserializeObject <HsReplayDecks>(json).Series.Data;

            return(decks.SelectMany(x => decks[x.Key].Select(d =>
            {
                // Count found decks thread-safe
                Interlocked.Increment(ref _decksFound);

                // Get the archetype or default
                HsReplayArchetype archetype;
                if (!archetypes.ContainsKey(d.ArchetypeId))
                {
                    archetype = new HsReplayArchetype();
                    archetype.Name = "Other";
                    archetype.Url = $"/archetypes/{d.ArchetypeId}";
                    archetype.Class = HsReplayNameToClassId[x.Key];
                }
                else
                {
                    archetype = archetypes[d.ArchetypeId];
                }

                // Create new deck
                var deck = new Deck();

                deck.Name = archetype.Name;
                deck.Url = archetype.Url;
                deck.Class = HsReplayClassIdToName[archetype.Class];

                // Insert deck note for statistics
                deck.Note = $"#Games: {d.TotalGames}, #Win Rate: {d.WinRate}%";

                // Set import datetime as LastEdited
                deck.LastEdited = DateTime.Now;

                var matches = Regex.Matches(d.DeckList, pattern);
                foreach (Match match in matches)
                {
                    var matchText = match.Value.Trim('[', ']');

                    // Get card from database with dbf id
                    var card = Database.GetCardFromDbfId(int.Parse(matchText.Split(',')[0]));
                    card.Count = int.Parse(matchText.Split(',')[1]);

                    deck.Cards.Add(card);
                }

                // Count imported decks thread-safe
                Interlocked.Increment(ref _decksImported);

                // Report progress for UI
                progress.Report(new Tuple <int, int>(_decksImported, _decksFound));

                return deck;
            })).ToList());
        }
Exemple #23
0
        public static async Task <Deck> Import(string url)
        {
            try
            {
                var doc = await ImportingHelper.GetHtmlDoc(url);

                var deck  = new Deck();
                var dname = HttpUtility.HtmlDecode(doc.DocumentNode.SelectSingleNode(
                                                       "//h1[contains(@class, 'panel-title')]").InnerText);
                deck.Name = Regex.Replace(dname, @"\s+", " ");                 // remove sequence of tabs

                var cards = doc.DocumentNode.SelectNodes("//div[contains(@class, 'cardname')]/span");

                var deckExtra = doc.DocumentNode.SelectSingleNode("//div[contains(@class, 'deck_banner_description')]");
                var deckInfo  = deckExtra.SelectNodes("//span[contains(@class, 'midlarge')]/span");

                // get class and tags
                if (deckInfo.Count == 3)
                {
                    deck.Class = HttpUtility.HtmlDecode(deckInfo[1].InnerText).Trim();

                    var decktype = HttpUtility.HtmlDecode(deckInfo[2].InnerText).Trim();
                    if (!string.IsNullOrWhiteSpace(decktype) &&
                        decktype != "None" && Config.Instance.TagDecksOnImport)
                    {
                        if (!DeckList.Instance.AllTags.Contains(decktype))
                        {
                            DeckList.Instance.AllTags.Add(decktype);
                            DeckList.Save();
                            if (Core.MainWindow != null)                            // to avoid errors when running tests
                            {
                                Core.MainWindow.ReloadTags();
                            }
                        }
                        deck.Tags.Add(decktype);
                    }
                }

                // TODO uncomment for standard/wild tags

                /*
                 * var deckFormat = deckExtra.SelectSingleNode("//span[contains(@class, 'small')]").InnerText.Trim();
                 * if(!string.IsNullOrWhiteSpace(deckFormat) && Config.Instance.TagDecksOnImport)
                 * {
                 *      var format = "Standard";
                 *      if(Regex.IsMatch(deckFormat, @"Format:\s*Wild"))
                 *              format = "Wild";
                 *      if(!DeckList.Instance.AllTags.Contains(format))
                 *      {
                 *              DeckList.Instance.AllTags.Add(format);
                 *              DeckList.Save();
                 *              if(Core.MainWindow != null) // to avoid errors when running tests
                 *                      Core.MainWindow.ReloadTags();
                 *      }
                 *      deck.Tags.Add(format);
                 * }
                 */

                foreach (var cardNode in cards)
                {
                    var nameString = HttpUtility.HtmlDecode(cardNode.InnerText);
                    var match      = Regex.Match(nameString, @"^\s*(\d+)\s+(.*)\s*$");

                    if (match.Success)
                    {
                        var count = match.Groups[1].Value;
                        var name  = match.Groups[2].Value;

                        var card = Database.GetCardFromName(name);
                        card.Count = count.Equals("2") ? 2 : 1;
                        deck.Cards.Add(card);
                        if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
                        {
                            deck.Class = card.PlayerClass;
                        }
                    }
                }

                return(deck);
            }
            catch (Exception e)
            {
                Log.Error(e);
                return(null);
            }
        }