"""
File View Handler Module
========================
מודול לניהול תצוגת קבצים וקוד בבוט טלגרם.
מודול זה מספק פונקציונליות ל:
- הצגת קבצי קוד
- עריכת קבצים
- ניהול גרסאות
- ייצוא קבצים
"""
import logging
import re
from io import BytesIO
import inspect
from datetime import datetime, timezone
from typing import List, Optional
import secrets
from html import escape as html_escape
from urllib.parse import quote_plus
from utils import TelegramUtils, TextUtils, ValidationUtils
# מודול שורש טהור: כתובת ה-WebApp, בלי ברירת מחדל — ``None`` כשהמשתנה חסר או פגום.
from webapp_url import webapp_base_url
async def _edit_message_text_unified(query, text: str, *, reply_markup=None, parse_mode=None):
"""Edit message text using query.edit_message_text when available, otherwise fallback to TelegramUtils.safe_edit_message_text.
This keeps tests that stub only one path working and unifies behavior.
"""
try:
if hasattr(query, 'edit_message_text') and callable(getattr(query, 'edit_message_text')):
return await query.edit_message_text(text, reply_markup=reply_markup, parse_mode=parse_mode)
else:
return await TelegramUtils.safe_edit_message_text(query, text, reply_markup=reply_markup, parse_mode=parse_mode)
except Exception:
# last resort — try the other path once
try:
return await TelegramUtils.safe_edit_message_text(query, text, reply_markup=reply_markup, parse_mode=parse_mode)
except Exception:
return await query.edit_message_text(text)
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, ReplyKeyboardMarkup
from telegram.constants import ParseMode
from telegram.ext import ContextTypes, ConversationHandler
from handlers.states import EDIT_CODE, EDIT_NAME
from services import code_service
logger = logging.getLogger(__name__)
# Injection hook for tests: set to an instance providing the FilesFacade API
FILES_FACADE = None
def _sanitize_codeblock_language_tag(language: Optional[str]) -> str:
"""מחזיר תג שפה בטוח ל-```lang ב-MarkdownV2 (כדי לקבל תווית שפה + הדגשת תחביר בצד הלקוח)."""
try:
lang_tag = str(language or "").strip().lower()
except Exception:
lang_tag = ""
# מיפוי מינימלי לערכים נפוצים/היסטוריים
alias = {
"c#": "csharp",
"cs": "csharp",
"csharp": "csharp",
"c++": "cpp",
"cpp": "cpp",
"py": "python",
"python3": "python",
"js": "javascript",
"ts": "typescript",
"sh": "bash",
"shell": "bash",
}
lang_tag = alias.get(lang_tag, lang_tag)
# Telegram: שמור רק תווים בטוחים; אם יצא ריק — fallback עקבי
try:
lang_tag = re.sub(r"[^a-z0-9#+-]+", "", lang_tag)
except Exception:
lang_tag = ""
return lang_tag or "text"
def _sanitize_codeblock_content_for_markdown_v2(code: str) -> str:
"""מונע סגירה מוקדמת של בלוק ``` ב-Telegram ע"י פירוק הרצף ``` בתוך התוכן."""
try:
text = str(code or "")
except Exception:
return ""
# אם מופיע ``` בתוך הקוד, הוא יסגור את הבלוק. נשבור את הרצף בעזרת תו Zero‑Width Space.
# זה שומר קריאות גבוהה ומונע נפילות "אקראיות" ל-HTML.
try:
return text.replace("```", "``\u200b`")
except Exception:
return text
def _get_webapp_button_row(file_id: Optional[str], file_name: Optional[str] = None) -> Optional[List[InlineKeyboardButton]]:
"""בונה שורת כפתור WebApp עבור מזהה קובץ או fallback לפי שם — או ``None`` כשאין כתובת ל-WebApp.
המימוש היחיד: ``conversation_handlers`` מייבא אותו מכאן.
"""
base_url = webapp_base_url()
if not base_url:
return None
target_url: Optional[str]
if file_id:
target_url = f"{base_url}/file/{file_id}"
elif file_name:
try:
query = quote_plus(str(file_name))
except Exception:
query = str(file_name)
target_url = f"{base_url}/files?q={query}#results"
else:
target_url = None
if not target_url:
return None
try:
return [InlineKeyboardButton("🌐 צפייה בWebApp", url=target_url)]
except TypeError:
# בסביבות בדיקה ייתכן שהכפתור לא תומך בפרמטר url
return None
def _get_files_facade():
"""
מחזיר את ה-FilesFacade עם נפילה חכמה לגרסה שמוזרקת בטסטים.
קודם ננסה את ה-Composition Root, ואם נכשל/לא זמין ננסה פונקציה גלובלית שמוקפצת בטסטים.
"""
# עדיפות עליונה: אובייקט מוזרק ישירות (לשימוש בטסטים)
try:
injected = globals().get("FILES_FACADE")
if injected is not None:
return injected
except Exception:
pass
# עדיפות ראשונה: פונקציה גלובלית שמוקפצת בטסטים (monkeypatch על handlers.file_view.get_files_facade)
try:
gf = globals().get("get_files_facade")
if callable(gf):
inst = gf()
if inst:
return inst
except Exception:
pass
try:
from src.infrastructure.composition import get_files_facade as _gff # type: ignore
facade = _gff()
if facade:
return facade
except Exception:
pass
return None
def _get_main_keyboard() -> list:
"""
מחזיר את פריסת המקלדת הראשית.
Returns:
list: רשימת כפתורי המקלדת הראשית
Note:
מחזיר רשימה ריקה במקרה של שגיאה
"""
try:
from conversation_handlers import MAIN_KEYBOARD
return MAIN_KEYBOARD
except Exception:
return [[]]
async def _call_service_method(service, method_name, *args, **kwargs):
"""
קריאה בטוחה לפעולה אסינכרונית/סינכרונית של השירות (לשימוש מול Composition Root).
"""
if not service:
return None
method = getattr(service, method_name, None)
if not callable(method):
return None
try:
result = method(*args, **kwargs)
if inspect.isawaitable(result):
return await result
return result
except Exception:
return None
[תיעוד]
async def handle_file_menu(update, context: ContextTypes.DEFAULT_TYPE) -> int:
"""
מציג תפריט פעולות עבור קובץ נבחר.
Args:
update: אובייקט Update מטלגרם
context: הקונטקסט של השיחה
Returns:
int: מצב השיחה החדש
Note:
מציג אפשרויות כמו הצגה, עריכה, מחיקה ושיתוף
"""
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[1]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בזיהוי הקובץ החכם")
return ConversationHandler.END
file_name = file_data.get('file_name', 'קובץ מיסתורי')
language = file_data.get('programming_language', 'לא ידועה')
try:
file_id_str = str(file_data.get('_id') or '')
except Exception:
file_id_str = ''
# קבע כפתור חזרה בהתאם למקור (מועדפים/רגיל/אחר)
last_page = context.user_data.get('files_last_page')
origin = context.user_data.get('files_origin') or {}
if origin.get('type') == 'by_repo' and origin.get('tag'):
back_cb = f"by_repo:{origin.get('tag')}"
elif origin.get('type') == 'favorites':
back_cb = f"favorites_page_{last_page}" if last_page else "show_favorites"
elif origin.get('type') == 'regular':
back_cb = f"files_page_{last_page}" if last_page else "show_regular_files"
else:
back_cb = f"back_after_view:{file_name}"
# הערה: לוגיקת ה־back כבר חושבה למעלה – אין לשכפל כדי לא לדרוס ערך
webapp_row = _get_webapp_button_row(file_id_str, file_name)
share_row = list(webapp_row) if webapp_row else []
share_row.append(InlineKeyboardButton("🔗 שתף קוד", callback_data=f"share_menu_idx:{file_index}"))
keyboard = [
[
InlineKeyboardButton("✏️ ערוך", callback_data=f"edit_code_{file_index}"),
InlineKeyboardButton("👁️ הצג קוד", callback_data=f"view_{file_index}"),
],
[
InlineKeyboardButton("📝 ערוך הערה", callback_data=f"edit_note_{file_index}"),
InlineKeyboardButton("📝 שנה שם", callback_data=f"edit_name_{file_index}"),
],
share_row,
[
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_{file_index}"),
InlineKeyboardButton("📥 הורד", callback_data=f"dl_{file_index}"),
],
[
InlineKeyboardButton("🔄 שכפול", callback_data=f"clone_{file_index}"),
InlineKeyboardButton("🗑️ מחק", callback_data=f"del_{file_index}"),
],
]
last_page = context.user_data.get('files_last_page')
origin = context.user_data.get('files_origin') or {}
# קביעה אחידה של יעד כפתור "חזרה" לפי מקור הרשימה
if origin.get('type') == 'by_repo' and origin.get('tag'):
back_cb = f"by_repo:{origin.get('tag')}"
elif origin.get('type') == 'favorites':
back_cb = f"favorites_page_{last_page}" if last_page else "show_favorites"
elif origin.get('type') == 'regular':
back_cb = f"files_page_{last_page}" if last_page else "show_regular_files"
else:
# ברירת מחדל: חזרה לתפריט הקבצים, לא לולאה של אותו מסך
back_cb = f"files_page_{last_page}" if last_page else "files"
keyboard.append([InlineKeyboardButton("🔙 חזרה לרשימה", callback_data=back_cb)])
note = file_data.get('description') or ''
if note:
try:
safe_note_md = TextUtils.escape_markdown(note, version=1)
except Exception:
safe_note_md = str(note).replace('`', '\\`').replace('*', '\\*').replace('_', '\\_')
note_line = f"\n📝 הערה: {safe_note_md}\n\n"
else:
note_line = "\n📝 הערה: —\n\n"
# הוסף כפתור מועדפים גם במסך "מרכז בקרה מתקדם"
try:
from src.infrastructure.composition import get_files_facade # type: ignore
is_fav_now = bool(get_files_facade().is_favorite(update.effective_user.id, file_name))
except Exception:
is_fav_now = False
fav_text = ("💔 הסר ממועדפים" if is_fav_now else "⭐ הוסף למועדפים")
raw_id = file_id_str
if raw_id and (len("fav_toggle_id:") + len(raw_id)) <= 60:
fav_cb = f"fav_toggle_id:{raw_id}"
else:
try:
tok = secrets.token_urlsafe(6)
except Exception:
tok = "t"
short_tok = (tok[:24] if isinstance(tok, str) else "t")
try:
tokens_map = context.user_data.get('fav_tokens') or {}
tokens_map[short_tok] = file_name
context.user_data['fav_tokens'] = tokens_map
except Exception:
pass
fav_cb = f"fav_toggle_tok:{short_tok}"
# הוסף שורת מועדפים לפני היסטוריה/הורדה
keyboard.insert(3, [InlineKeyboardButton(fav_text, callback_data=fav_cb)])
reply_markup = InlineKeyboardMarkup(keyboard)
await TelegramUtils.safe_edit_message_text(
query,
f"🎯 *מרכז בקרה מתקדם*\n\n"
f"📄 **קובץ:** `{file_name}`\n"
f"🧠 **שפה:** {language}{note_line}"
f"🎮 בחר פעולה מתקדמת:",
reply_markup=reply_markup,
parse_mode='Markdown',
)
except Exception as e:
logger.error(f"Error in handle_file_menu: {e}")
await TelegramUtils.safe_edit_message_text(query, "💥 שגיאה במרכז הבקרה המתקדם")
return ConversationHandler.END
[תיעוד]
async def handle_view_file(update, context: ContextTypes.DEFAULT_TYPE) -> int:
"""Display file content with actions (edit, history, download)."""
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[1]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await TelegramUtils.safe_edit_message_text(query, "⚠️ הקובץ נעלם מהמערכת החכמה")
return ConversationHandler.END
file_name = file_data.get('file_name', 'קובץ')
code = file_data.get('code', '')
language = file_data.get('programming_language', 'text')
version = file_data.get('version', 1)
try:
file_id_str = str(file_data.get('_id') or '')
except Exception:
file_id_str = ''
# טעינת קוד עצלה: אם ברשימות שמרנו רק מטא־דאטה ללא code, שלוף גרסה אחרונה מה-DB
if not code:
# נסה קודם דרך שכבת האפליקציה (Composition Root), נפילה ל-DB ישיר לתאימות
user_id = update.effective_user.id
loaded = False
try:
from src.infrastructure.composition import get_snippet_service # type: ignore
svc = get_snippet_service()
snippet = await _call_service_method(svc, "get_snippet", user_id, file_name)
if snippet:
code = getattr(snippet, "code", "") or ""
language = getattr(snippet, "language", language) or language
version = getattr(snippet, "version", version) or version
loaded = True
except Exception:
loaded = False
if not loaded:
try:
from src.infrastructure.composition import get_files_facade # type: ignore
latest_doc = get_files_facade().get_latest_version(user_id, file_name)
if latest_doc:
code = latest_doc.get('code', '') or ''
language = latest_doc.get('programming_language', language) or language
version = latest_doc.get('version', version) or version
try:
file_id_str = str(latest_doc.get('_id') or file_id_str)
except Exception:
pass
loaded = True
except Exception:
pass
if loaded:
# עדכן cache לזיהוי חזרה/המשך "הצג עוד"
try:
files_cache[str(file_index)] = dict(file_data, code=code, programming_language=language, version=version)
context.user_data['files_cache'] = files_cache
except Exception:
pass
# אם השפה שמורה כ-text/ריקה או (markdown עם תוכן שהוא קוד ברור) – נזהה מחדש להצגה דרך מקור אחיד
try:
lang_lower = str(language or "").lower()
file_name_lower = str(file_name or "").lower()
is_md_name = file_name_lower.endswith((".md", ".markdown", ".mdown", ".mkd", ".mkdn"))
if (not lang_lower) or lang_lower == "text" or (lang_lower == "markdown" and is_md_name):
new_lang = code_service.detect_language(code, file_name)
if new_lang and new_lang != language:
language = new_lang
# עדכן cache לשימוש בהמשך
try:
files_cache[str(file_index)] = dict(file_data, programming_language=language)
context.user_data['files_cache'] = files_cache
except Exception:
pass
except Exception:
pass
max_length = 3500
code_preview = code[:max_length]
last_page = context.user_data.get('files_last_page')
origin = context.user_data.get('files_origin') or {}
# קביעה אחידה של יעד כפתור "חזרה" לפי מקור הרשימה
if origin.get('type') == 'by_repo' and origin.get('tag'):
back_cb = f"by_repo:{origin.get('tag')}"
elif origin.get('type') == 'favorites':
back_cb = f"favorites_page_{last_page}" if last_page else "show_favorites"
elif origin.get('type') == 'regular':
back_cb = f"files_page_{last_page}" if last_page else "show_regular_files"
else:
# ברירת מחדל: חזרה לתפריט הקבצים, לא לולאה של אותו מסך
back_cb = f"files_page_{last_page}" if last_page else "files"
keyboard = [
[
InlineKeyboardButton("✏️ ערוך קוד", callback_data=f"edit_code_{file_index}"),
InlineKeyboardButton("📝 ערוך שם", callback_data=f"edit_name_{file_index}"),
],
[
InlineKeyboardButton("📝 ערוך הערה", callback_data=f"edit_note_{file_index}"),
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_{file_index}"),
],
[
InlineKeyboardButton("📥 הורד", callback_data=f"dl_{file_index}"),
InlineKeyboardButton("🔄 שכפול", callback_data=f"clone_{file_index}"),
],
[InlineKeyboardButton("🔙 חזרה", callback_data=back_cb)],
]
webapp_row = _get_webapp_button_row(file_id_str or None, file_name)
share_row = list(webapp_row) if webapp_row else []
share_row.append(InlineKeyboardButton("🔗 שתף קוד", callback_data=f"share_menu_idx:{file_index}"))
keyboard.insert(3, share_row)
# כפתור מועדפים (הוסף/הסר) לפי המצב הנוכחי
try:
from src.infrastructure.composition import get_files_facade # type: ignore
is_fav_now = bool(get_files_facade().is_favorite(update.effective_user.id, file_name))
except Exception:
is_fav_now = False
fav_text = ("💔 הסר ממועדפים" if is_fav_now else "⭐ הוסף למועדפים")
# בנה callback בטוח: העדף מזהה מסד אם קיים, אחרת טוקן קצר במיפוי זמני
raw_id = file_id_str
if raw_id and (len("fav_toggle_id:") + len(raw_id)) <= 60:
fav_cb = f"fav_toggle_id:{raw_id}"
else:
try:
tok = secrets.token_urlsafe(6)
except Exception:
tok = "t"
short_tok = (tok[:24] if isinstance(tok, str) else "t")
try:
tokens_map = context.user_data.get('fav_tokens') or {}
tokens_map[short_tok] = file_name
context.user_data['fav_tokens'] = tokens_map
except Exception:
pass
fav_cb = f"fav_toggle_tok:{short_tok}"
# הוסף את כפתור המועדפים לפני כפתור החזרה
keyboard.insert(-1, [InlineKeyboardButton(fav_text, callback_data=fav_cb)])
# הוספת כפתור "הצג עוד" אם יש עוד תוכן
note = file_data.get('description') or ''
note_line = f"\n📝 הערה: {html_escape(note)}\n" if note else "\n📝 הערה: —\n"
# אחידות: תמיד HTML עם <pre><code>, אך נכבד מגבלת 4096 לאחר escape
header_html = (
f"📄 <b>{html_escape(file_name)}</b> ({html_escape(language)}) - גרסה {version}{note_line}\n"
)
html_wrapper_overhead = len("<pre><code>") + len("</code></pre>")
fudge = 10
available_for_code = 4096 - len(header_html) - html_wrapper_overhead - fudge
if available_for_code < 100:
available_for_code = 100
preview_raw_limit = min(max_length, len(code))
safe_code = html_escape(code[:preview_raw_limit])
if len(safe_code) > available_for_code and preview_raw_limit > 0:
try:
factor = max(1.0, len(safe_code) / max(1, preview_raw_limit))
preview_raw_limit = max(0, int(available_for_code / factor))
except Exception:
preview_raw_limit = max(0, preview_raw_limit - (len(safe_code) - available_for_code))
safe_code = html_escape(code[:preview_raw_limit])
while len(safe_code) > available_for_code and preview_raw_limit > 0:
step = max(50, len(safe_code) - available_for_code)
preview_raw_limit = max(0, preview_raw_limit - step)
safe_code = html_escape(code[:preview_raw_limit])
code_preview = code[:preview_raw_limit]
if preview_raw_limit < len(code):
next_chunk = code[preview_raw_limit:preview_raw_limit + max_length]
next_lines = next_chunk.count('\n') or (1 if next_chunk else 0)
show_more_label = f"הצג עוד {next_lines} שורות ⤵️"
keyboard.insert(-1, [InlineKeyboardButton(show_more_label, callback_data=f"fv_more:idx:{file_index}:{preview_raw_limit}")])
reply_markup = InlineKeyboardMarkup(keyboard)
# ניסיון: MarkdownV2 עם תג שפה בבלוק קוד (כדי לקבל תווית שפה + הדגשת תחביר בצד הלקוח)
message_text = f"{header_html}<pre><code>{safe_code}</code></pre>"
parse_mode = 'HTML'
try:
file_name_lower = str(file_name or "").lower()
except Exception:
file_name_lower = ""
try:
language_lower = str(language or "").lower()
except Exception:
language_lower = ""
is_markdown_language = language_lower == 'markdown' or file_name_lower.endswith('.md') or file_name_lower.endswith('.markdown')
# העדף MarkdownV2 כדי לקבל תווית שפה + הדגשת תחביר בצד הלקוח.
# חריג: קבצי Markdown נשארים ב-HTML כדי לא לשבור תצוגת Markdown טבעית.
if not is_markdown_language:
try:
safe_file_name_md = TextUtils.escape_markdown(str(file_name), version=2)
safe_language_md = TextUtils.escape_markdown(str(language), version=2)
safe_note_md = TextUtils.escape_markdown(str(note), version=2) if note else '—'
header_md = (
f"📄 *{safe_file_name_md}*\n"
f"🧠 שפה: {safe_language_md}\n"
f"🔢 גרסה: {version}\n"
f"📝 הערה: {safe_note_md}\n\n"
)
lang_tag = _sanitize_codeblock_language_tag(language)
code_block_body = _sanitize_codeblock_content_for_markdown_v2(code_preview or "")
closing_newline = "" if code_block_body.endswith("\n") else "\n"
markdown_payload = f"{header_md}```{lang_tag}\n{code_block_body}{closing_newline}```"
if len(markdown_payload) <= 4096:
message_text = markdown_payload
parse_mode = getattr(ParseMode, "MARKDOWN_V2", "MarkdownV2")
except Exception:
# fallback ל-HTML (הקיים) אם MarkdownV2 נכשל מכל סיבה
pass
await TelegramUtils.safe_edit_message_text(
query,
message_text,
reply_markup=reply_markup,
parse_mode=parse_mode,
)
except Exception as e:
logger.error(f"Error in handle_view_file: {e}")
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בהצגת הקוד המתקדם")
return ConversationHandler.END
[תיעוד]
async def handle_edit_code(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[2]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
context.user_data['editing_file_index'] = file_index
context.user_data['editing_file_data'] = file_data
file_name = file_data.get('file_name', 'קובץ')
await TelegramUtils.safe_edit_message_text(
query,
f"✏️ *עריכת קוד מתקדמת*\n\n"
f"📄 **קובץ:** `{file_name}`\n\n"
f"📝 שלח את הקוד החדש והמעודכן:",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"file_{file_index}")]]),
parse_mode='Markdown',
)
return EDIT_CODE
except Exception as e:
logger.error(f"Error in handle_edit_code: {e}")
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בהתחלת עריכה\n\n🔄 אנא נסה שוב או חזור לתפריט הראשי\n📞 אם הבעיה נמשכת, פנה לתמיכה")
return ConversationHandler.END
[תיעוד]
async def receive_new_code(update, context: ContextTypes.DEFAULT_TYPE) -> int:
if context.user_data.get('editing_note_file'):
note_text = (update.message.text or '').strip()
file_name = context.user_data.pop('editing_note_file')
user_id = update.effective_user.id
try:
# שליפת גרסה אחרונה דרך Facade, עדכון הערה דרך save_code_snippet.
# טרי ולא דרך ``get_latest_version``: הקוד והשפה שנקראים כאן **נכתבים**
# לגרסה החדשה, והגרסה המקוּשה יכולה להיות מלפני עריכה בוובאפ.
# קריאה שנכשלה זורקת (ה-facade מבקש ``raise_on_error=True``), והחריגה עולה
# ל-``except`` שלמטה, שרושם אותה ועונה "שגיאה" — ולא נבלעת ל"הקובץ לא נמצא".
from src.infrastructure.composition import get_files_facade # type: ignore
_facade = get_files_facade()
doc = _facade.get_latest_version_fresh(user_id, file_name)
if not doc:
await update.message.reply_text("❌ הקובץ לא נמצא לעדכון הערה")
return ConversationHandler.END
desc = ("" if note_text.lower() == 'מחק' else note_text)[:280]
ok = False
try:
if _facade is not None:
ok = bool(_facade.save_code_snippet(
user_id=user_id,
file_name=file_name,
code=doc.get('code', '') or '',
programming_language=doc.get('programming_language', 'text') or 'text',
description=desc,
))
except Exception:
ok = False
# אין fallback לייבוא DB ישיר; אם ה-facade אינו זמין – ok יישאר False
if ok:
await update.message.reply_text(
"✅ הערה עודכנה בהצלחה!",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"view_direct_{file_name}")]]),
)
else:
await update.message.reply_text("❌ שגיאה בעדכון ההערה")
except Exception as e:
logger.error(f"Error updating note: {e}")
await update.message.reply_text("❌ שגיאה בעדכון ההערה")
return ConversationHandler.END
# שחזור טקסט עם סימוני Markdown שנבלעו ע"י לקוח טלגרם
try:
new_code = TelegramUtils.extract_message_text_preserve_markdown(update.message)
except Exception:
new_code = update.message.text
editing_large_file = context.user_data.get('editing_large_file')
if editing_large_file:
try:
user_id = update.effective_user.id
file_name = editing_large_file['file_name']
# זיהוי עקבי גם בקבצים גדולים: מקור אחיד דרך code_service
from services import code_service
language = code_service.detect_language(new_code, file_name)
facade = _get_files_facade()
success = bool(facade and facade.save_large_file(
user_id=user_id,
file_name=file_name,
content=new_code,
programming_language=language,
file_size=len(new_code.encode('utf-8')),
lines_count=len(new_code.split('\n')),
))
if success:
from utils import get_language_emoji
emoji = get_language_emoji(language)
keyboard = [[InlineKeyboardButton("📚 חזרה לקבצים גדולים", callback_data="show_large_files")]]
reply_markup = InlineKeyboardMarkup(keyboard)
lines_count = len(new_code.split('\n'))
await update.message.reply_text(
f"✅ **הקובץ הגדול עודכן בהצלחה!**\n\n"
f"📄 **קובץ:** `{file_name}`\n"
f"{emoji} **שפה:** {language}\n"
f"💾 **גודל חדש:** {len(new_code):,} תווים\n"
f"📏 **שורות:** {lines_count:,}",
reply_markup=reply_markup,
parse_mode='Markdown',
)
context.user_data.pop('editing_large_file', None)
else:
await update.message.reply_text("❌ שגיאה בעדכון הקובץ הגדול")
return ConversationHandler.END
except Exception as e:
logger.error(f"Error updating large file: {e}")
await update.message.reply_text("❌ שגיאה בעדכון הקובץ")
return ConversationHandler.END
file_data = context.user_data.get('editing_file_data')
if not file_data:
await update.message.reply_text("❌ שגיאה בנתוני הקובץ")
return ConversationHandler.END
try:
user_id = update.effective_user.id
file_name = context.user_data.get('editing_file_name') or file_data.get('file_name')
editing_file_index = context.user_data.get('editing_file_index')
files_cache = context.user_data.get('files_cache')
is_valid, cleaned_code, error_message = code_service.validate_code_input(new_code, file_name, user_id)
if not is_valid:
await update.message.reply_text(
f"❌ שגיאה בקלט הקוד:\n{error_message}\n\n"
f"💡 אנא וודא שהקוד תקין ונסה שוב.",
reply_markup=ReplyKeyboardMarkup(_get_main_keyboard(), resize_keyboard=True),
)
return EDIT_CODE
detected_language = code_service.detect_language(cleaned_code, file_name)
facade = _get_files_facade()
success = bool(facade and facade.save_file(user_id, file_name, cleaned_code, detected_language))
if success:
try:
last_version = get_files_facade().get_latest_version(user_id, file_name) # type: ignore[name-defined]
except Exception:
last_version = None
version_num = last_version.get('version', 1) if last_version else 1
try:
fid = str((last_version or {}).get('_id') or '')
except Exception:
fid = ''
webapp_row = _get_webapp_button_row(fid, file_name)
keyboard = [
[
InlineKeyboardButton("👁️ הצג קוד מעודכן", callback_data=(f"view_direct_id:{fid}" if fid else f"view_direct_{file_name}")),
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_file_{file_name}"),
],
[
InlineKeyboardButton("📥 הורד", callback_data=f"download_direct_{file_name}"),
InlineKeyboardButton("🔙 לרשימה", callback_data="files"),
],
]
if webapp_row:
keyboard.insert(0, webapp_row)
reply_markup = InlineKeyboardMarkup(keyboard)
try:
if files_cache is not None and editing_file_index is not None and str(editing_file_index) in files_cache:
entry = files_cache[str(editing_file_index)]
entry['code'] = cleaned_code
entry['programming_language'] = detected_language
entry['version'] = version_num
entry['updated_at'] = datetime.now(timezone.utc)
except Exception as e:
logger.warning(f"Failed to refresh files_cache after edit: {e}")
await update.message.reply_text(
f"✅ *הקובץ עודכן בהצלחה!*\n\n"
f"📄 **קובץ:** `{file_name}`\n"
f"🧠 **שפה:** {detected_language}\n"
f"📝 **גרסה:** {version_num} (עודכן מהגרסה הקודמת)\n"
f"💾 **הקובץ הקיים עודכן עם השינויים החדשים!**",
reply_markup=reply_markup,
parse_mode='Markdown',
)
else:
await update.message.reply_text(
"❌ שגיאה בעדכון הקוד",
reply_markup=ReplyKeyboardMarkup(_get_main_keyboard(), resize_keyboard=True),
)
except Exception as e:
logger.error(f"Error updating code: {e}")
await update.message.reply_text(
"❌ שגיאה בעדכון הקוד\n\n📝 **פרטים:** פרטי השגיאה לא זמינים\n🔄 אנא נסה שוב או פנה לתמיכה\n🏠 חזרה לתפריט הראשי",
reply_markup=ReplyKeyboardMarkup(_get_main_keyboard(), resize_keyboard=True),
parse_mode='Markdown',
)
preserved_cache = context.user_data.get('files_cache')
context.user_data.clear()
if preserved_cache is not None:
context.user_data['files_cache'] = preserved_cache
return ConversationHandler.END
[תיעוד]
async def handle_edit_name(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[2]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
context.user_data['editing_file_index'] = file_index
context.user_data['editing_file_data'] = file_data
current_name = file_data.get('file_name', 'קובץ')
await TelegramUtils.safe_edit_message_text(
query,
f"📝 *עריכת שם קובץ*\n\n"
f"📄 **שם נוכחי:** `{current_name}`\n\n"
f"✏️ שלח שם חדש לקובץ:",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"file_{file_index}")]]),
parse_mode='Markdown',
)
return EDIT_NAME
except Exception as e:
logger.error(f"Error in handle_edit_name: {e}")
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בהתחלת עריכת שם")
return ConversationHandler.END
[תיעוד]
async def handle_edit_note(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[2]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
file_name = file_data.get('file_name', 'קובץ')
current_note = file_data.get('description', '') or '—'
context.user_data['editing_note_file'] = file_name
await TelegramUtils.safe_edit_message_text(
query,
f"📝 *עריכת הערה לקובץ*\n\n"
f"📄 **שם:** `{file_name}`\n"
f"🔎 **הערה נוכחית:** {html_escape(current_note)}\n\n"
f"✏️ שלח/י הערה חדשה (או 'מחק' כדי להסיר)",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"file_{file_index}")]]),
parse_mode='Markdown',
)
return EDIT_CODE
except Exception as e:
logger.error(f"Error in handle_edit_note: {e}")
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בהתחלת עריכת הערה")
return ConversationHandler.END
[תיעוד]
async def receive_new_name(update, context: ContextTypes.DEFAULT_TYPE) -> int:
new_name = update.message.text.strip()
file_data = context.user_data.get('editing_file_data')
if not file_data:
await update.message.reply_text("❌ שגיאה בנתוני הקובץ")
return ConversationHandler.END
# אפשר גם שמות ללא סיומת (Dockerfile/Makefile) ודוטפיילז (.gitignore)
if not ValidationUtils.is_valid_filename(new_name):
await update.message.reply_text(
"🤔 השם נראה קצת מוזר...\n"
"💡 נסה שם כמו: `script.py` או `index.html`\n"
"✅ אותיות, מספרים, נקודות וקווים מותרים!",
)
return EDIT_NAME
try:
user_id = update.effective_user.id
old_name = context.user_data.get('editing_file_name') or file_data.get('file_name')
# דרך ה-FilesFacade מה-Composition Root
try:
from src.infrastructure.composition import get_files_facade # type: ignore
success = bool(get_files_facade().rename_file(user_id, old_name, new_name))
except Exception:
success = False
if success:
# חשב fid עבור הכפתור 'הצג קוד' בהעדפת ID אם זמין
try:
try:
latest_doc = get_files_facade().get_latest_version(user_id, new_name) # type: ignore[name-defined]
except Exception:
latest_doc = {}
fid = str(latest_doc.get('_id') or '')
except Exception:
fid = ''
keyboard = [
[
InlineKeyboardButton("👁️ הצג קוד", callback_data=(f"view_direct_id:{fid}" if fid else f"view_direct_{new_name}")),
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_file_{new_name}"),
],
[
InlineKeyboardButton("📥 הורד", callback_data=f"download_direct_{new_name}"),
InlineKeyboardButton("🔙 לרשימה", callback_data="files"),
],
]
webapp_row = _get_webapp_button_row(fid, new_name)
if webapp_row:
keyboard.insert(0, webapp_row)
reply_markup = InlineKeyboardMarkup(keyboard)
await update.message.reply_text(
f"✅ *שם הקובץ שונה בהצלחה!*\n\n"
f"📄 **שם ישן:** `{old_name}`\n"
f"📄 **שם חדש:** `{new_name}`\n"
f"🎉 **הכל מעודכן במערכת!**",
reply_markup=reply_markup,
parse_mode='Markdown',
)
else:
await update.message.reply_text(
"❌ שגיאה בשינוי השם",
reply_markup=ReplyKeyboardMarkup(_get_main_keyboard(), resize_keyboard=True),
)
except Exception as e:
logger.error(f"Error renaming file: {e}")
await update.message.reply_text(
"❌ שגיאה בשינוי השם",
reply_markup=ReplyKeyboardMarkup(_get_main_keyboard(), resize_keyboard=True),
)
context.user_data.clear()
return ConversationHandler.END
[תיעוד]
async def handle_versions_history(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
data = query.data
file_index: Optional[str] = None
files_cache = context.user_data.get('files_cache', {})
if data.startswith("versions_file_"):
file_name = data.replace("versions_file_", "", 1)
else:
file_index = data.split('_')[1]
file_data = files_cache.get(file_index)
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
file_name = file_data.get('file_name')
user_id = update.effective_user.id
try:
from src.infrastructure.composition import get_files_facade # type: ignore
versions = get_files_facade().get_all_versions(user_id, file_name)
except Exception:
versions = []
if not versions:
await query.edit_message_text("📚 אין היסטוריית גרסאות לקובץ זה")
return ConversationHandler.END
latest_version_num = versions[0].get('version') if versions and isinstance(versions[0], dict) else None
history_text = f"📚 *היסטוריית גרסאות - {file_name}*\n\n"
keyboard: List[List[InlineKeyboardButton]] = []
for i, version in enumerate(versions[:5]):
created_at = version.get('created_at', 'לא ידוע')
version_num = version.get('version', i + 1)
code_length = len(version.get('code', ''))
history_text += f"🔹 **גרסה {version_num}**\n"
history_text += f" 📅 {created_at}\n"
history_text += f" 📏 {code_length:,} תווים\n\n"
if latest_version_num is not None and version_num == latest_version_num:
keyboard.append([
InlineKeyboardButton(
f"👁 הצג גרסה {version_num}", callback_data=f"view_version_{version_num}_{file_name}"
)
])
else:
keyboard.append([
InlineKeyboardButton(
f"👁 הצג גרסה {version_num}", callback_data=f"view_version_{version_num}_{file_name}"
),
InlineKeyboardButton(
f"↩️ שחזר לגרסה {version_num}", callback_data=f"revert_version_{version_num}_{file_name}"
),
])
if file_index is not None:
keyboard.append([InlineKeyboardButton("🔙 חזרה", callback_data=f"file_{file_index}")])
else:
keyboard.append([InlineKeyboardButton("🔙 חזרה", callback_data=f"view_direct_{file_name}")])
reply_markup = InlineKeyboardMarkup(keyboard)
await query.edit_message_text(history_text, reply_markup=reply_markup, parse_mode='Markdown')
except Exception as e:
logger.error(f"Error in handle_versions_history: {e}")
await query.edit_message_text("❌ שגיאה בהצגת היסטוריה")
return ConversationHandler.END
[תיעוד]
async def handle_download_file(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
data = query.data
files_cache = context.user_data.get('files_cache', {})
file_name: Optional[str] = None
code: str = ''
if data.startswith('dl_'):
file_index = data.split('_')[1]
file_data = files_cache.get(file_index)
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
file_name = file_data.get('file_name', 'file.txt')
code = file_data.get('code', '')
elif data.startswith('download_direct_'):
file_name = data.replace('download_direct_', '', 1)
if not isinstance(file_name, str):
await query.edit_message_text("❌ שם קובץ שגוי להורדה")
return ConversationHandler.END
user_id = update.effective_user.id
try:
from src.infrastructure.composition import get_files_facade # type: ignore
latest = get_files_facade().get_latest_version(user_id, file_name)
except Exception:
latest = None
if not latest:
await query.edit_message_text("❌ לא נמצאה גרסה אחרונה לקובץ")
return ConversationHandler.END
code = latest.get('code', '')
else:
await query.edit_message_text("❌ בקשת הורדה לא חוקית")
return ConversationHandler.END
file_bytes = BytesIO()
file_bytes.write(code.encode('utf-8'))
file_bytes.seek(0)
await query.message.reply_document(
document=file_bytes,
filename=file_name,
caption=f"📥 *הורדת קובץ*\n\n📄 **שם:** `{file_name}`\n📏 **גודל:** {len(code):,} תווים",
)
keyboard = []
if data.startswith('dl_'):
file_index = data.split('_')[1]
keyboard.append([InlineKeyboardButton("🔙 חזרה", callback_data=f"file_{file_index}")])
else:
keyboard.append([InlineKeyboardButton("🔙 חזרה", callback_data=f"view_direct_{file_name}")])
reply_markup = InlineKeyboardMarkup(keyboard)
await query.edit_message_text(
f"✅ *הקובץ הורד בהצלחה!*\n\n"
f"📄 **שם:** `{file_name}`",
reply_markup=reply_markup,
parse_mode='Markdown',
)
except Exception as e:
logger.error(f"Error in handle_download_file: {e}")
await query.edit_message_text("❌ שגיאה בהורדת הקובץ")
return ConversationHandler.END
[תיעוד]
async def handle_delete_confirmation(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[1]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
file_name = file_data.get('file_name', 'קובץ')
keyboard = [[
InlineKeyboardButton("✅ כן, העבר לסל מיחזור", callback_data=f"confirm_del_{file_index}"),
InlineKeyboardButton("❌ לא, בטל", callback_data=f"file_{file_index}"),
]]
reply_markup = InlineKeyboardMarkup(keyboard)
await query.edit_message_text(
f"⚠️ *אישור מחיקה*\n\n"
f"📄 **קובץ:** `{file_name}`\n\n"
f"🗑️ האם להעביר את הקובץ לסל המיחזור?\n"
f"♻️ ניתן לשחזר מתוך סל המיחזור עד פקיעת התוקף",
reply_markup=reply_markup,
parse_mode='Markdown',
)
except Exception as e:
logger.error(f"Error in handle_delete_confirmation: {e}")
await query.edit_message_text("❌ שגיאה באישור מחיקה")
return ConversationHandler.END
[תיעוד]
async def handle_delete_file(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[2]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
user_id = update.effective_user.id
file_name = file_data.get('file_name')
try:
from src.infrastructure.composition import get_files_facade # type: ignore
success = bool(get_files_facade().delete_file(user_id, file_name))
except Exception:
success = False
if success:
keyboard = [[InlineKeyboardButton("🔙 לרשימת קבצים", callback_data="files")]]
reply_markup = InlineKeyboardMarkup(keyboard)
await query.edit_message_text(
f"✅ *הקובץ הועבר לסל המיחזור!*\n\n"
f"📄 **קובץ:** `{file_name}`\n"
f"♻️ ניתן לשחזר אותו מתפריט '🗑️ סל מיחזור' עד למחיקה אוטומטית",
reply_markup=reply_markup,
parse_mode='Markdown',
)
else:
await query.edit_message_text(f"❌ שגיאה במחיקת הקובץ `{file_name}`")
except Exception as e:
logger.error(f"Error in handle_delete_file: {e}")
await query.edit_message_text("❌ שגיאה במחיקת הקובץ")
return ConversationHandler.END
[תיעוד]
async def handle_file_info(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[1]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
file_name = file_data.get('file_name', 'קובץ')
code = file_data.get('code', '')
language = file_data.get('programming_language', 'לא ידועה')
created_at = file_data.get('created_at', 'לא ידוע')
version = file_data.get('version', 1)
lines = len(code.split('\n'))
chars = len(code)
words = len(code.split())
info_text = (
f"📊 *מידע מפורט על הקובץ*\n\n"
f"📄 **שם:** `{file_name}`\n"
f"🧠 **שפת תכנות:** {language}\n"
f"📅 **נוצר:** {created_at}\n"
f"🔢 **גרסה:** {version}\n\n"
f"📊 **סטטיסטיקות:**\n"
f"• 📏 שורות: {lines:,}\n"
f"• 🔤 תווים: {chars:,}\n"
f"• 📝 מילים: {words:,}\n"
)
keyboard = [[InlineKeyboardButton("🔙 חזרה", callback_data=f"file_{file_index}")]]
reply_markup = InlineKeyboardMarkup(keyboard)
await query.edit_message_text(info_text, reply_markup=reply_markup, parse_mode='Markdown')
except Exception as e:
logger.error(f"Error in handle_file_info: {e}")
await query.edit_message_text("❌ שגיאה בהצגת מידע")
return ConversationHandler.END
[תיעוד]
async def handle_view_direct_file(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
data = query.data
token = data.replace("view_direct_", "", 1)
user_id = update.effective_user.id
file_data = None
file_name = None
is_large_file = False
if token.startswith("id:"):
file_id = token[3:]
try:
from src.infrastructure.composition import get_files_facade # type: ignore
doc = get_files_facade().get_file_by_id(file_id)
except Exception:
doc = None
if not doc:
try:
from src.infrastructure.composition import get_files_facade # type: ignore
lf = get_files_facade().get_large_file_by_id(file_id)
except Exception:
lf = None
if lf:
is_large_file = True
file_name = lf.get('file_name') or 'file'
file_data = {
'file_name': file_name,
'code': lf.get('content', ''),
'programming_language': lf.get('programming_language', 'text'),
'version': 1,
'description': lf.get('description', ''),
'_id': lf.get('_id')
}
else:
await _edit_message_text_unified(query, "⚠️ הקובץ לא נמצא")
return ConversationHandler.END
else:
file_name = doc.get('file_name') or 'file'
file_data = doc
else:
file_name = token
try:
from src.infrastructure.composition import get_files_facade # type: ignore
file_data = get_files_facade().get_latest_version(user_id, file_name)
except Exception:
file_data = None
# תמיכה בקבצים גדולים: אם לא נמצא בקולקציה הרגילה, ננסה large_files
if not file_data and file_name:
try:
from src.infrastructure.composition import get_files_facade # type: ignore
lf = get_files_facade().get_large_file(user_id, file_name)
except Exception:
lf = None
if lf:
is_large_file = True
file_data = {
'file_name': lf.get('file_name', file_name),
'code': lf.get('content', ''),
'programming_language': lf.get('programming_language', 'text'),
'version': 1,
'description': lf.get('description', ''),
'_id': lf.get('_id')
}
else:
await _edit_message_text_unified(query, "⚠️ הקובץ נעלם מהמערכת החכמה")
return ConversationHandler.END
code = file_data.get('code', '')
language = file_data.get('programming_language', 'text')
version = file_data.get('version', 1)
max_length = 3500
code_preview = code[:max_length]
# נסה להשיג ObjectId לצורך שיתוף
try:
fid = str(file_data.get('_id') or '')
except Exception:
fid = ''
# יעד כפתור "חזרה" לפי מקור הרשימה אם קיים; אחרת חזרה אחרי תצוגה ישירה
try:
last_page = context.user_data.get('files_last_page')
origin = context.user_data.get('files_origin') or {}
if origin.get('type') == 'by_repo' and origin.get('tag'):
back_cb = f"by_repo:{origin.get('tag')}"
elif origin.get('type') == 'favorites':
back_cb = f"favorites_page_{last_page}" if last_page else "show_favorites"
elif origin.get('type') == 'regular':
back_cb = f"files_page_{last_page}" if last_page else "show_regular_files"
else:
back_cb = f"back_after_view:{file_name}"
except Exception:
back_cb = f"back_after_view:{file_name}"
keyboard = [
[
InlineKeyboardButton("✏️ ערוך קוד", callback_data=f"edit_code_direct_{file_name}"),
InlineKeyboardButton("📝 ערוך שם", callback_data=f"edit_name_direct_{file_name}"),
],
[
InlineKeyboardButton("📝 ערוך הערה", callback_data=f"edit_note_direct_{file_name}"),
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_file_{file_name}"),
],
[
InlineKeyboardButton("📥 הורד", callback_data=f"download_direct_{file_name}"),
InlineKeyboardButton("🔄 שכפול", callback_data=f"clone_direct_{file_name}"),
],
[
InlineKeyboardButton("🔗 שתף קוד", callback_data=f"share_menu_id:{fid}") if fid else InlineKeyboardButton("🔗 שתף קוד", callback_data=f"share_menu_id:")
],
[InlineKeyboardButton("🔙 חזרה", callback_data=back_cb)],
]
view_target_id = fid if not is_large_file else None
webapp_row = _get_webapp_button_row(view_target_id, file_name)
if webapp_row:
keyboard.insert(0, webapp_row)
# כפתור מועדפים (הוסף/הסר) לפי המצב הנוכחי
try:
from src.infrastructure.composition import get_files_facade # type: ignore
is_fav_now = bool(get_files_facade().is_favorite(update.effective_user.id, file_name))
except Exception:
is_fav_now = False
fav_text = ("💔 הסר ממועדפים" if is_fav_now else "⭐ הוסף למועדפים")
# בנה callback בטוח: העדף מזהה מסד אם קיים, אחרת טוקן קצר במיפוי זמני
if fid and (len("fav_toggle_id:") + len(fid)) <= 60:
fav_cb = f"fav_toggle_id:{fid}"
else:
try:
tok = secrets.token_urlsafe(6)
except Exception:
tok = "t"
short_tok = (tok[:24] if isinstance(tok, str) else "t")
try:
tokens_map = context.user_data.get('fav_tokens') or {}
tokens_map[short_tok] = file_name
context.user_data['fav_tokens'] = tokens_map
except Exception:
pass
fav_cb = f"fav_toggle_tok:{short_tok}"
# הוסף את כפתור המועדפים לפני כפתור החזרה
keyboard.insert(-1, [InlineKeyboardButton(fav_text, callback_data=fav_cb)])
note = file_data.get('description') or ''
note_line_html = f"\n📝 הערה: {html_escape(note)}\n\n" if note else "\n📝 הערה: —\n\n"
large_note_html = "\n<i>זה קובץ גדול</i>\n\n" if is_large_file else ""
header_html = (
f"📄 <b>{html_escape(file_name)}</b> ({html_escape(language)}) - גרסה {version}"
f"{note_line_html}{large_note_html}"
)
if not header_html.endswith("\n"):
header_html += "\n"
html_wrapper_overhead = len("<pre><code>") + len("</code></pre>")
fudge = 10
available_for_code = 4096 - len(header_html) - html_wrapper_overhead - fudge
if available_for_code < 100:
available_for_code = 100
preview_raw_limit = min(max_length, len(code))
safe_code = html_escape(code[:preview_raw_limit])
if len(safe_code) > available_for_code and preview_raw_limit > 0:
try:
factor = max(1.0, len(safe_code) / max(1, preview_raw_limit))
preview_raw_limit = max(0, int(available_for_code / factor))
except Exception:
preview_raw_limit = max(0, preview_raw_limit - (len(safe_code) - available_for_code))
safe_code = html_escape(code[:preview_raw_limit])
while len(safe_code) > available_for_code and preview_raw_limit > 0:
step = max(50, len(safe_code) - available_for_code)
preview_raw_limit = max(0, preview_raw_limit - step)
safe_code = html_escape(code[:preview_raw_limit])
code_preview = code[:preview_raw_limit]
safe_code = html_escape(code_preview)
if preview_raw_limit < len(code):
next_chunk = code[preview_raw_limit:preview_raw_limit + max_length]
next_lines = next_chunk.count('\n') or (1 if next_chunk else 0)
show_more_label = f"הצג עוד {next_lines} שורות ⤵️"
keyboard.insert(-1, [InlineKeyboardButton(show_more_label, callback_data=f"fv_more:direct:{file_name}:{preview_raw_limit}")])
reply_markup = InlineKeyboardMarkup(keyboard)
html_payload = f"{header_html}<pre><code>{safe_code}</code></pre>"
message_text = html_payload
parse_mode = 'HTML'
try:
file_name_lower = str(file_name).lower()
except Exception:
file_name_lower = ""
try:
language_lower = str(language or "").lower()
except Exception:
language_lower = ""
is_markdown_language = language_lower == 'markdown' or file_name_lower.endswith('.md') or file_name_lower.endswith('.markdown')
# העדף MarkdownV2 כדי לקבל תווית שפה + הדגשת תחביר.
# חריגים:
# - קבצים גדולים: עדיף HTML כדי לשמור עקביות בטעינה מדורגת/כפתור "הצג עוד"
# - קבצי Markdown: עדיף HTML כדי לא לאבד תצוגת Markdown טבעית
prefer_markdown = (not is_large_file) and (not is_markdown_language)
if prefer_markdown:
try:
# MarkdownV2 מאפשר גם תג שפה לבלוק קוד (שמפעיל תווית שפה + הדגשת תחביר בצד הלקוח)
safe_file_name_md = TextUtils.escape_markdown(str(file_name), version=2)
safe_language_md = TextUtils.escape_markdown(str(language), version=2)
safe_note_md = TextUtils.escape_markdown(str(note), version=2) if note else '—'
header_md = (
f"📄 *{safe_file_name_md}*\n"
f"🧠 שפה: {safe_language_md}\n"
f"🔢 גרסה: {version}\n"
f"📝 הערה: {safe_note_md}\n\n"
)
code_block_body = _sanitize_codeblock_content_for_markdown_v2(code_preview or "")
closing_newline = "" if code_block_body.endswith("\n") else "\n"
lang_tag = _sanitize_codeblock_language_tag(language)
markdown_payload = f"{header_md}```{lang_tag}\n{code_block_body}{closing_newline}```"
if len(markdown_payload) <= 4096:
message_text = markdown_payload
parse_mode = getattr(ParseMode, "MARKDOWN_V2", "MarkdownV2")
except Exception as markdown_err:
logger.debug("Markdown render fallback to HTML: %s", markdown_err)
await _edit_message_text_unified(
query,
message_text,
reply_markup=reply_markup,
parse_mode=parse_mode,
)
except Exception as e:
logger.error(f"Error in handle_view_direct_file: {e}")
await _edit_message_text_unified(query, "❌ שגיאה בהצגת הקוד המתקדם")
return ConversationHandler.END
[תיעוד]
async def handle_edit_code_direct(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_name = query.data.replace("edit_code_direct_", "")
user_id = update.effective_user.id
try:
from src.infrastructure.composition import get_files_facade # type: ignore
file_data = get_files_facade().get_latest_version(user_id, file_name)
except Exception:
file_data = None
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
context.user_data['editing_file_data'] = file_data
context.user_data['editing_file_name'] = file_name
await query.edit_message_text(
f"✏️ *עריכת קוד מתקדמת*\n\n"
f"📄 **קובץ:** `{file_name}`\n\n"
f"📝 שלח את הקוד החדש והמעודכן:",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"view_direct_{file_name}")]]),
parse_mode='Markdown',
)
return EDIT_CODE
except Exception as e:
logger.error(f"Error in handle_edit_code_direct: {e}")
await query.edit_message_text("❌ שגיאה בהתחלת עריכה")
return ConversationHandler.END
[תיעוד]
async def handle_edit_name_direct(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_name = query.data.replace("edit_name_direct_", "")
user_id = update.effective_user.id
try:
from src.infrastructure.composition import get_files_facade # type: ignore
file_data = get_files_facade().get_latest_version(user_id, file_name)
except Exception:
file_data = None
if not file_data:
await query.edit_message_text("❌ שגיאה בזיהוי הקובץ")
return ConversationHandler.END
context.user_data['editing_file_data'] = file_data
context.user_data['editing_file_name'] = file_name
await query.edit_message_text(
f"📝 *עריכת שם קובץ*\n\n"
f"📄 **שם נוכחי:** `{file_name}`\n\n"
f"✏️ שלח שם חדש לקובץ:",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"view_direct_{file_name}")]]),
parse_mode='Markdown',
)
return EDIT_NAME
except Exception as e:
logger.error(f"Error in handle_edit_name_direct: {e}")
await query.edit_message_text("❌ שגיאה בהתחלת עריכת שם")
return ConversationHandler.END
[תיעוד]
async def handle_edit_note_direct(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_name = query.data.replace("edit_note_direct_", "")
user_id = update.effective_user.id
try:
from src.infrastructure.composition import get_files_facade # type: ignore
file_data = get_files_facade().get_latest_version(user_id, file_name)
except Exception:
file_data = None
if not file_data:
await query.edit_message_text("❌ לא נמצא הקובץ לעריכת הערה")
return ConversationHandler.END
current_note = file_data.get('description', '') or '—'
context.user_data['editing_note_file'] = file_name
await query.edit_message_text(
f"📝 *עריכת הערה לקובץ*\n\n"
f"📄 **שם:** `{file_name}`\n"
f"🔎 **הערה נוכחית:** {html_escape(current_note)}\n\n"
f"✏️ שלח/י הערה חדשה (או שלח/י 'מחק' כדי להסיר).",
reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 חזרה", callback_data=f"view_direct_{file_name}")]]),
parse_mode='Markdown',
)
return EDIT_CODE
except Exception as e:
logger.exception("Error in handle_edit_note_direct: %s", e)
await query.edit_message_text("❌ שגיאה בעריכת הערה")
return ConversationHandler.END
def _suggest_clone_name(facade, user_id: int, name: str) -> str:
"""שם פנוי לעותק של ``name``: ``<stem> (copy)<ext>``, ואחריו ``(copy 2)`` עד ``(copy 99)``.
"פנוי" נשאל את המסד דרך ``get_latest_version_fresh`` ולא את הקאש: השם נבחר כדי לכתוב אליו,
והקאש אינו שומר ``None`` — שם שנמחק או ששונה בוובאפ היה נשאר "תפוס" עד שהקאש פג. בדיקה
שנכשלה זורקת (ה-facade מבקש ``raise_on_error=True``), והחריגה עולה לקורא ואינה נחשבת
"פנוי": שמירה בשם תפוס הייתה נכתבת כגרסה חדשה של הקובץ האחר, ולא כעותק.
"""
name = str(name)
dot = name.rfind('.')
stem, ext = (name[:dot], name[dot:]) if dot > 0 else (name, '')
candidate = f"{stem} (copy){ext}"
if not facade.get_latest_version_fresh(user_id, candidate):
return candidate
for i in range(2, 100):
candidate = f"{stem} (copy {i}){ext}"
if not facade.get_latest_version_fresh(user_id, candidate):
return candidate
return f"{stem} (copy {int(datetime.now(timezone.utc).timestamp())}){ext}"
def _clone_fields(source: dict):
"""(קוד, שפה, תיאור, תגיות) שהעותק מקבל — ממסמך המקור שנקרא מהמסד, לא מרשימת הבוט ולא מהקאש."""
tags = source.get('tags')
return (
source.get('code', ''),
source.get('programming_language', 'text'),
source.get('description', '') or '',
list(tags) if isinstance(tags, (list, tuple)) else [],
)
[תיעוד]
async def handle_clone(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_index = query.data.split('_')[1]
files_cache = context.user_data.get('files_cache', {})
file_data = files_cache.get(file_index)
if not file_data:
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בזיהוי הקובץ לשכפול")
return ConversationHandler.END
# הרשומה ברשימה מזהה את הקובץ, ותו לא. את התוכן קוראים מהמסד: ``files_cache`` הוא מה
# שהיה כשהרשימה הוצגה, בלי שום תוקף, ושכפול ממנו העתיק את מה שהרשימה זכרה ולא את
# הקובץ — וקובץ שכבר נמחק היה נבנה ממנה מחדש.
original_name = file_data.get('file_name', 'file.txt')
user_id = update.effective_user.id
from src.infrastructure.composition import get_files_facade # type: ignore
facade = get_files_facade()
source = facade.get_latest_version_fresh(user_id, original_name)
if not source:
await TelegramUtils.safe_edit_message_text(query, "❌ הקובץ לא נמצא לשכפול")
return ConversationHandler.END
code, language, description, tags = _clone_fields(source)
new_name = _suggest_clone_name(facade, user_id, original_name)
try:
from src.infrastructure.composition import get_files_facade # type: ignore
ok = bool(get_files_facade().save_code_snippet(
user_id=user_id,
file_name=new_name,
code=code,
programming_language=language,
description=description,
tags=tags,
))
except Exception:
ok = False
if ok:
try:
# רענון חלקי של ה-cache המקומי אם זמין
if isinstance(files_cache, dict):
files_cache[str(file_index)] = dict(file_data, file_name=original_name)
except Exception:
pass
try:
from src.infrastructure.composition import get_files_facade # type: ignore
latest_doc = get_files_facade().get_latest_version(user_id, new_name) or {}
fid = str(latest_doc.get('_id') or '')
except Exception:
fid = ''
webapp_row = _get_webapp_button_row(fid, new_name)
keyboard = [
[
InlineKeyboardButton("👁️ הצג קוד", callback_data=(f"view_direct_id:{fid}" if fid else f"view_direct_{new_name}")),
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_file_{new_name}"),
],
[
InlineKeyboardButton("📥 הורד", callback_data=f"download_direct_{new_name}"),
InlineKeyboardButton("🔙 לרשימה", callback_data="files"),
],
]
if webapp_row:
keyboard.insert(0, webapp_row)
reply_markup = InlineKeyboardMarkup(keyboard)
await TelegramUtils.safe_edit_message_text(
query,
f"✅ *הקובץ שוכפל בהצלחה!*\n\n"
f"📄 **מקור:** `{original_name}`\n"
f"📄 **עותק חדש:** `{new_name}`",
reply_markup=reply_markup,
parse_mode='Markdown',
)
else:
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בשכפול הקובץ")
except Exception as e:
logger.error(f"Error in handle_clone: {e}")
await TelegramUtils.safe_edit_message_text(query, "❌ שגיאה בשכפול הקובץ")
return ConversationHandler.END
[תיעוד]
async def handle_clone_direct(update, context: ContextTypes.DEFAULT_TYPE) -> int:
query = update.callback_query
await query.answer()
try:
file_name = query.data.replace("clone_direct_", "")
user_id = update.effective_user.id
# המקור נקרא מהמסד ולא דרך ``get_latest_version`` המקוּשה: מה שנקרא כאן **נכתב**
# לעותק, והגרסה המקוּשה יכולה להיות מלפני עריכה בוובאפ. קריאה שנכשלה זורקת
# (ה-facade מבקש ``raise_on_error=True``), והחריגה עולה ל-``except`` שלמטה ונרשמת
# — ולא נבלעת ל"הקובץ לא נמצא".
from src.infrastructure.composition import get_files_facade # type: ignore
facade = get_files_facade()
file_data = facade.get_latest_version_fresh(user_id, file_name)
if not file_data:
await query.edit_message_text("❌ הקובץ לא נמצא לשכפול")
return ConversationHandler.END
code, language, description, tags = _clone_fields(file_data)
new_name = _suggest_clone_name(facade, user_id, file_name)
# יצירת snippet לשמירה דרך Facade
try:
from src.infrastructure.composition import get_files_facade # type: ignore
ok = bool(get_files_facade().save_code_snippet(
user_id=user_id,
file_name=new_name,
code=code,
programming_language=language,
description=description,
tags=tags,
))
except Exception:
ok = False
if ok:
# חשב fid עבור הכפתור 'הצג קוד' בהעדפת ID אם זמין
try:
from src.infrastructure.composition import get_files_facade # type: ignore
latest_doc = get_files_facade().get_latest_version(user_id, new_name) or {}
fid = str(latest_doc.get('_id') or '')
except Exception:
fid = ''
webapp_row = _get_webapp_button_row(fid)
keyboard = [
[
InlineKeyboardButton("👁️ הצג קוד", callback_data=(f"view_direct_id:{fid}" if fid else f"view_direct_{new_name}")),
InlineKeyboardButton("📚 היסטוריה", callback_data=f"versions_file_{new_name}"),
],
[
InlineKeyboardButton("📥 הורד", callback_data=f"download_direct_{new_name}"),
InlineKeyboardButton("🔙 לרשימה", callback_data="files"),
],
]
if webapp_row:
keyboard.insert(0, webapp_row)
reply_markup = InlineKeyboardMarkup(keyboard)
text = (
f"✅ *הקובץ שוכפל בהצלחה!*\n\n"
f"📄 **מקור:** `{file_name}`\n"
f"📄 **עותק חדש:** `{new_name}`"
)
await query.edit_message_text(text, reply_markup=reply_markup, parse_mode='Markdown')
else:
await query.edit_message_text("❌ שגיאה בשכפול הקובץ")
except Exception as e:
logger.error(f"Error in handle_clone_direct: {e}")
await query.edit_message_text("❌ שגיאה בשכפול הקובץ")
return ConversationHandler.END