public async Task <ArticleTaskResult> Process(Article article)
        {
            var articleTaskResult = new ArticleTaskResult {
                Article = article
            };

            if (!article.Title.Equals("Archetype", StringComparison.OrdinalIgnoreCase))
            {
                var articleDetailsList = await _wikiArticle.Details((int)article.Id);

                var articleDetails = articleDetailsList.Items.First();

                var epoch = articleDetails.Value.Revision.Timestamp;

                var thumbNailUrl = _archetypeWebPage.ArchetypeThumbnail(articleDetails, article.Url);

                var archetype = new Archetype
                {
                    Id         = article.Id,
                    Name       = article.Title,
                    Revision   = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(epoch),
                    ImageUrl   = thumbNailUrl,
                    ProfileUrl = article.Url
                };

                await _queue.Publish(archetype);
            }

            return(articleTaskResult);
        }
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            var response = new ArticleTaskResult {
                Article = item
            };

            var card = await _cardService.CardByName(item.Title);

            if (card != null)
            {
                var triviaSections = new List <CardTriviaSection>();

                var articleCardTrivia = await _wikiArticle.Simple(item.Id);

                foreach (var cardTriviaSection in articleCardTrivia.Sections)
                {
                    if (cardTriviaSection.Title.Equals("References", StringComparison.OrdinalIgnoreCase))
                    {
                        continue;
                    }

                    var rulingSection = new CardTriviaSection
                    {
                        Name   = cardTriviaSection.Title,
                        Trivia = SectionHelper.GetSectionContentList(cardTriviaSection)
                    };

                    triviaSections.Add(rulingSection);
                }

                await _cardTriviaService.Update(card.Id, triviaSections);
            }

            return(response);
        }
示例#3
0
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            if (item == null)
            {
                throw new ArgumentNullException(nameof(item));
            }

            var articleTaskResult = new ArticleTaskResult {
                Article = item
            };

            try
            {
                await _queue.Publish(item);

                articleTaskResult.IsSuccessfullyProcessed = true;
            }
            catch (Exception ex)
            {
                articleTaskResult.Failed = new ArticleException {
                    Article = item, Exception = ex
                };
            }

            return(articleTaskResult);
        }
        public async Task <ArticleTaskResult> ProcessItem(Article article)
        {
            var response = new ArticleTaskResult {
                Article = article
            };

            var cardSectionMessage = await _cardSectionProcessor.ProcessItem(article);

            await _queues.Single(q => q.Handles(ArticleCategory.CardTrivia)).Publish(cardSectionMessage);

            return(response);
        }
        public async Task <ArticleTaskResult> Process(Article article)
        {
            var articleTaskResult = new ArticleTaskResult {
                Article = article
            };

            var archetypeName = StringHelpers.ArchetypeNameFromListTitle(article.Title);

            var archetypeCards = new ArchetypeCard
            {
                ArchetypeName = archetypeName,
                Cards         = _archetypeWebPage.Cards(new Uri(article.Url))
            };

            await _queue.Publish(archetypeCards);

            return(articleTaskResult);
        }
示例#6
0
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            var response = new ArticleTaskResult {
                Article = item
            };

            var yugiohCard = _cardWebPage.GetYugiohCard(new Uri(new Uri(_config.WikiaDomainUrl), item.Url));

            if (yugiohCard != null)
            {
                var card = await _yugiohCardService.AddOrUpdate(yugiohCard);

                if (card != null)
                {
                    response.IsSuccessfullyProcessed = true;
                }
            }

            return(response);
        }
示例#7
0
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            var response = new ArticleTaskResult {
                Article = item
            };

            var card = await _cardService.CardByName(item.Title);

            if (card != null)
            {
                var tipSections = new List <CardTipSection>();

                var articleCardTips = await _wikiArticle.Simple(item.Id);

                foreach (var cardTipSection in articleCardTips.Sections)
                {
                    var tipSection = new CardTipSection
                    {
                        Name = cardTipSection.Title,
                        Tips = SectionHelper.GetSectionContentList(cardTipSection)
                    };


                    if (cardTipSection.Title.Equals("List", StringComparison.OrdinalIgnoreCase) ||
                        cardTipSection.Title.Equals("Lists", StringComparison.OrdinalIgnoreCase))
                    {
                        tipSection.Name = tipSection.Tips.First();
                        tipSection.Tips.Clear();
                        _tipRelatedWebPage.GetTipRelatedCards(tipSection, item);
                    }

                    tipSections.Add(tipSection);
                }

                await _cardTipService.Update(card.Id, tipSections);
            }

            return(response);
        }
