Upload core.py

core.py

@@ -0,0 +1,444 @@
+# --- START OF FILE core.py ---
+import asyncio
+import html
+import logging
+import re
+import httpx
+import io
+from datetime import datetime, timedelta, timezone
+from urllib.parse import quote 
+
+from telegram import Update, MessageOriginChannel, ChatMember, Chat, User, InlineKeyboardButton, InlineKeyboardMarkup, ChatPermissions, ReactionTypeEmoji
+from telegram.ext import ContextTypes
+from telegram.constants import ParseMode, MessageEntityType
+from telegram.error import Forbidden, BadRequest
+
+import config
+import db
+from . import utils
+from .batch import BatchDeleter 
+
+logger = logging.getLogger(__name__)
+
+# --- ১. হেল্পার ফাংশনসমূহ ---
+
+async def extract_text_with_own_api(image_bytes: bytes, api_url: str) -> str:
+    try:
+        files = {'file': ('image.jpg', image_bytes, 'image/jpeg')}
+        async with httpx.AsyncClient() as client:
+            response = await client.post(api_url, files=files, timeout=60.0)
+            if response.status_code == 200:
+                return response.json().get("extracted_text", "").strip()
+            return ""
+    except Exception as e:
+        logger.error(f"OCR API Error: {e}")
+        return ""
+
+async def scheduled_delete(context, chat_id, message_id, delay):
+    try:
+        await asyncio.sleep(delay)
+        await context.bot.delete_message(chat_id=chat_id, message_id=message_id)
+    except: pass
+
+# 🔥 আপডেট করা স্মার্ট লক (ট্রিগার মেসেজ আইডি সেভ করবে)
+async def alert_missing_permissions(context, chat_id, user_id, trigger_msg_id=None):
+    redis = utils.get_redis_client_for_chat(context, chat_id)
+    if not redis: return
+    if await redis.get(f"perm_warn:{chat_id}"): return
+    try:
+        lang = await db.get_user_lang_from_db(context, user_id)
+        msg_text = utils.get_text("deletion_fail_group_warning", lang)
+        sent = await context.bot.send_message(chat_id, msg_text, parse_mode='HTML')
+        
+        await redis.set(f"perm_warn:{chat_id}", "1", ex=3600)
+        await redis.set(f"perm_warn_msg_id:{chat_id}", str(sent.message_id), ex=3600)
+        # যে লিংকটি ডিলিট করতে পারেনি সেটিও সেভ রাখা হলো
+        if trigger_msg_id:
+            await redis.set(f"perm_trigger_msg_id:{chat_id}", str(trigger_msg_id), ex=3600)
+    except: pass
+
+# --- ২. ডিলিট করার মূল লজিক ---
+
+async def process_deletion_and_tasks(context, user, chat, msg_id, settings, reason_keys, content):
+    batch_deleter = context.bot_data.get('batch_deleter')
+    if batch_deleter:
+        await batch_deleter.delete(chat.id, msg_id)
+    else:
+        try:
+            await context.bot.delete_message(chat.id, msg_id)
+        except BadRequest as e:
+            if "not found" not in str(e).lower():
+                asyncio.create_task(alert_missing_permissions(context, chat.id, user.id, msg_id))
+        except Forbidden:
+            asyncio.create_task(alert_missing_permissions(context, chat.id, user.id, msg_id))
+    
+    asyncio.create_task(_background_processing(context, user, chat, settings, reason_keys, content))
+
+async def _background_processing(context, user, chat, settings, reason_keys, content):
+    redis_client = utils.get_redis_client_for_chat(context, chat.id)
+    is_join_leave = 'censor_reason_join_leave' in reason_keys
+    is_bot_link = False
+    
+    if 'censor_reason_link' in reason_keys or 'censor_reason_bio_link' in reason_keys:
+        if re.search(r'(@[\w_]+bot\b|(?:t\.me|telegram\.me)\/[\w_]+bot\b)', content, re.IGNORECASE):
+            is_bot_link = True
+
+    if not is_join_leave and not is_bot_link:
+        if re.search(r'(?:t\.me|telegram\.me)', content, re.IGNORECASE) or 'censor_reason_word' in reason_keys:
+            asyncio.create_task(utils.send_deletion_report(context, user, chat, reason_keys[0], content))
+
+        await utils.update_user_activity_score(context, chat.id, user.id, 'deletion', reason_keys, content)
+        
+        if settings.get('mute_on_link_24_h', False) and ('censor_reason_link' in reason_keys or 'censor_reason_bio_link' in reason_keys):
+            try:
+                mute_until = datetime.now(timezone.utc) + timedelta(hours=24)
+                await context.bot.restrict_chat_member(chat.id, user.id, ChatPermissions(can_send_messages=False), until_date=mute_until)
+            except: pass
+
+        if redis_client:
+            cooldown_key = f"warn_cooldown:{chat.id}:{user.id}"
+            if not await redis_client.get(cooldown_key):
+                try:
+                    lang = await db.get_user_lang_from_db(context, user.id)
+                    reason_msg = utils.get_text(reason_keys[0], lang)
+                    warn_text = utils.get_text("censor_warning", lang).format(user_mention=user.mention_html(), reason=reason_msg, bot_username=context.bot.username)
+                    sent_warn = await context.bot.send_message(chat.id, warn_text, parse_mode=ParseMode.HTML)
+                    await redis_client.set(cooldown_key, "1", ex=600)
+                    asyncio.create_task(utils.delete_message_after_delay(context, chat.id, sent_warn.message_id, config.CENSOR_WARNING_DELETE_SECONDS))
+                except: pass
+
+async def process_image_with_ocr_in_background(context, chat_id, user_id, message_id, image_bytes):
+    try:
+        ocr_semaphore = context.bot_data.get('ocr_semaphore')
+        async with ocr_semaphore: 
+            ocr_text = await extract_text_with_own_api(image_bytes, config.OCR_API_URL)
+        if ocr_text:
+            normalized_text = re.sub(r'\s+', '', ocr_text).lower()
+            if config.LINK_PATTERN_COMPILED.search(ocr_text) or any(indicator in normalized_text for indicator in config.LINK_INDICATOR_KEYWORDS):
+                settings = await utils.get_settings_from_cache_and_update_regex(context, chat_id)
+                try:
+                    chat_obj = await context.bot.get_chat(chat_id)
+                    member = await context.bot.get_chat_member(chat_id, user_id)
+                    asyncio.create_task(process_deletion_and_tasks(context, member.user, chat_obj, message_id, settings, ['censor_reason_link'], ocr_text))
+                except: pass
+    except: pass
+
+# --- ৩. প্রধান মেসেজ হ্যান্ডেলার ---
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    msg, chat, user = update.effective_message, update.effective_chat, update.effective_user
+    if not all([msg, chat, user]): return
+
+    redis = utils.get_redis_client_for_chat(context, chat.id)
+    if redis and await redis.get(f"perm_warn:{chat.id}"): return
+
+    is_bot_admin = await utils.is_group_admin(context, chat.id, context.bot.id)
+    if not is_bot_admin and chat.type != 'private':
+        asyncio.create_task(alert_missing_permissions(context, chat.id, user.id, msg.message_id))
+        return 
+
+    if chat.type == 'private':
+        if not user.is_bot and not msg.new_chat_members: 
+            asyncio.create_task(db.buffer_user_stats(context, user.id, user.first_name, user.username))
+        return
+
+    if msg.new_chat_members:
+        is_adder_admin = await utils.is_group_admin(context, chat.id, user.id)
+        for member in msg.new_chat_members:
+            if member.is_bot and member.id != context.bot.id and not is_adder_admin:
+                try:
+                    await context.bot.ban_chat_member(chat.id, member.id)
+                    await msg.delete()
+                    return 
+                except: pass
+
+    is_edit = update.edited_message is not None
+    asyncio.create_task(db.track_chat_member(context.bot_data.get('db_pool'), chat.id, user.id))
+    if not is_edit:
+        asyncio.create_task(db.buffer_user_stats(context, user.id, user.first_name, user.username))
+    
+    settings = await utils.get_settings_from_cache_and_update_regex(context, chat.id)
+    owner_id = await utils.get_group_owner_id(context, chat.id)
+    is_exempt = (user.id == owner_id) or (user.id == context.bot_data.get('BOT_OWNER_ID')) or (settings.get('allow_admins_manage') and await utils.is_group_admin(context, chat.id, user.id))
+
+    if is_exempt and not settings.get('enable_traffic_control', False): return
+    if settings.get('enable_traffic_control', False): asyncio.create_task(utils.check_traffic_control(context, chat.id))
+    if is_exempt: return
+
+    # --- লিংক এবং মেনশন স্মার্ট চেক ---
+    text_content = (msg.text or msg.caption or "").strip()
+    # --- লিংক এবং মেনশন স্মার্ট চেক ---
+    # আগে শুধু text_content চেক হতো, এখন পুরো 'msg' অবজেক্ট পাঠাবো
+    is_link = utils.has_link_in_text(msg) 
+    
+    # মেনশন বা ইউজারনেম চেক
+    if not is_link:
+        text_content = (msg.text or msg.caption or "").strip()
+        entities = msg.entities or msg.caption_entities or []
+        
+        # এনটিটির ভেতর মেনশন আছে কি না দেখা
+        has_mention_entity = any(ent.type in [MessageEntityType.MENTION, MessageEntityType.TEXT_MENTION] for ent in entities)
+        
+        if has_mention_entity:
+            if not settings.get('allow_usernames', False):
+                is_link = True # ইউজারনেম এলাউ না থাকলে ডিলিট হবে
+            else:
+                # যদি এলাউ থাকে কিন্তু সেটি চ্যানেল কি না চেক করা
+                mentions = config.MENTION_PATTERN_COMPILED.findall(text_content)
+                for mention in mentions:
+                    if await utils.is_channel_or_group_username(context, mention):
+                        is_link = True
+                        break
+
+        # --- ১৮৫-১৯২ এর পর যেখানে violations চেক শুরু হবে ---
+    violations = []
+    
+    # ১. লিংক ভায়োলেশন অ্যাড করা (এটি যোগ করা জরুরি)
+    if is_link:
+        violations.append(('link', 'censor_reason_link'))
+
+    # ২. নিষিদ্ধ শব্দ চেক
+    if (fw_regex := settings.get('fw_regex')) and fw_regex.search(text_content): 
+        violations.append(('word', 'censor_reason_word'))
+    
+    # ৩. ফরোয়ার্ড মেসেজ চেক
+    if settings.get('block_channel_forwards') and isinstance(msg.forward_origin, MessageOriginChannel): 
+        violations.append(('forward', 'censor_reason_forward'))
+
+    # ৪. কাউন্টার এবং মিউট লজিক (সবার জন্য)
+    if violations:
+        if redis:
+            spam_key = f"spam_violation_counter:{chat.id}:{user.id}"
+            current_count = await redis.incr(spam_key)
+            if current_count == 1: 
+                await redis.expire(spam_key, 600) # ১০ মিনিট
+            
+            if current_count >= 11:
+                try: 
+                    # পারমানেন্ট মিউট
+                    await context.bot.restrict_chat_member(chat.id, user.id, ChatPermissions(can_send_messages=False))
+                except: pass
+
+        # ডিলিট এবং রিপোর্ট পাঠানোর টাস্ক
+        asyncio.create_task(process_deletion_and_tasks(context, user, chat, msg.message_id, settings, [v[1] for v in violations], text_content))
+        return
+
+    # --- স্প্যাম স্ক্যানার (ওনার মেনশন ও বাটন জাম্প লিঙ্ক) ---
+    if settings.get('enable_spamscan') and config.SPAM_PHRASES_COMPILED.search(text_content):
+        try:
+            # ১. স্মার্ট জাম্প লিঙ্ক তৈরি (সরাসরি আসল স্প্যাম মেসেজে যাওয়ার জন্য)
+            if chat.username:
+                jump_url = f"https://t.me/{chat.username}/{msg.message_id}"
+            else:
+                chat_id_clean = str(chat.id).replace("-100", "")
+                jump_url = f"https://t.me/c/{chat_id_clean}/{msg.message_id}"
+            
+            # ২. গ্রুপ ওনারকে খুঁজে বের করা (যাতে নোটিফিকেশন যায়)
+            owner_id = await utils.get_group_owner_id(context, chat.id)
+            mention_text = ""
+            if owner_id:
+                # ওনারের আইডি দিয়ে লিঙ্ক তৈরি, এতে 100% নোটিফিকেশন বাজবে
+                mention_text = f"📢 <b>Attention:</b> <a href='tg://user?id={owner_id}'>Admin</a>\n"
+            
+            # ৩. ক্লিন অ্যালার্ট টেক্সট
+            warn_text = f"🚨 <b>Spam Alert!</b>\n{mention_text}⚠️ একটি স্প্যাম মেসেজ পাওয়া গেছে।"
+            
+            # ৪. বাটন সেটআপ (এখানে ব্র্যাকেট ফিক্স করা হয়েছে)
+            btns = [[InlineKeyboardButton("👀 View Message", url=jump_url)],[InlineKeyboardButton("🔇 Mute & Delete", callback_data=f"spam_act_mute_{user.id}_{msg.message_id}"), 
+                 InlineKeyboardButton("❌ Cancel", callback_data="spam_act_cancel")]
+            ]
+            
+            # ৫. মেসেজ পাঠানো (কোনো রিপ্লাই বা নীল বক্স আসবে না)
+            await context.bot.send_message(
+                chat_id=chat.id,
+                text=warn_text,
+                parse_mode=ParseMode.HTML,
+                reply_markup=InlineKeyboardMarkup(btns),
+                disable_web_page_preview=True
+            )
+
+        except Exception as e:
+            logger.error(f"Spam Scan Error: {e}")
+        return
+
+    if settings.get('enable_sentiment', False) and text_content:
+        senti = await asyncio.to_thread(utils.analyze_sentiment, text_content)
+        if senti:
+            try: await msg.set_reaction(reaction=[ReactionTypeEmoji("❤️" if senti == 'positive' else "👎")])
+            except: pass
+
+    if settings.get('block_bio_links', True):
+        bio_status_key = f"bio_status:{user.id}"
+        cached_bio = await redis.get(bio_status_key) if redis else None
+        if cached_bio == "bad":
+            asyncio.create_task(process_deletion_and_tasks(context, user, chat, msg.message_id, settings, ['censor_reason_bio_link'], "Bio contains links (cached)"))
+            return
+        if not cached_bio:
+            async with context.bot_data.get('api_semaphore'):
+                try:
+                    profile = await context.bot.get_chat(user.id)
+                    if profile.bio and utils.has_link_in_text(profile.bio):
+                        if redis: await redis.set(bio_status_key, "bad", ex=600)
+                        asyncio.create_task(process_deletion_and_tasks(context, user, chat, msg.message_id, settings, ['censor_reason_bio_link'], f"Bio: {profile.bio}"))
+                        return
+                    if redis: await redis.set(bio_status_key, "safe", ex=600)
+                except: pass
+
+    if settings.get('delete_join_messages') and (msg.new_chat_members or msg.left_chat_member): 
+        asyncio.create_task(process_deletion_and_tasks(context, user, chat, msg.message_id, settings, ['censor_reason_join_leave'], "Join/Leave message"))
+        return
+
+    if text_content:
+        filters_cache = await db.get_chat_filters(context, chat.id)
+        for keyword, fdata in filters_cache.items():
+            if keyword in text_content.lower():
+                args = {'chat_id': chat.id, 'reply_to_message_id': msg.message_id}
+                if fdata['type'] == 'photo': await context.bot.send_photo(photo=fdata['file_id'], caption=fdata['text'], **args)
+                else: await context.bot.send_message(text=fdata['text'], parse_mode=ParseMode.HTML, **args)
+                return
+        if text_content.startswith('#'):
+            if note_data := await db.get_note_from_db(context, chat.id, text_content.split(' ')[0][1:].lower()):
+                await context.bot.send_message(chat.id, note_data['text'], parse_mode=ParseMode.HTML, reply_to_message_id=msg.message_id)
+
+    auto_del = settings.get('auto_delete_seconds', 0)
+    if auto_del > 0:
+        is_media = (msg.photo or msg.video or msg.document or msg.voice or msg.audio or msg.sticker or msg.animation or msg.video_note)
+        if is_media: asyncio.create_task(scheduled_delete(context, chat.id, msg.message_id, auto_del))
+                
+    if settings.get('enable_ocr_scan') and msg.photo and config.OCR_API_URL:
+        try:
+            photo_file = await msg.photo[-1].get_file()
+            photo_bytes = await photo_file.download_as_bytearray()
+            asyncio.create_task(process_image_with_ocr_in_background(context, chat_id, user.id, msg.message_id, bytes(photo_bytes)))
+        except: pass
+
+# --- ৮. মেম্বার ও বটের স্ট্যাটাস হ্যান্ডেলার ---
+
+async def handle_member_status_change(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    if not update.chat_member: return
+    chat = update.chat_member.chat
+    user = update.chat_member.new_chat_member.user
+    new_status = update.chat_member.new_chat_member.status
+    old_status = update.chat_member.old_chat_member.status
+    redis = utils.get_redis_client_for_chat(context, chat.id)
+    
+    if redis:
+        if new_status in [ChatMember.ADMINISTRATOR, ChatMember.OWNER]: 
+            await redis.set(f"is_admin:{chat.id}:{user.id}", "1", ex=86400)
+        else: 
+            await redis.set(f"is_admin:{chat.id}:{user.id}", "0", ex=86400)
+        await redis.delete(f"bio_status:{user.id}")
+        if new_status == ChatMember.OWNER: 
+            await redis.set(f"group_owner:{chat.id}", str(user.id), ex=86400)
+
+    if new_status == ChatMember.MEMBER and old_status not in [ChatMember.MEMBER, ChatMember.ADMINISTRATOR, ChatMember.OWNER] and not user.is_bot:
+        await db._add_user_to_db_core(context.bot_data.get('db_pool'), user.id, user.first_name, user.username)
+        
+        try:
+            settings = await utils.get_settings_from_cache_and_update_regex(context, chat.id)
+            welcome_data = settings.get('welcome_data') or {}
+            
+            if redis:
+                last_msg_id = await redis.get(f"last_welcome_msg:{chat.id}")
+                if last_msg_id:
+                    try: await context.bot.delete_message(chat.id, int(last_msg_id))
+                    except: pass
+
+            raw_text = welcome_data.get('text') or (
+                "👋 <b>Welcome {name} to our Group!</b>\n\n"
+                "🛡️ I am your <b>Group Protector</b>. I will keep this chat safe from spam.\n"
+                "📝 Please follow the rules to avoid being muted or banned."
+            )
+            welcome_text = raw_text.replace("{name}", user.mention_html())
+            
+            # --- স্মার্ট বাটন জেনারেট লজিক (এনকোডিং ফিক্স সহ) ---
+            buttons_list = welcome_data.get('buttons', [])
+            keyboard = []
+            for i, btn in enumerate(buttons_list):
+                btn_name = btn['name']
+                btn_content = btn['content'].strip()
+                
+                if btn_content.startswith('share:'):
+                    # এনকোডিং ফিক্সের জন্য quote ইমপোর্ট করা হলো
+                    from urllib.parse import quote
+                    link_to_share = btn_content.replace('share:', '').strip()
+                    share_url = f"https://t.me/share/url?url={quote(link_to_share)}"
+                    keyboard.append([InlineKeyboardButton(btn_name, url=share_url)])
+                
+                elif btn_content.startswith('http'):
+                    keyboard.append([InlineKeyboardButton(btn_name, url=btn_content)])
+                
+                else:
+                    keyboard.append([InlineKeyboardButton(btn_name, callback_data=f"w_pop_{i}")])
+            
+            reply_markup = InlineKeyboardMarkup(keyboard) if keyboard else None
+            sent = None
+            
+            if settings.get('welcome_mode', 'text') == 'card':
+                photos = await user.get_profile_photos(limit=1)
+                pfp = None
+                if photos.total_count > 0:
+                    try:
+                        pfp_file = await photos.photos[0][-1].get_file()
+                        pfp = bytes(await pfp_file.download_as_bytearray())
+                    except: pfp = None
+                
+                card = await utils.generate_welcome_card(user.first_name, pfp)
+                if card: 
+                    sent = await context.bot.send_photo(chat.id, photo=card, caption=welcome_text, parse_mode=ParseMode.HTML, reply_markup=reply_markup)
+            
+            if not sent:
+                sent = await context.bot.send_message(chat.id, text=welcome_text, parse_mode=ParseMode.HTML, disable_web_page_preview=True, reply_markup=reply_markup)
+            
+            if sent and redis:
+                await redis.set(f"last_welcome_msg:{chat.id}", sent.message_id)
+                ds = welcome_data.get('delete_seconds', 0)
+                if ds > 0:
+                    asyncio.create_task(utils.delete_message_after_delay(context, chat.id, sent.message_id, ds))
+        
+        except Exception as e:
+            logger.error(f"Welcome Error: {e}")
+
+# 🔥 অটো আনলক ও অটো-ডিলিট ট্রিগার মেসেজ
+async def handle_bot_status_change(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    result = update.my_chat_member
+    if not result: return
+    chat = result.chat
+    new_status = result.new_chat_member.status
+    pool = context.bot_data.get('db_pool')
+    
+    if new_status in [ChatMember.MEMBER, ChatMember.ADMINISTRATOR]:
+        await db._add_chat_to_db_core(pool, chat.id)
+        if new_status == ChatMember.ADMINISTRATOR:
+            redis = utils.get_redis_client_for_chat(context, chat.id)
+            if redis:
+                # ১. বটের নিজের Admin Status Cache আপডেট করা (যাতে সাথে সাথে কাজ শুরু করে)
+                await redis.set(f"is_admin:{chat.id}:{context.bot.id}", "1", ex=86400)
+                
+                # ২. পারমিশন ওয়ার্নিং লক রিলিজ করা
+                await redis.delete(f"perm_warn:{chat.id}")
+                
+                # ৩. আগের ওয়ার্নিং মেসেজ ডিলিট করা
+                if (last_warn := await redis.get(f"perm_warn_msg_id:{chat.id}")):
+                    try:
+                        await context.bot.delete_message(chat.id, int(last_warn))
+                        await redis.delete(f"perm_warn_msg_id:{chat.id}")
+                    except: pass
+                
+                # ৪. 🔥 যে লিংকটির কারণে পারমিশন এরর এসেছিল সেটি ডিলিট করা
+                if (trigger_link_id := await redis.get(f"perm_trigger_msg_id:{chat.id}")):
+                    try:
+                        await context.bot.delete_message(chat.id, int(trigger_link_id))
+                        await redis.delete(f"perm_trigger_msg_id:{chat.id}")
+                    except: pass
+            
+    elif new_status in [ChatMember.LEFT, ChatMember.KICKED, ChatMember.BANNED]:
+        if pool:
+            try:
+                async with pool.acquire() as conn: await conn.execute("DELETE FROM chats WHERE chat_id = $1", chat.id)
+            except: pass
+
+async def handle_edited_message(update, context): 
+    await handle_message(update, context)
+
+# --- END OF FILE ---