🚧 RSS as a module

2026-07-31 00:29:24 +03:00 · 2020-03-02 00:00:52 +04:00
parent e86049f4fd
commit eac0da5016
16 changed files with 1185 additions and 0 deletions
@@ -0,0 +1,314 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BotFramework.Attributes;
+using Kruzya.TelegramBot.Core.Extensions;
+using Kruzya.TelegramBot.RichSiteSummary.Data;
+using Microsoft.EntityFrameworkCore;
+using Telegram.Bot.Types;
+using Telegram.Bot.Types.Enums;
+using Telegram.Bot.Types.ReplyMarkups;
+
+namespace Kruzya.TelegramBot.RichSiteSummary.Handler
+{
+    public class FeedList : AbstractHandler
+    {
+        public FeedList(RichSiteSummaryContext dbContext) : base(dbContext)
+        {
+        }
+        
+        [ParametrizedCommand("feed_show")]
+        public async Task ShowFeed(Feed feed) => await ShowFeed(feed, Chat, From);
+
+        public async Task ShowFeed(Guid feedId, Chat chat, User from)
+        {
+            var feed = await _dbContext.FindAsync<Feed>(feedId);
+            if (feed == null)
+            {
+                return;
+            }
+
+            await ShowFeed(feed, chat, from);
+        }
+
+        public async Task ShowFeed(Feed feed, Chat chat, User from, Message message = null)
+        {
+            var textBuilder = new StringBuilder();
+            textBuilder.Append(feed.Representation(ParseMode.Html));
+            textBuilder.Append("\n");
+            textBuilder.Append($"<b>Posts at this moment</b>: {feed.Posts.Count}\n");
+            textBuilder.Append($"<b>RSS feed</b>: <code>{feed.Url}</code>\n");
+            textBuilder.Append($"<b>Home page</b>: <code>{feed.HomePage}</code>\n");
+            textBuilder.Append($"<b>Last synchronization</b>: <code>{feed.UpdatedAt}</code>");
+
+            var text = textBuilder.ToString();
+
+            var buttons = new List<InlineKeyboardButton>();
+            var callbackData = $"feed|{from.Id}|do|{feed.FeedId}";
+            if (await _dbContext.Subscriptions.HasSubscription(chat, feed))
+            {
+                buttons.Add(new InlineKeyboardButton()
+                {
+                    CallbackData = callbackData,
+                    Text = "Unsubscribe"
+                });
+            }
+            else
+            {
+                buttons.Add(new InlineKeyboardButton()
+                {
+                    CallbackData = callbackData,
+                    Text = "Subscribe"
+                });
+            }
+            buttons.Add(new InlineKeyboardButton()
+            {
+                CallbackData = $"feed|{from.Id}|last|{feed.FeedId}",
+                Text = "Last 10 posts"
+            });
+
+            var inlineButtons = new InlineKeyboardMarkup(buttons);
+            if (message == null)
+            {
+                await Bot.SendTextMessageAsync(new ChatId(chat.Id), text, ParseMode.Html, true, true, 0, inlineButtons);
+            }
+            else
+            {
+                await Bot.EditMessageTextAsync(chat, message.MessageId, text, ParseMode.Html, true, inlineButtons);
+            }
+        }
+        
+        [ParametrizedCommand("feed_list")]
+        public async Task List() => await GenerateMenu();
+
+        [ParametrizedCommand("feed_search")]
+        public async Task Search(string query)
+        {
+            if (!(await GenerateMenu(query)))
+            {
+                await Bot.SendTextMessageAsync(Chat, $"No one feed match by search pattern (<code>{query}</code>).", ParseMode.Html, true);
+            }
+        }
+
+        [Command("feed_subscriptions")]
+        public async Task Subscriptions()
+        {
+            if (!(await GenerateMenu(":sub")))
+            {
+                await Bot.SendTextMessageAsync(Chat,
+                    "There are no one subscription. Add new with /feed_list or /feed_search.");
+            }
+        }
+
+        #region Message generator
+        
+        protected async Task<bool> GenerateMenu() =>
+            await GenerateMenu(string.Empty);
+
+        protected async Task<bool> GenerateMenu(string query) =>
+            await GenerateMenu(query, 0);
+
+        protected async Task<bool> GenerateMenu(string query, UInt16 page, Message editableMessage = null)
+        {
+            var chat = editableMessage != null ? (editableMessage.Chat) : Chat;
+            var elementsOnPage = 9;
+            var startIndex = page * elementsOnPage;
+            var dbQuery = _dbContext.Feeds.AsQueryable();
+            if (!string.IsNullOrWhiteSpace(query))
+            {
+                var searchQuery = query;
+                if (query.EndsWith(":sub"))
+                {
+                    var chatList = await _dbContext.Subscriptions.AllSubscriptions(chat).Select(chat => chat.Feed.FeedId).ToArrayAsync();
+                    dbQuery = dbQuery.Where(sub => chatList.Contains(sub.FeedId));
+
+                    searchQuery = searchQuery.Remove(searchQuery.Length - 4, 4);
+                }
+                
+                dbQuery = dbQuery.Where(feed => feed.Title.Contains(searchQuery) || feed.Url.Contains(searchQuery) || feed.HomePage.Contains(searchQuery));
+            }
+
+            var totalCount = await dbQuery.CountAsync();
+            if (totalCount == 0)
+            {
+                return false;
+            }
+
+            if (totalCount == 1)
+            {
+                await ShowFeed((await dbQuery.FirstOrDefaultAsync()), Chat, From);
+                return true;
+            }
+            
+            var result = await dbQuery.Take(elementsOnPage * (page + 1)).Skip(startIndex)
+                .ToArrayAsync();
+            
+            var backButton = (page > 0);
+            var nextButton = totalCount >= (startIndex + elementsOnPage);
+
+            var buttons = new List<List<InlineKeyboardButton>>();
+            List<InlineKeyboardButton> row;
+            foreach (var feed in result)
+            {
+                row = new List<InlineKeyboardButton>();
+                row.Add(new InlineKeyboardButton()
+                {
+                    CallbackData = $"feed|{From.Id}|show|{feed.FeedId.ToString()}",
+                    Text = feed.Title
+                });
+
+                buttons.Add(row);
+            }
+            
+            if (backButton || nextButton)
+            {
+                row = new List<InlineKeyboardButton>();
+                if (backButton)
+                {
+                    row.Add(new InlineKeyboardButton()
+                    {
+                        CallbackData = $"feed|{From.Id}|page|{query}|{page - 1}",
+                        Text = "⬅️"
+                    });
+                }
+                
+                row.Add(new InlineKeyboardButton()
+                {
+                    CallbackData = $"feed|{From.Id}|donothing",
+                    Text = $"{page + 1}/{(totalCount / elementsOnPage) + 1}"
+                });
+
+                if (nextButton)
+                {
+                    row.Add(new InlineKeyboardButton()
+                    {
+                        CallbackData = $"feed|{From.Id}|page|{query}|{page + 1}",
+                        Text = "➡️"
+                    });
+                }
+                
+                buttons.Add(row);
+            }
+            
+            if (editableMessage == null)
+            {
+                await Bot.SendTextMessageAsync(Chat, "Select the feed for viewing details", ParseMode.Default,
+                    true, true, 0, new InlineKeyboardMarkup(buttons));
+            }
+            else
+            {
+                await Bot.EditMessageTextAsync(editableMessage.Chat, editableMessage.MessageId, "Select the feed for viewing details", ParseMode.Default, false,
+                    new InlineKeyboardMarkup(buttons));
+            }
+
+            return true;
+        }
+        
+        #endregion
+
+        #region Message handler
+
+        [CallbackQuery]
+        public async Task HandleAction()
+        {
+            if (!RawUpdate.CallbackQuery.Data.StartsWith("feed|"))
+            {
+                return;
+            }
+
+            var data = RawUpdate.CallbackQuery.Data.Split('|');
+            var fromId = Int64.Parse(data[1]);
+            if (fromId != From.Id)
+            {
+                await Bot.AnswerCallbackQueryAsync(RawUpdate.CallbackQuery.Id,
+                    "You can't perform this action: command called by another user.", true);
+                return;
+            }
+
+            // Check action.
+            switch (data[2])
+            {
+                case "page":
+                    await GenerateMenu(data[3], UInt16.Parse(data[4]), RawUpdate.CallbackQuery.Message);
+                    break;
+                
+                case "show":
+                    await ShowFeed(Guid.Parse(data[3]), RawUpdate.CallbackQuery.Message.Chat, RawUpdate.CallbackQuery.From);
+                    break;
+                
+                case "do":
+                    if (RawUpdate.CallbackQuery.From.Id != RawUpdate.CallbackQuery.Message.Chat.Id)
+                    {
+                        var userStatus = (await Bot.GetChatMemberAsync(RawUpdate.CallbackQuery.Message.Chat, RawUpdate.CallbackQuery.From.Id)).Status;
+                        var allowedUserStatuses = new ChatMemberStatus[]
+                            {ChatMemberStatus.Administrator, ChatMemberStatus.Creator};
+
+                        if (!allowedUserStatuses.Contains(userStatus))
+                        {
+                            await Bot.AnswerCallbackQueryAsync(RawUpdate.CallbackQuery.Id,
+                                "You can't perform this action: you don't have administrator permissions.", true);
+                            return;
+                        }
+                    }
+
+                    await ChangeFeedSubscription(Guid.Parse(data[3]), RawUpdate.CallbackQuery.Message.Chat, RawUpdate.CallbackQuery.From, RawUpdate.CallbackQuery.Message);
+                    break;
+                
+                case "last":
+                    var feed = await _dbContext.FindAsync<Feed>(Guid.Parse(data[3]));
+                    var posts = feed.Posts.OrderByDescending(p => p.ReceivedAt).Take(10).ToList();
+                    
+                    var messageTextBuilder = new StringBuilder();
+                    messageTextBuilder.Append($"Last 10 posts from {feed.Representation(ParseMode.Html)}\n");
+                    messageTextBuilder.Append("\n");
+
+                    var idx = 1;
+                    foreach (var post in posts)
+                    {
+                        messageTextBuilder.Append($"{idx}. {post}\n");
+                        idx++;
+                    }
+
+                    await Bot.SendTextMessageAsync(RawUpdate.CallbackQuery.Message.Chat, messageTextBuilder.ToString(),
+                        ParseMode.Html, true);
+                    break;
+            }
+            
+            await Bot.AnswerCallbackQueryAsync(RawUpdate.CallbackQuery.Id);
+        }
+
+        protected async Task ChangeFeedSubscription(Guid feedId, Chat chat, User from, Message message)
+        {
+            var feed = await _dbContext.FindAsync<Feed>(feedId);
+            if (feed == null)
+            {
+                return;
+            }
+
+            var subscriptionState = await _dbContext.Subscriptions.HasSubscription(chat, feed);
+            if (subscriptionState)
+            {
+                var subId = await _dbContext.Subscriptions
+                    .Where(subscriber => subscriber.Feed == feed && subscriber.SubscriberId == chat.Id)
+                    .Select(subscriber => subscriber.SubscriptionId).FirstAsync();
+                
+                _dbContext.MarkAsDeleted(_dbContext.Find<Subscriber>(subId));
+            }
+            else
+            {
+                var subscription = _dbContext.Subscriptions.Create();
+                subscription.Feed = feed;
+                subscription.SubscriberId = chat.Id;
+                
+                _dbContext.MarkAsCreated(subscription);
+            }
+
+            await _dbContext.SaveChangesAsync();
+            await ShowFeed(feed, chat, from, message);
+        }
+        
+        #endregion
+    }
+}