示例#8
0
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            var response = new ArticleTaskResult {
                Article = item
            };

            if (!item.Title.Equals("Archetype", StringComparison.OrdinalIgnoreCase))
            {
                var archetypeUrl = new Uri(new Uri(_config.WikiaDomainUrl), item.Url);

                var thumbNailUrl = await _archetypeWebPage.ArchetypeThumbnail(item.Id, item.Url);

                var existingArchetype = await _archetypeService.ArchetypeById(item.Id);

                var archetype = existingArchetype == null
                    ? await _archetypeService.Add(new AddArchetypeCommand
                {
                    ArchetypeNumber = item.Id,
                    Name            = item.Title,
                    ImageUrl        = ImageHelper.ExtractImageUrl(thumbNailUrl),
                    ProfileUrl      = archetypeUrl.AbsoluteUri
                })
                    : await _archetypeService.Update(new UpdateArchetypeCommand
                {
                    Id         = existingArchetype.Id,
                    Name       = item.Title,
                    ImageUrl   = ImageHelper.ExtractImageUrl(thumbNailUrl),
                    ProfileUrl = archetypeUrl.AbsoluteUri
                });


                if (archetype != null)
                {
                    response.IsSuccessfullyProcessed = true;
                }
            }

            return(response);
        }
示例#9
0
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            var response = new ArticleTaskResult {
                Article = item
            };
            var archetypeName = StringHelpers.ArchetypeNameFromListTitle(item.Title);

            var archetypeUrl = new Uri(new Uri(_config.WikiaDomainUrl), item.Url);

            var existingArchetype = await _archetypeService.ArchetypeByName(archetypeName);

            if (existingArchetype != null)
            {
                var archetype = await _archetypeCardsService.Update(new UpdateArchetypeCardsCommand { ArchetypeId = existingArchetype.Id, Cards = _archetypeWebPage.Cards(archetypeUrl) });

                if (archetype != null)
                {
                    response.IsSuccessfullyProcessed = true;
                }
            }

            return(response);
        }
        public async Task <ArticleTaskResult> ProcessItem(Article article)
        {
            var response = new ArticleTaskResult {
                Article = article
            };

            var tipSections = new List <CardSection>();

            var articleCardTips = await _wikiArticle.Simple(article.Id);

            foreach (var cardTipSection in articleCardTips.Sections)
            {
                var tipSection = new CardSection
                {
                    Name        = cardTipSection.Title,
                    ContentList = SectionHelper.GetSectionContentList(cardTipSection)
                };

                if (cardTipSection.Title.Equals("List", StringComparison.OrdinalIgnoreCase) ||
                    cardTipSection.Title.Equals("Lists", StringComparison.OrdinalIgnoreCase))
                {
                    tipSection.Name = tipSection.ContentList.First();
                    tipSection.ContentList.Clear();
                    _tipRelatedWebPage.GetTipRelatedCards(tipSection, article);
                }

                tipSections.Add(tipSection);
            }

            var cardSectionMessage = new CardSectionMessage {
                Name = article.Title, CardSections = tipSections
            };

            await _queues.Single(q => q.Handles(ArticleCategory.CardTips)).Publish(cardSectionMessage);

            return(response);
        }
示例#11
0
        public async Task <ArticleTaskResult> ProcessItem(UnexpandedArticle item)
        {
            var response = new ArticleTaskResult {
                Article = item
            };

            var articleDetailsList = await _wikiArticle.Details(item.Id);

            var articleDetails = articleDetailsList.Items.First();

            var banlistArticleSummary = BanlistHelpers.ExtractBanlistArticleDetails(articleDetails.Value.Id, articleDetails.Value.Abstract);

            if (banlistArticleSummary != null)
            {
                const char beginChar = '「';
                const char endChar   = '」';

                var banlist = new YugiohBanlist
                {
                    ArticleId   = banlistArticleSummary.ArticleId,
                    Title       = articleDetails.Value.Title,
                    BanlistType = banlistArticleSummary.BanlistType,
                    StartDate   = banlistArticleSummary.StartDate
                };


                var banlistContentResult = await _wikiArticle.Simple(banlistArticleSummary.ArticleId);

                foreach (var section in banlistContentResult.Sections)
                {
                    // skip references section
                    if (section.Title.ToLower() == "references")
                    {
                        continue;
                    }

                    // new section
                    var ybls = new YugiohBanlistSection
                    {
                        Title   = StringHelpers.RemoveBetween(section.Title, beginChar, endChar).Trim(),
                        Content = ContentResultHelpers.GetSectionContentList(section).OrderBy(c => c).ToList()
                    };

                    // remove invalid characters
                    if (ybls.Content.Any())
                    {
                        ybls.Content = ybls.Content.Select(c => StringHelpers.RemoveBetween(c, beginChar, endChar)).ToList();
                    }

                    banlist.Sections.Add(ybls);
                }

                await _banlistService.AddOrUpdate(banlist);

                response.Data = banlist;

                response.IsSuccessfullyProcessed = true;
            }

            return(response);
        }