8cc7b09716
Now only shows the creator line if created_by_username exists,
no fallback to "User {id}" which could be confusing.
896 lines
28 KiB
Python
896 lines
28 KiB
Python
"""Telegram command handlers for JIGAIDO - Thin wrappers around core services."""
|
|
|
|
import time
|
|
from datetime import datetime, timezone
|
|
from functools import wraps
|
|
from typing import Optional
|
|
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
|
|
|
|
import dateparser
|
|
from telegram import Update
|
|
from telegram.ext import ContextTypes
|
|
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
|
|
from telegram.constants import ParseMode
|
|
|
|
from adapters.storage.json_file import JsonFileRoomStorage, JsonFileTrackingStorage
|
|
from core.services import BountyService, TrackingService
|
|
|
|
ROOM_STORAGE = JsonFileRoomStorage()
|
|
TRACKING_STORAGE = JsonFileTrackingStorage()
|
|
BOUNTY_SERVICE = BountyService(ROOM_STORAGE)
|
|
TRACKING_SERVICE = TrackingService(TRACKING_STORAGE, ROOM_STORAGE)
|
|
|
|
TELEGRAM_BOT_USERNAME = "your_bot_username"
|
|
|
|
|
|
def format_due_date(due_date_ts: int | None, timezone_str: str) -> str:
|
|
"""Format due date as human-readable with timezone.
|
|
|
|
Examples:
|
|
No due date: (none shown)
|
|
Date only: 4 April 2026
|
|
Date + time: 4 April 2026 14:30
|
|
With timezone: 4 April 2026 14:30 (Asia/Jakarta)
|
|
"""
|
|
if not due_date_ts:
|
|
return ""
|
|
|
|
try:
|
|
tz = ZoneInfo(timezone_str)
|
|
except (KeyError, ZoneInfoNotFoundError):
|
|
tz = ZoneInfo("UTC")
|
|
|
|
dt = datetime.fromtimestamp(due_date_ts, tz=tz)
|
|
|
|
date_str = dt.strftime("%-d %B %Y")
|
|
|
|
if dt.hour != 0 or dt.minute != 0:
|
|
date_str += f" {dt.strftime('%H:%M')}"
|
|
date_str += f" ({timezone_str})"
|
|
|
|
return date_str
|
|
|
|
|
|
def extract_args(text: str) -> list[str]:
|
|
if not text:
|
|
return []
|
|
tokens = text.strip().split()
|
|
return tokens[1:] if len(tokens) > 1 else []
|
|
|
|
|
|
def parse_args(
|
|
args: list[str],
|
|
timezone_str: str = "UTC",
|
|
) -> tuple[Optional[str], Optional[str], Optional[int], bool, bool]:
|
|
text = None
|
|
link = None
|
|
due_date_ts = None
|
|
clear_link = False
|
|
clear_date = False
|
|
|
|
try:
|
|
tz = ZoneInfo(timezone_str)
|
|
except (KeyError, ZoneInfoNotFoundError):
|
|
tz = ZoneInfo("UTC")
|
|
|
|
def is_url(s: str) -> bool:
|
|
if not s:
|
|
return False
|
|
if s.startswith("http://") or s.startswith("https://"):
|
|
return True
|
|
if "." in s and " " not in s:
|
|
return True
|
|
return False
|
|
|
|
def is_time(s: str) -> bool:
|
|
if not s or ":" not in s:
|
|
return False
|
|
parts = s.split(":")
|
|
if len(parts) != 2:
|
|
return False
|
|
try:
|
|
h, m = int(parts[0]), int(parts[1])
|
|
return 0 <= h <= 23 and 0 <= m <= 59
|
|
except ValueError:
|
|
return False
|
|
|
|
def parse_date_with_tz(date_str: str) -> int | None:
|
|
parsed = dateparser.parse(date_str)
|
|
if parsed:
|
|
localized = parsed.replace(tzinfo=tz)
|
|
return int(localized.timestamp())
|
|
return None
|
|
|
|
i = 0
|
|
while i < len(args):
|
|
arg = args[i]
|
|
|
|
if arg == "-link":
|
|
if i + 1 < len(args):
|
|
link = args[i + 1]
|
|
i += 2
|
|
else:
|
|
clear_link = True
|
|
i += 1
|
|
elif arg == "-date":
|
|
if i + 1 < len(args):
|
|
due_date_ts = parse_date_with_tz(args[i + 1])
|
|
if due_date_ts is not None:
|
|
i += 2
|
|
if i < len(args) and is_time(args[i]):
|
|
time_parts = args[i].split(":")
|
|
due_date_ts += (
|
|
int(time_parts[0]) * 3600 + int(time_parts[1]) * 60
|
|
)
|
|
i += 1
|
|
else:
|
|
clear_date = True
|
|
i += 1
|
|
else:
|
|
clear_date = True
|
|
i += 1
|
|
elif not link and is_url(arg):
|
|
link = arg
|
|
i += 1
|
|
elif due_date_ts is None:
|
|
due_date_ts = parse_date_with_tz(arg)
|
|
if due_date_ts is not None:
|
|
i += 1
|
|
if i < len(args) and is_time(args[i]):
|
|
time_parts = args[i].split(":")
|
|
due_date_ts += int(time_parts[0]) * 3600 + int(time_parts[1]) * 60
|
|
i += 1
|
|
else:
|
|
i += 1
|
|
if text is None:
|
|
text = arg
|
|
else:
|
|
text = text + " " + arg
|
|
else:
|
|
i += 1
|
|
if text is None:
|
|
text = arg
|
|
else:
|
|
text = text + " " + arg
|
|
|
|
return text, link, due_date_ts, clear_link, clear_date
|
|
|
|
|
|
def format_bounty(
|
|
b, show_id: bool = True, slice_length: int = 0, timezone_str: str = "UTC"
|
|
) -> str:
|
|
parts = []
|
|
if show_id:
|
|
parts.append(f"[#{b.id}]")
|
|
if b.text:
|
|
text = b.text
|
|
if slice_length > 0 and len(text) > slice_length:
|
|
text = text[:slice_length] + "..."
|
|
parts.append(text)
|
|
if b.link:
|
|
parts.append(f"🔗 {b.link}")
|
|
if b.due_date_ts:
|
|
try:
|
|
tz = ZoneInfo(timezone_str)
|
|
except (KeyError, ZoneInfoNotFoundError):
|
|
tz = ZoneInfo("UTC")
|
|
|
|
now_utc = int(time.time())
|
|
dt_now = datetime.now(tz)
|
|
dt_due = datetime.fromtimestamp(b.due_date_ts, tz=tz)
|
|
|
|
seconds_left = int((dt_due - dt_now).total_seconds())
|
|
hours_left = seconds_left // 3600
|
|
days_left = seconds_left // 86400
|
|
|
|
due_str = dt_due.strftime("%d %b %Y %H:%M")
|
|
|
|
if seconds_left < 0:
|
|
parts.append(f"⏰ {due_str} (OVERDUE)")
|
|
elif hours_left < 48:
|
|
if hours_left < 1:
|
|
minutes_left = seconds_left // 60
|
|
parts.append(f"⏰ {due_str} ({minutes_left}m)")
|
|
else:
|
|
parts.append(f"⏰ {due_str} ({hours_left}h)")
|
|
else:
|
|
parts.append(f"⏰ {due_str} ({days_left}d)")
|
|
return " | ".join(parts)
|
|
|
|
|
|
async def cmd_delete_message(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
query = update.callback_query
|
|
if not query:
|
|
return
|
|
|
|
data = query.data
|
|
if not data.startswith("del_msg:"):
|
|
return
|
|
|
|
parts = data.split(":")
|
|
if len(parts) != 2:
|
|
return
|
|
|
|
try:
|
|
expected_user_id = int(parts[1])
|
|
except ValueError:
|
|
return
|
|
|
|
user_id = get_user_id(update)
|
|
if user_id != expected_user_id:
|
|
await query.answer("You can't delete this message", show_alert=True)
|
|
return
|
|
|
|
try:
|
|
await query.message.delete()
|
|
await query.answer("Deleted")
|
|
except Exception as e:
|
|
await query.answer(f"Could not delete: {e}", show_alert=True)
|
|
|
|
|
|
def is_group(update: Update) -> bool:
|
|
return update.effective_chat.type != "private"
|
|
|
|
|
|
def get_group_id(update: Update) -> int:
|
|
return update.effective_chat.id
|
|
|
|
|
|
def get_user_id(update: Update) -> int:
|
|
return update.effective_user.id
|
|
|
|
|
|
def get_room_id(update: Update) -> int:
|
|
"""Get room_id for the current context.
|
|
|
|
For groups: negative group_id
|
|
For DMs: positive user_id
|
|
"""
|
|
if is_group(update):
|
|
return get_group_id(update)
|
|
return get_user_id(update)
|
|
|
|
|
|
async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
room_id = get_room_id(update)
|
|
user_id = get_user_id(update)
|
|
timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
|
|
args = extract_args(update.message.text)
|
|
|
|
show_all = "all" in args
|
|
args = [a for a in args if a != "all"]
|
|
|
|
try:
|
|
limit = int(args[0]) if args else 5
|
|
except (ValueError, IndexError):
|
|
limit = 5
|
|
|
|
now = int(time.time())
|
|
cutoff_24h = now - 86400
|
|
|
|
all_bounties = BOUNTY_SERVICE.list_bounties(room_id)
|
|
|
|
def is_expired(b) -> bool:
|
|
return b.due_date_ts is not None and b.due_date_ts < cutoff_24h
|
|
|
|
def sort_key(b):
|
|
if b.due_date_ts is not None:
|
|
return (0, b.due_date_ts)
|
|
return (1, b.created_at)
|
|
|
|
filtered_bounties = [b for b in all_bounties if not is_expired(b) or show_all]
|
|
filtered_bounties.sort(key=sort_key)
|
|
|
|
total_count = len(filtered_bounties)
|
|
displayed_bounties = filtered_bounties[:limit]
|
|
|
|
if not displayed_bounties:
|
|
if show_all:
|
|
await update.message.reply_text("No bounties yet.")
|
|
else:
|
|
await update.message.reply_text(
|
|
"No active bounties. Use /bounty all to show expired."
|
|
)
|
|
return
|
|
|
|
lines = []
|
|
if limit < total_count:
|
|
lines.append(f"Showing {limit} of {total_count} bounties:")
|
|
slice_length = 40
|
|
elif show_all and total_count > limit:
|
|
lines.append(f"Showing {limit} of {total_count} bounties (including expired):")
|
|
slice_length = 40
|
|
else:
|
|
lines.append(f"Showing {total_count} bounties:")
|
|
slice_length = 0
|
|
|
|
for b in displayed_bounties:
|
|
lines.append(
|
|
format_bounty(
|
|
b, show_id=True, slice_length=slice_length, timezone_str=timezone_str
|
|
)
|
|
)
|
|
|
|
keyboard = [[InlineKeyboardButton("🗑️ Delete", callback_data=f"del_msg:{user_id}")]]
|
|
reply_markup = InlineKeyboardMarkup(keyboard)
|
|
await update.message.reply_text(
|
|
"\n".join(lines), disable_web_page_preview=True, reply_markup=reply_markup
|
|
)
|
|
|
|
|
|
async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
user_id = get_user_id(update)
|
|
|
|
if is_group(update):
|
|
group_id = get_group_id(update)
|
|
bounties = TRACKING_SERVICE.get_tracked_bounties(group_id, user_id)
|
|
room_id = group_id
|
|
else:
|
|
room_id = get_room_id(update)
|
|
bounties = BOUNTY_SERVICE.list_bounties(room_id)
|
|
|
|
timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
|
|
|
|
if not bounties:
|
|
msg = (
|
|
"You are not tracking any bounties."
|
|
if is_group(update)
|
|
else "No personal bounties."
|
|
)
|
|
await update.message.reply_text(msg)
|
|
return
|
|
|
|
lines = [
|
|
format_bounty(b, show_id=True, timezone_str=timezone_str) for b in bounties
|
|
]
|
|
await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
|
|
|
|
|
|
async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
if not args:
|
|
await update.message.reply_text(
|
|
"Usage: /add <text> [link] [due_date]\n"
|
|
"Example: /add Fix the bug https://github.com/foo/bar tomorrow"
|
|
)
|
|
return
|
|
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
|
|
|
|
effective_user = update.effective_user
|
|
username = effective_user.username or effective_user.first_name or None
|
|
|
|
text, link, due_date_ts, _, _ = parse_args(args, timezone_str)
|
|
if not text and not link:
|
|
await update.message.reply_text("A bounty needs at least text or a link.")
|
|
return
|
|
|
|
try:
|
|
bounty = BOUNTY_SERVICE.add_bounty(
|
|
room_id=room_id,
|
|
user_id=user_id,
|
|
text=text,
|
|
link=link,
|
|
due_date_ts=due_date_ts,
|
|
created_by_username=username,
|
|
)
|
|
except PermissionError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
return
|
|
except ValueError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
return
|
|
|
|
due_str = ""
|
|
if due_date_ts:
|
|
timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
|
|
due_str = f" | Due: {format_due_date(due_date_ts, timezone_str)}"
|
|
await update.message.reply_text(
|
|
f"✅ Bounty added (#{bounty.id}){due_str}",
|
|
disable_web_page_preview=True,
|
|
)
|
|
|
|
|
|
async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
if len(args) < 1:
|
|
await update.message.reply_text(
|
|
"Usage: /update <bounty_id> [text] [link] [due_date]\n"
|
|
" /update <bounty_id> -link [<url>] - clear or set link\n"
|
|
" /update <bounty_id> -date [<date>] - clear or set date\n"
|
|
"Examples:\n"
|
|
" /update 1 new text - update text only\n"
|
|
" /update 1 -link - clear link\n"
|
|
" /update 1 -link https://... - set link\n"
|
|
" /update 1 -link -date - clear both link and date"
|
|
)
|
|
return
|
|
|
|
try:
|
|
bounty_id = int(args[0])
|
|
except ValueError:
|
|
await update.message.reply_text("Invalid bounty ID.")
|
|
return
|
|
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
|
|
|
|
text, link, due_date_ts, clear_link, clear_date = parse_args(args[1:], timezone_str)
|
|
if (
|
|
not text
|
|
and not link
|
|
and due_date_ts is None
|
|
and not clear_link
|
|
and not clear_date
|
|
):
|
|
await update.message.reply_text("Nothing to update.")
|
|
return
|
|
|
|
old_bounty = BOUNTY_SERVICE.get_bounty(room_id, bounty_id)
|
|
if not old_bounty:
|
|
await update.message.reply_text("Bounty not found.")
|
|
return
|
|
|
|
try:
|
|
success = BOUNTY_SERVICE.update_bounty(
|
|
room_id=room_id,
|
|
bounty_id=bounty_id,
|
|
user_id=user_id,
|
|
text=text,
|
|
link=link,
|
|
due_date_ts=due_date_ts,
|
|
clear_link=clear_link,
|
|
clear_due=clear_date,
|
|
)
|
|
except PermissionError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
return
|
|
except ValueError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
return
|
|
|
|
if success:
|
|
changes = []
|
|
if text is not None:
|
|
old_text = old_bounty.text or "(none)"
|
|
changes.append(f"Text: {old_text} → {text}")
|
|
if link is not None:
|
|
old_link = old_bounty.link or "(none)"
|
|
changes.append(f"Link: {old_link} → {link}")
|
|
if due_date_ts is not None:
|
|
old_date = (
|
|
time.strftime("%d %b %Y %H:%M", time.localtime(old_bounty.due_date_ts))
|
|
if old_bounty.due_date_ts
|
|
else "(none)"
|
|
)
|
|
new_date = time.strftime("%d %b %Y %H:%M", time.localtime(due_date_ts))
|
|
changes.append(f"Date: {old_date} → {new_date}")
|
|
if clear_link:
|
|
old_link = old_bounty.link or "(none)"
|
|
changes.append(f"Link: {old_link} → (cleared)")
|
|
if clear_date:
|
|
old_date = (
|
|
time.strftime("%d %b %Y %H:%M", time.localtime(old_bounty.due_date_ts))
|
|
if old_bounty.due_date_ts
|
|
else "(none)"
|
|
)
|
|
changes.append(f"Date: {old_date} → (cleared)")
|
|
|
|
if changes:
|
|
await update.message.reply_text(
|
|
f"✅ Bounty #{bounty_id} updated:\n" + "\n".join(changes)
|
|
)
|
|
else:
|
|
await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
|
|
else:
|
|
await update.message.reply_text("Bounty not found.")
|
|
|
|
|
|
cmd_edit = cmd_update
|
|
|
|
|
|
async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
if not args:
|
|
await update.message.reply_text("Usage: /delete <bounty_id> [bounty_id ...]")
|
|
return
|
|
|
|
try:
|
|
bounty_ids = [int(arg) for arg in args]
|
|
except ValueError:
|
|
await update.message.reply_text("Invalid bounty ID.")
|
|
return
|
|
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
|
|
try:
|
|
results = BOUNTY_SERVICE.delete_bounties(
|
|
room_id=room_id,
|
|
bounty_ids=bounty_ids,
|
|
user_id=user_id,
|
|
)
|
|
except PermissionError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
return
|
|
|
|
response_lines = []
|
|
for bounty_id, result in results.items():
|
|
if result == "deleted":
|
|
response_lines.append(f"✅ Bounty #{bounty_id} deleted.")
|
|
elif result == "not_found":
|
|
response_lines.append(f"⛔ Bounty #{bounty_id} not found.")
|
|
elif result == "permission_denied":
|
|
response_lines.append(f"⛔ Bounty #{bounty_id} permission denied.")
|
|
|
|
await update.message.reply_text("\n".join(response_lines))
|
|
|
|
|
|
async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
if not is_group(update):
|
|
await update.message.reply_text("⛔ /track is only available in groups.")
|
|
return
|
|
|
|
args = extract_args(update.message.text)
|
|
if not args:
|
|
await update.message.reply_text("Usage: /track <bounty_id>")
|
|
return
|
|
|
|
try:
|
|
bounty_id = int(args[0])
|
|
except ValueError:
|
|
await update.message.reply_text("Invalid bounty ID.")
|
|
return
|
|
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
|
|
try:
|
|
if TRACKING_SERVICE.track_bounty(room_id, user_id, bounty_id):
|
|
await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
|
|
else:
|
|
await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
|
|
except ValueError as e:
|
|
await update.message.reply_text(str(e))
|
|
|
|
|
|
async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
if not is_group(update):
|
|
await update.message.reply_text("⛔ /untrack is only available in groups.")
|
|
return
|
|
|
|
args = extract_args(update.message.text)
|
|
if not args:
|
|
await update.message.reply_text("Usage: /untrack <bounty_id>")
|
|
return
|
|
|
|
try:
|
|
bounty_id = int(args[0])
|
|
except ValueError:
|
|
await update.message.reply_text("Invalid bounty ID.")
|
|
return
|
|
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
|
|
if TRACKING_SERVICE.untrack_bounty(room_id, user_id, bounty_id):
|
|
await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
|
|
else:
|
|
await update.message.reply_text("Not tracking bounty #{bounty_id}.")
|
|
|
|
|
|
async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
|
|
if is_group(update):
|
|
try:
|
|
chat_member = await ctx.bot.get_chat_member(room_id, user_id)
|
|
if chat_member.status == "creator" and not BOUNTY_SERVICE.is_admin(
|
|
room_id, user_id
|
|
):
|
|
BOUNTY_SERVICE.add_admin(room_id, user_id, user_id)
|
|
await update.message.reply_text(
|
|
"👻 JIGAIDO is watching.\n\n"
|
|
"This group's bounty list is now active.\n"
|
|
"You are now an admin (group creator).\n"
|
|
"/bounty — list bounties\n"
|
|
"/add — create a bounty\n"
|
|
"/track — track a bounty\n"
|
|
"/my — your tracked bounties"
|
|
)
|
|
return
|
|
except Exception:
|
|
pass
|
|
|
|
await update.message.reply_text(
|
|
"👻 JIGAIDO is watching.\n\n"
|
|
"This group's bounty list is now active.\n"
|
|
"/bounty — list bounties\n"
|
|
"/add — create a bounty\n"
|
|
"/track — track a bounty\n"
|
|
"/my — your tracked bounties"
|
|
)
|
|
else:
|
|
if not BOUNTY_SERVICE.is_admin(room_id, user_id):
|
|
BOUNTY_SERVICE.add_admin(room_id, user_id, user_id)
|
|
|
|
await update.message.reply_text(
|
|
"👻 JIGAIDO activated.\n\n"
|
|
"Personal bounty list ready.\n"
|
|
"/bounty — list your bounties\n"
|
|
"/add — create a bounty\n"
|
|
"/my — your tracked bounties"
|
|
)
|
|
|
|
|
|
async def cmd_show(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
if not args:
|
|
await update.message.reply_text("Usage: /show <bounty_id>")
|
|
return
|
|
|
|
try:
|
|
bounty_id = int(args[0])
|
|
except ValueError:
|
|
await update.message.reply_text("Invalid bounty ID.")
|
|
return
|
|
|
|
room_id = get_room_id(update)
|
|
bounty = BOUNTY_SERVICE.get_bounty(room_id, bounty_id)
|
|
|
|
if not bounty:
|
|
await update.message.reply_text("Bounty not found.")
|
|
return
|
|
|
|
timezone_str = BOUNTY_SERVICE.get_timezone(room_id)
|
|
|
|
try:
|
|
tz = ZoneInfo(timezone_str)
|
|
except (KeyError, ZoneInfoNotFoundError):
|
|
tz = ZoneInfo("UTC")
|
|
|
|
lines = []
|
|
|
|
title = bounty.text or "(no text)"
|
|
lines.append(f"[#{bounty.id}] {title}")
|
|
|
|
if bounty.link:
|
|
lines.append(f"🔗 {bounty.link}")
|
|
|
|
if bounty.due_date_ts:
|
|
dt_due = datetime.fromtimestamp(bounty.due_date_ts, tz=tz)
|
|
due_str = dt_due.strftime("%d %B %Y %H:%M")
|
|
lines.append(f"📅 {due_str} ({timezone_str})")
|
|
|
|
if bounty.created_by_username:
|
|
lines.append(
|
|
f'👤 <a href="tg://user?id={bounty.created_by_user_id}">{bounty.created_by_username}</a>'
|
|
)
|
|
|
|
dt_created = datetime.fromtimestamp(bounty.created_at, tz=tz)
|
|
created_str = dt_created.strftime("%Y-%m-%d %H:%M")
|
|
lines.append(f"📌 Created: {created_str}")
|
|
|
|
await update.message.reply_text(
|
|
"\n".join(lines), disable_web_page_preview=True, parse_mode=ParseMode.HTML
|
|
)
|
|
|
|
|
|
async def cmd_timezone(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
room_id = get_room_id(update)
|
|
user_id = get_user_id(update)
|
|
|
|
if not args:
|
|
current_tz = BOUNTY_SERVICE.get_timezone(room_id)
|
|
await update.message.reply_text(f"Current timezone: {current_tz}")
|
|
return
|
|
|
|
timezone_str = args[0]
|
|
|
|
try:
|
|
ZoneInfo(timezone_str)
|
|
except (KeyError, ZoneInfoNotFoundError):
|
|
await update.message.reply_text(
|
|
"⛔ Invalid timezone. Use IANA format (e.g., Asia/Jakarta)"
|
|
)
|
|
return
|
|
|
|
try:
|
|
BOUNTY_SERVICE.set_timezone(room_id, timezone_str, user_id)
|
|
except PermissionError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
return
|
|
|
|
await update.message.reply_text(f"✅ Timezone set to {timezone_str}.")
|
|
|
|
|
|
async def cmd_recover(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
room_id = get_room_id(update)
|
|
user_id = get_user_id(update)
|
|
|
|
if not BOUNTY_SERVICE.is_admin(room_id, user_id):
|
|
await update.message.reply_text("⛔ Only admins can perform this action.")
|
|
return
|
|
|
|
if not args:
|
|
deleted_bounties = BOUNTY_SERVICE.list_deleted_bounties(room_id)
|
|
if not deleted_bounties:
|
|
await update.message.reply_text("No recoverable bounties.")
|
|
return
|
|
|
|
deleted_bounties.sort(key=lambda b: b.deleted_at or 0, reverse=True)
|
|
|
|
lines = ["Recoverable bounties:"]
|
|
for b in deleted_bounties[:10]:
|
|
text = (
|
|
b.text[:40] + "..."
|
|
if b.text and len(b.text) > 40
|
|
else (b.text or "(no text)")
|
|
)
|
|
link_str = f" | 🔗 {b.link}" if b.link else ""
|
|
deleted_str = (
|
|
time.strftime("%d %b %Y", time.localtime(b.deleted_at))
|
|
if b.deleted_at
|
|
else "unknown"
|
|
)
|
|
lines.append(f"[#{b.id}] {text}{link_str} | 🗑️ Deleted {deleted_str}")
|
|
|
|
await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
|
|
return
|
|
|
|
try:
|
|
bounty_ids = [int(arg) for arg in args]
|
|
except ValueError:
|
|
await update.message.reply_text("Invalid bounty ID.")
|
|
return
|
|
|
|
results = BOUNTY_SERVICE.recover_bounties(room_id, bounty_ids, user_id)
|
|
|
|
response_lines = []
|
|
for bounty_id, result in results.items():
|
|
if result == "recovered":
|
|
response_lines.append(f"✅ Recovered bounty #{bounty_id}.")
|
|
elif result == "not_found":
|
|
response_lines.append(f"⛔ Bounty #{bounty_id} not found.")
|
|
elif result == "not_deleted":
|
|
response_lines.append(f"⛔ Bounty #{bounty_id} is not deleted.")
|
|
elif result == "permission_denied":
|
|
response_lines.append(f"⛔ Bounty #{bounty_id} permission denied.")
|
|
|
|
await update.message.reply_text("\n".join(response_lines))
|
|
|
|
|
|
def _find_user_id_by_username(room_id: int, username: str) -> int | None:
|
|
"""Find user_id by username from bounty creators in the room."""
|
|
bounties = BOUNTY_SERVICE.list_bounties(room_id)
|
|
for bounty in bounties:
|
|
if (
|
|
bounty.created_by_username
|
|
and bounty.created_by_username.lower() == username.lower()
|
|
):
|
|
return bounty.created_by_user_id
|
|
return None
|
|
|
|
|
|
def _find_username_by_user_id(room_id: int, user_id: int) -> str | None:
|
|
"""Find username by user_id from bounty creators in the room."""
|
|
bounties = BOUNTY_SERVICE.list_bounties(room_id)
|
|
for bounty in bounties:
|
|
if bounty.created_by_user_id == user_id:
|
|
return bounty.created_by_username
|
|
return None
|
|
|
|
|
|
async def cmd_admin(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
args = extract_args(update.message.text)
|
|
if not args:
|
|
admins = BOUNTY_SERVICE.list_admins(get_room_id(update))
|
|
if not admins:
|
|
await update.message.reply_text("No admins in this room.")
|
|
return
|
|
admin_mentions = []
|
|
for admin_id in admins:
|
|
username = _find_username_by_user_id(get_room_id(update), admin_id)
|
|
if username:
|
|
admin_mentions.append(f"@{username}")
|
|
else:
|
|
admin_mentions.append(f"user#{admin_id}")
|
|
await update.message.reply_text(
|
|
f"Room Admins:\n" + "\n".join(f"- {m}" for m in admin_mentions)
|
|
)
|
|
return
|
|
|
|
if args[0] not in ("add", "remove"):
|
|
await update.message.reply_text(
|
|
"Usage:\n"
|
|
"/admin — list admins\n"
|
|
"/admin add @username — add admin\n"
|
|
"/admin remove @username — remove admin"
|
|
)
|
|
return
|
|
|
|
subcommand = args[0]
|
|
|
|
if len(args) < 2:
|
|
await update.message.reply_text(f"Usage: /admin {subcommand} @username")
|
|
return
|
|
|
|
raw_username = args[1]
|
|
if not raw_username.startswith("@"):
|
|
await update.message.reply_text(f"Usage: /admin {subcommand} @username")
|
|
return
|
|
|
|
username = raw_username[1:]
|
|
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
|
|
if not BOUNTY_SERVICE.is_admin(room_id, user_id):
|
|
await update.message.reply_text("⛔ Only admins can perform this action.")
|
|
return
|
|
|
|
target_user_id = _find_user_id_by_username(room_id, username)
|
|
|
|
if target_user_id is None:
|
|
await update.message.reply_text(f"⛔ User @{username} not found.")
|
|
return
|
|
|
|
try:
|
|
if subcommand == "add":
|
|
BOUNTY_SERVICE.add_admin(room_id, target_user_id, user_id)
|
|
await update.message.reply_text(f"✅ @{username} is now an admin.")
|
|
elif subcommand == "remove":
|
|
BOUNTY_SERVICE.remove_admin(room_id, target_user_id, user_id)
|
|
await update.message.reply_text(f"✅ @{username} is no longer an admin.")
|
|
except PermissionError as e:
|
|
await update.message.reply_text(f"⛔ {e}")
|
|
|
|
|
|
async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
|
|
user_id = get_user_id(update)
|
|
room_id = get_room_id(update)
|
|
is_admin = BOUNTY_SERVICE.is_admin(room_id, user_id)
|
|
|
|
if is_admin:
|
|
lines = [
|
|
"👻 JIGAIDO Commands (Admin):\n",
|
|
"📋 Bounty Management:",
|
|
"/bounty — list bounties",
|
|
"/add — add bounty",
|
|
"/edit — edit bounty",
|
|
"/delete — delete bounty",
|
|
"/recover — recover deleted bounties",
|
|
"",
|
|
"🔗 Tracking:",
|
|
"/track — track bounty",
|
|
"/untrack — stop tracking",
|
|
"/my — your tracked bounties",
|
|
"/show — show bounty details",
|
|
"",
|
|
"⚙️ Room Management:",
|
|
"/admin — manage admins",
|
|
"/timezone — get/set timezone",
|
|
"",
|
|
"/start — re-initialize",
|
|
"/help — show this message",
|
|
]
|
|
else:
|
|
lines = [
|
|
"👻 JIGAIDO Commands:\n",
|
|
"/bounty — list bounties",
|
|
"/track — track bounty",
|
|
"/untrack — stop tracking",
|
|
"/my — your tracked bounties",
|
|
"/show — show bounty details",
|
|
"/start — re-initialize",
|
|
"/help — show this message",
|
|
]
|
|
|
|
await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
|