Restrict on negative karma

app/config.py

@@ -3,17 +3,24 @@
 """
 import os
 import secrets
+import typing
+from datetime import timedelta
+from functools import partial
 from pathlib import Path
 
+from aiogram import Bot
 from dotenv import load_dotenv
 
+from app.models.common import TypeRestriction
+
 app_dir: Path = Path(__file__).parent.parent
 load_dotenv(str(app_dir / '.env'))
 
 PLUS = "+"
-PLUS_WORDS = frozenset(
-    {"спасибо", "спс", "спасибочки", "благодарю", "пасиба", "пасеба", "посеба", "благодарочка", "thx", "мерси", "выручил"}
-)
+PLUS_WORDS = frozenset({
+    "спасибо", "спс", "спасибочки", "благодарю", "пасиба", "пасеба", "посеба",
+    "благодарочка", "thx", "мерси", "выручил",
+})
 PLUS_TRIGGERS = frozenset({PLUS, *PLUS_WORDS})
 PLUS_EMOJI = frozenset({"👍", })
 MINUS = "-"
@@ -22,6 +29,38 @@
 
 TIME_TO_CANCEL_ACTIONS = 60
 
+DEFAULT_DURATION = timedelta(hours=1)  # длительность ограничения по умолчанию
+FOREVER_DURATION = timedelta(days=666)  # длительность ограничения "навсегда"
+
+# auto restrict when karma less than NEGATIVE_KARMA_TO_RESTRICT
+ENABLE_AUTO_RESTRICT_ON_NEGATIVE_KARMA = bool(int(os.getenv("ENABLE_AUTO_RESTRICT_ON_NEGATIVE_KARMA", default=0)))
+
+NEGATIVE_KARMA_TO_RESTRICT = -100
+KARMA_AFTER_RESTRICT = -80
+
+
+class RestrictionPlanElem(typing.NamedTuple):
+    duration: timedelta
+    type_restriction: TypeRestriction
+
+
+RESTRICTIONS_PLAN: typing.List[RestrictionPlanElem] = [
+    RestrictionPlanElem(timedelta(days=7), TypeRestriction.auto_for_negative_carma),
+    RestrictionPlanElem(timedelta(days=30), TypeRestriction.auto_for_negative_carma),
+    RestrictionPlanElem(FOREVER_DURATION, TypeRestriction.ban),
+]
+
+RO_ACTION = partial(Bot.restrict_chat_member, can_send_messages=False)
+BAN_ACTION = Bot.kick_chat_member
+AUTO_RESTRICT_ACTION = RO_ACTION
+
+action_for_restrict = {
+    TypeRestriction.ban: BAN_ACTION,
+    TypeRestriction.ro: RO_ACTION,
+    TypeRestriction.auto_for_negative_carma: AUTO_RESTRICT_ACTION,
+}
+COMMENT_AUTO_RESTRICT = f"Карма ниже {NEGATIVE_KARMA_TO_RESTRICT}"
+
 PROG_NAME = "KarmaBot"
 PROG_DESC = (
     "This program is a Python 3+ script. The script launches a bot in Telegram,"

app/handlers/change_karma.py

@@ -12,8 +12,9 @@
 from app.utils.exceptions import SubZeroKarma, AutoLike
 from app.services.remove_message import remove_kb_after_sleep
 from . import keyboards as kb
-from ..services.adaptive_trottle import AdaptiveThrottle
-
+from app.services.adaptive_trottle import AdaptiveThrottle
+from app.services.moderation import TypeRestriction, it_was_last_one_auto_restrict
+from app.utils.timedelta_functions import format_timedelta
 
 a_throttle = AdaptiveThrottle()
 
@@ -37,12 +38,13 @@ async def too_fast_change_karma(message: types.Message, *_, **__):
 async def karma_change(message: types.Message, karma: dict, user: User, chat: Chat, target: User):
 
     try:
-        uk, abs_change, karma_event = await change_karma(
+        uk, abs_change, karma_event, count_auto_restrict = await change_karma(
             target_user=target,
             chat=chat,
             user=user,
             how_change=karma['karma_change'],
-            comment=karma['comment']
+            comment=karma['comment'],
+            bot=message.bot,
         )
     except SubZeroKarma:
         return await message.reply("У Вас слишком мало кармы для этого")
@@ -59,9 +61,34 @@ async def karma_change(message: types.Message, karma: dict, user: User, chat: Ch
         disable_web_page_preview=True,
         reply_markup=kb.get_kb_karma_cancel(user, karma_event)
     )
+    if count_auto_restrict:
+        await message.answer(await render_text_auto_restrict(count_auto_restrict, target))
     asyncio.create_task(remove_kb_after_sleep(msg, config.TIME_TO_CANCEL_ACTIONS))
 
 
+async def render_text_auto_restrict(count_auto_restrict: int, target: User):
+    # TODO чото надо сделать с этим чтобы понятно объяснить за что RO и что будет в следующий раз
+    if it_was_last_one_auto_restrict(count_auto_restrict):
+        about_next = ""
+    else:
+        about_next = (
+            f"Вам установлена карма {config.KARMA_AFTER_RESTRICT}. "
+            f"Если Ваша карма снова достигнет {config.NEGATIVE_KARMA_TO_RESTRICT} "
+            f"Ваш RO будет перманентный."
+        )
+    return (
+        "{target}, Уровень вашей кармы снизился ниже {negative_limit}. "
+        "За это вы попадаете в {type_restriction} на срок {duration}!\n"
+        "{about_next}".format(
+            target=target.mention_link,
+            negative_limit=config.NEGATIVE_KARMA_TO_RESTRICT,
+            type_restriction=TypeRestriction.ro.name,
+            duration=format_timedelta(config.RESTRICTIONS_PLAN[count_auto_restrict - 1]),
+            about_next=about_next,
+        )
+    )
+
+
 @dp.callback_query_handler(kb.cb_karma_cancel.filter())
 async def cancel_karma(callback_query: types.CallbackQuery, callback_data: typing.Dict[str, str]):
     if int(callback_data['user_id']) != callback_query.from_user.id:

app/handlers/moderator.py

@@ -1,22 +1,15 @@
-import typing
-from datetime import timedelta
-
 from aiogram import types
-from aiogram.utils.exceptions import BadRequest, Unauthorized
+from aiogram.utils.exceptions import Unauthorized
 from aiogram.utils.markdown import hide_link, quote_html
 from loguru import logger
 
 from app.misc import dp, bot
-from app.utils.timedelta_functions import parse_timedelta_from_text, format_timedelta
-from app.utils.exceptions import TimedeltaParseError
-from app.models import ModeratorEvent, Chat, User
+from app.utils.exceptions import TimedeltaParseError, ModerationError
+from app.models import Chat, User
 from app.services.user_info import get_user_info
-from app.services.moderation import warn_user
+from app.services.moderation import warn_user, ro_user, ban_user, get_duration
 from app.services.remove_message import delete_message
 
-FOREVER_DURATION = timedelta(days=366)
-DEFAULT_DURATION = timedelta(hours=1)
-
 
 @dp.message_handler(
     types.ChatType.is_group_or_super_group,
@@ -47,65 +40,25 @@ def need_notify_admin(admin: types.ChatMember):
     return admin.can_delete_messages or admin.can_restrict_members or admin.status == types.ChatMemberStatus.CREATOR
 
 
-def get_moderator_message_args(text: str) -> typing.Tuple[str, str]:
-    _, *args = text.split(maxsplit=2)  # in text: command_duration_comments like: "!ro 13d don't flood"
-    if not args:
-        return "", ""
-    duration_text = args[0]
-    if len(args) == 1:
-        return duration_text, ""
-    return duration_text, " ".join(args[1:])
-
-
-def get_duration(text: str):
-    duration_text, comment = get_moderator_message_args(text)
-    if duration_text:
-        duration = parse_timedelta_from_text(duration_text)
-    else:
-        duration = DEFAULT_DURATION
-    return duration, comment
-
-
 @dp.message_handler(
     commands=["ro", "mute"],
     commands_prefix="!",
     has_target=True,
     user_can_restrict_members=True,
     bot_can_restrict_members=True,
 )
-async def cmd_ro(message: types.Message, chat: Chat, user: User, target: User):
+async def cmd_ro(message: types.Message, user: User, target: User):
     try:
         duration, comment = get_duration(message.text)
     except TimedeltaParseError as e:
         return await message.reply(f"Не могу распознать время. {quote_html(e.text)}")
 
     try:
-        await message.chat.restrict(target.tg_id, can_send_messages=False, until_date=duration)
-        logger.info(
-            "User {user} restricted by {admin} for {duration}",
-            user=target.tg_id,
-            admin=user.tg_id,
-            duration=duration,
-        )
-    except BadRequest as e:
+        success_text = await ro_user(message.chat, target, user, duration, comment, message.bot)
+    except ModerationError as e:
         logger.error("Failed to restrict chat member: {error!r}", error=e)
-        return False
     else:
-        await ModeratorEvent.save_new_action(
-            moderator=user,
-            user=target,
-            chat=chat,
-            type_restriction="ro",
-            duration=duration,
-            comment=comment
-        )
-
-    await message.reply(
-        "Пользователь {user} сможет <b>только читать</b> сообщения на протяжении {duration}".format(
-            user=target.mention_link,
-            duration=format_timedelta(duration),
-        )
-    )
+        await message.reply(success_text)
 
 
 @dp.message_handler(
@@ -115,39 +68,18 @@ async def cmd_ro(message: types.Message, chat: Chat, user: User, target: User):
     user_can_restrict_members=True,
     bot_can_restrict_members=True,
 )
-async def cmd_ban(message: types.Message, chat: Chat, user: User, target: User):
+async def cmd_ban(message: types.Message, user: User, target: User):
     try:
         duration, comment = get_duration(message.text)
     except TimedeltaParseError as e:
         return await message.reply(f"Не могу распознать время. {quote_html(e.text)}")
 
     try:
-        await message.chat.kick(target.tg_id, until_date=duration)
-        logger.info(
-            "User {user} kicked by {admin} for {duration}",
-            user=target.tg_id,
-            admin=user.tg_id,
-            duration=duration,
-        )
-    except BadRequest as e:
+        success_text = await ban_user(message.chat, target, user, duration, comment, message.bot)
+    except ModerationError as e:
         logger.error("Failed to kick chat member: {error!r}", error=e)
-        return False
     else:
-        await ModeratorEvent.save_new_action(
-            moderator=user,
-            user=target,
-            chat=chat,
-            type_restriction="ban",
-            duration=duration,
-            comment=comment
-        )
-
-    text = "Пользователь {user} попал в бан этого чата.".format(
-            user=target.mention_link,
-        )
-    if duration < FOREVER_DURATION:
-        text += " Он сможет вернуться через {duration}".format(duration=format_timedelta(duration))
-    await message.reply(text)
+        await message.reply(success_text)
 
 
 @dp.message_handler(
@@ -187,7 +119,7 @@ async def get_info_about_user(message: types.Message, chat: Chat, target: User):
             disable_web_page_preview=True
         )
     except Unauthorized:
-        await message.reply("Напишите мне в личку /start и повторите команду.")
+        await message.reply(f"{message.from_user.get_mention()}, напишите мне в личку /start и повторите команду.")
     finally:
         await delete_message(message)
 

app/models/common.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class TypeRestriction(Enum):
+    ro = "ro"
+    ban = "ban"
+    warn = "warn"
+    auto_for_negative_carma = "auto_for_negative_carma"

app/models/moderator_actions.py

@@ -28,8 +28,9 @@ class Meta:
         table = 'moderator_events'
 
     def __repr__(self):
+        # noinspection PyUnresolvedReferences
         return (
-            f"KarmaEvent {self.id_} from moderator {self.moderator.id} to {self.user.id}, date {self.date}, "
+            f"ModeratorEvent {self.id_} from moderator {self.moderator_id} to {self.user_id}, date {self.date}, "
             f"type_restriction {self.type_restriction} timedelta_restriction {self.timedelta_restriction}"
         )
 
@@ -41,7 +42,8 @@ async def save_new_action(
             chat: Chat,
             type_restriction: str,
             duration: timedelta = None,
-            comment: str = ""
+            comment: str = "",
+            using_db=None,
     ):
         moderator_event = ModeratorEvent(
             moderator=moderator,
@@ -51,7 +53,7 @@ async def save_new_action(
             timedelta_restriction=duration,
             comment=comment
         )
-        await moderator_event.save()
+        await moderator_event.save(using_db=using_db)
         return moderator_event
 
     @classmethod

app/models/user.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from aiogram import types
 from aiogram.utils.markdown import hlink, quote_html
 from tortoise import fields
@@ -6,6 +8,7 @@
 
 from app.utils.exceptions import UserWithoutUserIdError
 from .chat import Chat
+from .common import TypeRestriction
 
 
 class User(Model):
@@ -17,6 +20,8 @@ class User(Model):
     is_bot: bool = fields.BooleanField(null=True)
     # noinspection PyUnresolvedReferences
     karma: fields.ReverseRelation['UserKarma']
+    # noinspection PyUnresolvedReferences
+    my_restriction_events: fields.ReverseRelation['ModeratorEvent']
 
     class Meta:
         table = "users"
@@ -116,6 +121,17 @@ async def get_number_in_top_karma(self, chat: Chat) -> int:
         uk: "UserKarma" = await self.get_uk(chat)
         return await uk.number_in_top()
 
+    async def has_now_ro(self, chat: Chat):
+        my_restrictions = await self.my_restriction_events.filter(
+            chat=chat,
+            type_restriction=TypeRestriction.ro.name
+        ).all()
+        for my_restriction in my_restrictions:
+            if my_restriction.timedelta_restriction \
+                    and my_restriction.date + my_restriction.timedelta_restriction > datetime.now():
+                return True
+        return False
+
     def to_json(self):
         return dict(
             id=self.id,