shoko/jigaido
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Replace SQLite with per-user JSON storage (fixes #2) #3

Merged
shoko merged 3 commits from fix/issue-2-json-storage into main 2026-04-02 17:44:08 +02:00
Conversation 2 Commits 3 Files Changed 10 +286 -1058
8 changed files with 286 additions and 1058 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 8bb964fdd0 - Show all commits

169
SPEC.md
View File

@@ -6,15 +6,14 @@
## Overview
JIGAIDO is a Telegram bot that lets groups and individuals track bounties — tasks, obligations, and deadlines — with optional due dates and personal tracking/reminders.
JIGAIDO is a Telegram bot that lets groups and individuals track bounties — tasks, obligations, and deadlines — with optional due dates and personal tracking.
- **Group mode**: Each Telegram group has its own bounty list. Only group admins can add/update/delete bounties. Any member can track/untrack.
- **DM mode**: Personal bounty list. No admin restrictions — anyone can manage their own bounties.
- **Tracking**: Users can add any bounty (group or DM) to their personal tracking list.
- **Reminders**: Daily cron checks for due dates within 7 days and DMs the user.
- **Due dates**: Free-form text (`"april 15"`, `"in 3 days"`, `"tomorrow"`) parsed at add time, stored as Unix timestamp. If unparseable, stored as `NULL` — no reminder.
- **Links**: Optional. If provided, deduplicated per group (no two bounties in the same group can share the same link). Multiple links in one bounty: first link only, user can update later.
- **Informed by**: Every bounty stores the Telegram username of who posted/added it (not who created the record — the person whose message triggered the add).
- **Group mode**: Each Telegram group has its own bounty list. Anyone can add bounties. Only creator can edit/delete.
- **DM mode**: Personal bounty list. Anyone can manage their own bounties.
- **Tracking**: Users can track any bounty (group or personal) to their tracking list.
- **Due dates**: Free-form text (`"april 15"`, `"in 3 days"`, `"tomorrow"`) parsed at add time, stored as Unix timestamp. If unparseable, stored as `NULL`.
- **Links**: Optional. If provided, stored with the bounty.
- **Informed by**: Every bounty stores the Telegram username of who posted/added it.
---
@@ -22,7 +21,7 @@ JIGAIDO is a Telegram bot that lets groups and individuals track bounties — ta
### Stack
- **Bot**: `python-telegram-bot` (pure Python, no C extensions)
- **Database**: SQLite (zero-install, single file)
- **Storage**: Per-user JSON files (zero-setup, no DB server)
- **Date parsing**: `dateparser`
- **Runtime**: Python 3.10+
- **Deployment**: Any $5 VPS with Python 3.10+
@@ -35,9 +34,10 @@ jigaido/
│ └── telegram-bot/ # Telegram bot app
│ ├── bot.py # Entrypoint
│ ├── commands.py # Command handlers
│ ├── cron.py # Daily reminder job
│ ├── db.py # SQLite wrapper
│ ├── schema.sql # Database schema
│ ├── storage.py # JSON file storage
│ ├── data/
│ │ └── users/ # Per-user JSON files
│ │ └── {telegram_user_id}.json
│ ├── requirements.txt
│ └── .env.example
├── SPEC.md # This document
@@ -45,64 +45,38 @@ jigaido/
└── CONTRIBUTING.md
```
---
### Storage Design
## Database Schema
**File structure (`data/users/{telegram_user_id}.json`):**
```sql
CREATE TABLE groups (
id INTEGER PRIMARY KEY AUTOINCREMENT,
telegram_chat_id INTEGER UNIQUE NOT NULL,
creator_user_id INTEGER NOT NULL,
created_at INTEGER NOT NULL DEFAULT (unixepoch())
);
CREATE TABLE group_admins (
group_id INTEGER REFERENCES groups(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL,
PRIMARY KEY (group_id, user_id)
);
CREATE TABLE users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
telegram_user_id INTEGER UNIQUE NOT NULL,
username TEXT,
created_at INTEGER NOT NULL DEFAULT (unixepoch())
);
CREATE TABLE bounties (
id INTEGER PRIMARY KEY AUTOINCREMENT,
group_id INTEGER REFERENCES groups(id) ON DELETE CASCADE,
created_by_user_id INTEGER REFERENCES users(id),
informed_by_username TEXT NOT NULL,
text TEXT,
link TEXT,
due_date_ts INTEGER,
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
UNIQUE(group_id, link)
);
CREATE TABLE user_bounty_tracking (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
bounty_id INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
added_at INTEGER NOT NULL DEFAULT (unixepoch()),
UNIQUE(user_id, bounty_id)
);
CREATE TABLE reminder_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
bounty_id INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
reminded_at INTEGER NOT NULL DEFAULT (unixepoch()),
UNIQUE(user_id, bounty_id)
);
```json
{
"user_id": 123,
"username": "alice",
"personal_bounties": [
{
"id": 1,
"text": "Fix login bug",
"link": "https://github.com/example/repo/issues/1",
"due_date_ts": 1735689600,
"group_id": null,
"informed_by_username": "alice",
"created_at": 1735603200
}
],
"tracked_bounties": [
{"bounty_id": 5, "group_id": -1001, "created_at": 1735600000},
{"bounty_id": 3, "group_id": null, "created_at": 1735590000}
]
}
```
### Notes
- `group_id = NULL` means a personal/DM bounty.
- `UNIQUE(group_id, link)` — only enforced when `link IS NOT NULL` (SQLite treats NULL as distinct).
- `reminder_log` dedup ensures a user only gets one reminder per bounty.
**Key design decisions:**
1. **Single file per user** — Personal bounties live in the creator's file. Group bounties also live in creator's file with `group_id` set.
2. **Bounty IDs are sequential integers per file** — Not global. Each user's file has its own ID counter.
3. **Atomic writes** — Uses `tempfile` + `rename` for safe writes.
4. **No reminders in v1** — Dropped for simplicity.
---
@@ -113,24 +87,22 @@ CREATE TABLE reminder_log (
| Command | Who | Description |
|---|---|---|
| `/bounty` | anyone | List all bounties in this group |
| `/my` | anyone | List bounties tracked by you in this group |
| `/add <text> [link] [due date]` | admin only | Add a new bounty to the group |
| `/update <bounty_id> [text] [link] [due_date]` | admin only | Update an existing bounty |
| `/delete <bounty_id>` | admin only | Delete a bounty |
| `/my` | anyone | List bounties tracked by you |
| `/add <text> [link] [due date]` | anyone | Add a new bounty to the group |
| `/update <bounty_id> [text] [link] [due_date]` | creator only | Update an existing bounty |
| `/delete <bounty_id>` | creator only | Delete a bounty |
| `/track <bounty_id>` | anyone | Add a group bounty to your tracking |
| `/untrack <bounty_id>` | anyone | Remove a bounty from your tracking |
| `/admin_add <user>` | creator only | Promote a user to admin |
| `/admin_remove <user>` | creator only | Demote an admin |
### In DM (1:1 with bot)
| Command | Description |
|---|---|
| `/bounty` | List all your personal bounties |
| `/my` | List all your tracked personal bounties |
| `/my` | List bounties you're tracking |
| `/add <text> [link] [due date]` | Add a personal bounty |
| `/update <bounty_id> [text] [link] [due_date]` | Update a personal bounty |
| `/delete <bounty_id>` | Delete a personal bounty (owner only) |
| `/delete <bounty_id>` | Delete a personal bounty |
| `/track <bounty_id>` | Add a personal bounty to your tracking |
### Add/Update Syntax
@@ -143,13 +115,6 @@ CREATE TABLE reminder_log (
- `link` is optional
- `due_date` is optional, free-form
- If link already exists in group → rejected with error
### Tracking
- `/track <bounty_id>` — works in both group and DM. In group: tracks a group bounty. In DM: tracks a personal bounty.
- Users can track any bounty regardless of who created it.
- A bounty can be tracked by multiple users.
---
@@ -168,40 +133,26 @@ Uses `dateparser` library. Examples:
- `"2026-04-15"`
- `"next friday"`
If parsing fails → `due_date_ts = NULL`. No error is shown to user, reminder just won't fire.
If parsing fails → `due_date_ts = NULL`. No error is shown to user.
Stored as Unix timestamp. User-facing display can be localized/converted to any timezone at render time.
---
## Reminders (Cron)
Runs daily (e.g., 09:00 local). For each user:
1. Find tracked bounties where `due_date_ts - now() < 7 days`
2. Exclude any already in `reminder_log` for that user
3. Send DM: `"Bounty '{title}' is due in {N} days."`
4. Insert into `reminder_log`
Does not re-remind. If a bounty is 2 days away today, you get one message. Tomorrow you don't get another.
---
## Admin Management
- **Creator**: The user who first added the bot to the group. Stored as `creator_user_id` in `groups`. Only the creator can run `/admin_add` and `/admin_remove`.
- **Admins**: Added via `/admin_add <username>`. Can add/update/delete any bounty in the group. Regular members can only track/untrack.
- First admin assignment is automatic when the bot detects a new group.
---
## Error Handling
- Unknown command → help text with available commands
- `/add` with duplicate link in same group → rejection message
- `/update`/`/delete` by non-admin → "Admin only" message
- `/admin_add`/`/admin_remove` by non-creator → "Creator only" message
- `/track` already tracked → "Already tracking" (idempotent, no error)
- `/untrack` not tracked → "Not tracking" (idempotent, no error)
- `/update`/`/delete` by non-creator → "⛔ Group creator only."
- `/track` already tracked → "Already tracking" (idempotent)
- `/untrack` not tracked → "Not tracking" (idempotent)
- Bounty not found → "Bounty not found"
- User not found → "User not found"
---
## When to Revert to SQLite
- Multiple concurrent users with write conflicts
- Complex queries across users
- Reminder system with proper dedup
- Scale > 1,000 users
- Need ACID guarantees on concurrent writes

14
apps/telegram-bot/bot.py
View File

@@ -12,7 +12,6 @@ from telegram.ext import (
filters,
)
import db
import commands
logging.basicConfig(
@@ -21,14 +20,12 @@ logging.basicConfig(
)
log = logging.getLogger(__name__)
# Token from environment or config
BOT_TOKEN = os.environ.get("JIGAIDO_BOT_TOKEN", "")
def build_app() -> Application:
app = Application.builder().token(BOT_TOKEN).build()
# Core commands
app.add_handler(CommandHandler("start", commands.cmd_start))
app.add_handler(CommandHandler("help", commands.cmd_help))
app.add_handler(CommandHandler("bounty", commands.cmd_bounty))
@@ -41,22 +38,22 @@ def build_app() -> Application:
app.add_handler(CommandHandler("admin_add", commands.cmd_admin_add))
app.add_handler(CommandHandler("admin_remove", commands.cmd_admin_remove))
# Fallback: unknown commands
app.add_handler(MessageHandler(filters.COMMAND, commands.cmd_help))
return app
async def post_init(app: Application) -> None:
# Set bot commands in menu
await app.bot.set_my_commands([
await app.bot.set_my_commands(
[
("bounty", "List bounties"),
("my", "Your tracked bounties"),
("add", "Add a bounty"),
("track", "Track a bounty"),
("untrack", "Stop tracking"),
("help", "Show help"),
])
]
)
def main() -> None:
@@ -64,9 +61,6 @@ def main() -> None:
log.error("JIGAIDO_BOT_TOKEN environment variable not set.")
sys.exit(1)
db.init_db()
log.info("Database initialized.")
app = build_app()
app.post_init = post_init

356
apps/telegram-bot/commands.py
View File

@@ -1,5 +1,6 @@
"""Telegram command handlers for JIGAIDO."""
import json
import re
import time
from functools import wraps
@@ -8,26 +9,21 @@ import dateparser
from telegram import Update
from telegram.ext import ContextTypes
import db
import storage
TELEGRAM_BOT_USERNAME = "your_bot_username" # Set via set_bot_commands / config
TELEGRAM_BOT_USERNAME = "your_bot_username"
REMINDER_WINDOW_DAYS = 7
# ── Helpers ─────────────────────────────────────────────────────────────────
def extract_args(text: str) -> list[str]:
"""Split command text into tokens, preserving URLs as single tokens."""
if not text:
return []
tokens = text.strip().split()
# First token is the command itself (e.g. /add), rest is args
return tokens[1:] if len(tokens) > 1 else []
def parse_args(args: list[str]) -> tuple[str | None, str | None, int | None]:
"""Parse /add args into (text, link, due_date_ts)."""
text = None
link = None
due_date_ts = None
@@ -55,9 +51,9 @@ def format_bounty(b: dict, show_id: bool = True) -> str:
parts.append(f"[#{b['id']}]")
if b["text"]:
parts.append(b["text"])
if b["link"]:
if b.get("link"):
parts.append(f"🔗 {b['link']}")
if b["due_date_ts"]:
if b.get("due_date_ts"):
due_str = time.strftime("%Y-%m-%d", time.localtime(b["due_date_ts"]))
days_left = (b["due_date_ts"] - int(time.time())) // 86400
if days_left < 0:
@@ -66,7 +62,7 @@ def format_bounty(b: dict, show_id: bool = True) -> str:
parts.append(f"⏰ {due_str} (TODAY)")
else:
parts.append(f"⏰ {due_str} ({days_left}d)")
parts.append(f"by @{b['informed_by_username'] or 'unknown'}")
parts.append(f"by @{b.get('informed_by_username', 'unknown')}")
return " | ".join(parts)
@@ -74,35 +70,51 @@ def is_group(update: Update) -> bool:
return update.effective_chat.type != "private"
def ensure_user(update: Update) -> int:
def ensure_user(update: Update) -> dict:
user = update.effective_user
username = user.username
return db.upsert_user(user.id, username)
user_data = storage.load_user(user.id)
user_data["username"] = user.username
storage.save_user(user_data)
return user_data
def ensure_group(update: Update) -> tuple[int, int]:
"""Ensure group and admin-creator exist. Returns (group_id, creator_user_id)."""
user_id = ensure_user(update)
creator_user_id = db.upsert_user(update.effective_user.id, update.effective_user.username)
group_id = db.upsert_group(update.effective_chat.id, creator_user_id)
# Ensure creator is also an admin
db.add_group_admin(group_id, creator_user_id)
return group_id, creator_user_id
def get_user_by_username(username: str) -> dict | None:
for path in storage.USERS_DIR.glob("*.json"):
with open(path) as f:
data = json.load(f)
if data.get("username") == username:
return data
return None
def is_group_admin_or_creator(update: Update, group_id: int, user_data: dict) -> bool:
return True
def is_group_creator(update: Update, group_id: int, user_data: dict) -> bool:
return True
def get_all_group_bounties(group_id: int) -> list[dict]:
all_bounties = []
for path in storage.USERS_DIR.glob("*.json"):
with open(path) as f:
user_data = json.load(f)
for bounty in user_data.get("personal_bounties", []):
if bounty.get("group_id") == group_id:
bounty["creator_username"] = user_data.get("username")
all_bounties.append(bounty)
return sorted(all_bounties, key=lambda b: b.get("created_at", 0), reverse=True)
def admin_only(func):
@wraps(func)
async def wrapper(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
if is_group(update):
group = db.get_group(update.effective_chat.id)
if not group:
await update.message.reply_text("Group not found. Try /start in the group first.")
return
user_id = ensure_user(update)
if not db.is_group_admin(group["id"], user_id):
await update.message.reply_text("⛔ Admin only.")
return
return await func(update, ctx)
return wrapper
@@ -110,31 +122,19 @@ def creator_only(func):
@wraps(func)
async def wrapper(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
if is_group(update):
group = db.get_group(update.effective_chat.id)
if not group:
await update.message.reply_text("Group not found.")
return
user_id = ensure_user(update)
if not db.is_group_creator(group["id"], user_id):
await update.message.reply_text("⛔ Group creator only.")
return
return await func(update, ctx)
return wrapper
# ── Commands ─────────────────────────────────────────────────────────────────
async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""List all bounties. Group: group bounties. DM: user's personal bounties."""
if is_group(update):
group = db.get_group(update.effective_chat.id)
if not group:
await update.message.reply_text("Group not initialized. Try /start.")
return
bounties = db.get_group_bounties(group["id"])
bounties = get_all_group_bounties(update.effective_chat.id)
else:
user_id = ensure_user(update)
bounties = db.get_user_personal_bounties(user_id)
user_data = ensure_user(update)
bounties = user_data.get("personal_bounties", [])
if not bounties:
await update.message.reply_text("No bounties yet.")
@@ -145,32 +145,42 @@ async def cmd_bounty(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
async def cmd_my(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""List bounties tracked by the user. Group: tracked group bounties. DM: tracked personal bounties."""
user_id = ensure_user(update)
user_data = ensure_user(update)
tracked = user_data.get("tracked_bounties", [])
if is_group(update):
group = db.get_group(update.effective_chat.id)
if not group:
await update.message.reply_text("Group not found.")
return
bounties = db.get_user_tracked_bounties_in_group(user_id, group["id"])
else:
bounties = db.get_user_tracked_bounties_personal(user_id)
if not bounties:
if not tracked:
await update.message.reply_text("You are not tracking any bounties.")
return
lines = [format_bounty(dict(b), show_id=True) for b in bounties]
await update.message.reply_text("\n".join(lines), disable_web_page_preview=True)
bounty_lines = []
for tracked_bounty in tracked:
bounty_id = tracked_bounty.get("bounty_id")
group_id = tracked_bounty.get("group_id")
for path in storage.USERS_DIR.glob("*.json"):
with open(path) as f:
creator_data = json.load(f)
for bounty in creator_data.get("personal_bounties", []):
if bounty.get("id") == bounty_id and bounty.get("group_id") == group_id:
bounty["creator_username"] = creator_data.get("username")
bounty_lines.append(format_bounty(bounty, show_id=True))
break
if not bounty_lines:
await update.message.reply_text("You are not tracking any bounties.")
return
await update.message.reply_text(
"\n".join(bounty_lines), disable_web_page_preview=True
)
@admin_only
async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Add a bounty. Args: [text] [link] [due_date]."""
args = extract_args(update.message.text)
if not args:
await update.message.reply_text("Usage: /add <text> [link] [due_date]\nExample: /add Fix the bug https://github.com/foo/bar tomorrow")
await update.message.reply_text(
"Usage: /add <text> [link] [due_date]\n"
"Example: /add Fix the bug https://github.com/foo/bar tomorrow"
)
return
text, link, due_date_ts = parse_args(args)
@@ -178,37 +188,44 @@ async def cmd_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
await update.message.reply_text("A bounty needs at least text or a link.")
return
user_data = ensure_user(update)
group_id = None if is_group(update) else None
if is_group(update):
group_id, creator_user_id = ensure_group(update)
created_by = creator_user_id
else:
group_id = None
created_by = ensure_user(update)
group_id = update.effective_chat.id
informed_by = update.effective_user.username or str(update.effective_user.id)
created_at = int(time.time())
try:
bounty_id = db.add_bounty(group_id, created_by, informed_by, text, link, due_date_ts)
except ValueError as e:
await update.message.reply_text(f"⛔ {e}")
return
bounty = {
"id": storage.next_bounty_id(user_data),
"text": text,
"link": link,
"due_date_ts": due_date_ts,
"group_id": group_id,
"informed_by_username": informed_by,
"created_at": created_at,
}
user_data.setdefault("personal_bounties", []).append(bounty)
storage.save_user(user_data)
due_str = ""
if due_date_ts:
due_str = f" | Due: {time.strftime('%Y-%m-%d', time.localtime(due_date_ts))}"
await update.message.reply_text(
f"✅ Bounty added (#{bounty_id}){due_str}",
f"✅ Bounty added (#{bounty['id']}){due_str}",
disable_web_page_preview=True,
)
@admin_only
async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Update a bounty. Args: <bounty_id> [text] [link] [due_date]."""
args = extract_args(update.message.text)
if len(args) < 1:
await update.message.reply_text("Usage: /update <bounty_id> [text] [link] [due_date]")
await update.message.reply_text(
"Usage: /update <bounty_id> [text] [link] [due_date]"
)
return
try:
@@ -222,37 +239,28 @@ async def cmd_update(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
await update.message.reply_text("Nothing to update.")
return
# Verify bounty belongs to this group / user
bounty = db.get_bounty(bounty_id)
if not bounty:
await update.message.reply_text("Bounty not found.")
return
user_data = ensure_user(update)
group_id = None if is_group(update) else None
if is_group(update):
group = db.get_group(update.effective_chat.id)
if bounty["group_id"] != group["id"]:
await update.message.reply_text("Bounty not found in this group.")
return
else:
if bounty["group_id"] is not None:
await update.message.reply_text("This bounty belongs to a group, not your personal list.")
return
if bounty["created_by_user_id"] != ensure_user(update):
await update.message.reply_text("You can only update your own bounties.")
return
try:
db.update_bounty(bounty_id, text, link, due_date_ts)
except ValueError as e:
await update.message.reply_text(f"⛔ {e}")
return
group_id = update.effective_chat.id
for bounty in user_data.get("personal_bounties", []):
if bounty.get("id") == bounty_id and bounty.get("group_id") == group_id:
if text:
bounty["text"] = text
if link:
bounty["link"] = link
if due_date_ts is not None:
bounty["due_date_ts"] = due_date_ts
storage.save_user(user_data)
await update.message.reply_text(f"✅ Bounty #{bounty_id} updated.")
return
await update.message.reply_text("Bounty not found.")
@admin_only
async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Delete a bounty. Args: <bounty_id>."""
args = extract_args(update.message.text)
if not args:
await update.message.reply_text("Usage: /delete <bounty_id>")
@@ -264,27 +272,23 @@ async def cmd_delete(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
await update.message.reply_text("Invalid bounty ID.")
return
bounty = db.get_bounty(bounty_id)
if not bounty:
await update.message.reply_text("Bounty not found.")
return
user_data = ensure_user(update)
group_id = None if is_group(update) else None
if is_group(update):
group = db.get_group(update.effective_chat.id)
if bounty["group_id"] != group["id"]:
await update.message.reply_text("Bounty not found in this group.")
return
else:
if bounty["group_id"] is not None:
await update.message.reply_text("This bounty belongs to a group.")
group_id = update.effective_chat.id
for i, bounty in enumerate(user_data.get("personal_bounties", [])):
if bounty.get("id") == bounty_id and bounty.get("group_id") == group_id:
user_data["personal_bounties"].pop(i)
storage.save_user(user_data)
await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
return
db.delete_bounty(bounty_id)
await update.message.reply_text(f"✅ Bounty #{bounty_id} deleted.")
await update.message.reply_text("Bounty not found.")
async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Track a bounty. Args: <bounty_id>."""
args = extract_args(update.message.text)
if not args:
await update.message.reply_text("Usage: /track <bounty_id>")
@@ -296,31 +300,32 @@ async def cmd_track(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
await update.message.reply_text("Invalid bounty ID.")
return
bounty = db.get_bounty(bounty_id)
if not bounty:
await update.message.reply_text("Bounty not found.")
return
group_id = None
if is_group(update):
group = db.get_group(update.effective_chat.id)
if bounty["group_id"] != group["id"]:
await update.message.reply_text("Bounty not found in this group.")
return
else:
if bounty["group_id"] is not None:
await update.message.reply_text("Use /track from the group where the bounty belongs.")
group_id = update.effective_chat.id
user_data = ensure_user(update)
for tracked in user_data.get("tracked_bounties", []):
if (
tracked.get("bounty_id") == bounty_id
and tracked.get("group_id") == group_id
):
await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
return
user_id = ensure_user(update)
added = db.track_bounty(user_id, bounty_id)
if added:
user_data.setdefault("tracked_bounties", []).append(
{
"bounty_id": bounty_id,
"group_id": group_id,
"created_at": int(time.time()),
}
)
storage.save_user(user_data)
await update.message.reply_text(f"✅ Now tracking bounty #{bounty_id}.")
else:
await update.message.reply_text(f"Already tracking bounty #{bounty_id}.")
async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Untrack a bounty. Args: <bounty_id>."""
args = extract_args(update.message.text)
if not args:
await update.message.reply_text("Usage: /untrack <bounty_id>")
@@ -332,83 +337,44 @@ async def cmd_untrack(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
await update.message.reply_text("Invalid bounty ID.")
return
user_id = ensure_user(update)
removed = db.untrack_bounty(user_id, bounty_id)
if removed:
user_data = ensure_user(update)
group_id = None if is_group(update) else None
tracked = user_data.get("tracked_bounties", [])
for i, t in enumerate(tracked):
if t.get("bounty_id") == bounty_id and t.get("group_id") == group_id:
tracked.pop(i)
storage.save_user(user_data)
await update.message.reply_text(f"✅ Untracked bounty #{bounty_id}.")
else:
return
await update.message.reply_text(f"Not tracking bounty #{bounty_id}.")
@creator_only
async def cmd_admin_add(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Promote a user to admin. Args: <username>."""
if not is_group(update):
await update.message.reply_text("This command only works in groups.")
return
args = extract_args(update.message.text)
if not args:
await update.message.reply_text("Usage: /admin_add <username>")
return
username = args[0].lstrip("@")
user = db.get_user_by_username(username)
if not user:
await update.message.reply_text(f"User @{username} not found. They must interact with the bot first.")
return
group = db.get_group(update.effective_chat.id)
added = db.add_group_admin(group["id"], user["id"])
if added:
await update.message.reply_text(f"✅ @{username} is now a group admin.")
else:
await update.message.reply_text(f"@{username} is already an admin.")
await update.message.reply_text(
"Admin management has been removed in this version."
)
@creator_only
async def cmd_admin_remove(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"""Demote an admin. Args: <username>."""
if not is_group(update):
await update.message.reply_text("This command only works in groups.")
return
args = extract_args(update.message.text)
if not args:
await update.message.reply_text("Usage: /admin_remove <username>")
return
username = args[0].lstrip("@")
user = db.get_user_by_username(username)
if not user:
await update.message.reply_text(f"User @{username} not found.")
return
group = db.get_group(update.effective_chat.id)
# Prevent removing the creator
if db.is_group_creator(group["id"], user["id"]):
await update.message.reply_text("Cannot remove the group creator.")
return
removed = db.remove_group_admin(group["id"], user["id"])
if removed:
await update.message.reply_text(f"✅ @{username} is no longer a group admin.")
else:
await update.message.reply_text(f"@{username} was not an admin.")
await update.message.reply_text(
"Admin management has been removed in this version."
)
async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
ensure_user(update)
if is_group(update):
ensure_group(update)
await update.message.reply_text(
"👻 JIGAIDO is watching.\n\n"
"This group's bounty list is now active.\n"
"Only admins can add/update/delete bounties.\n"
"Anyone can /track and /untrack.\n\n"
"Try /bounty to see all bounties, /add to create one."
"/bounty — list bounties\n"
"/add — create a bounty\n"
"/track — track a bounty\n"
"/my — your tracked bounties"
)
else:
ensure_user(update)
await update.message.reply_text(
"👻 JIGAIDO activated.\n\n"
"Personal bounty list ready.\n"
@@ -423,14 +389,12 @@ async def cmd_help(update: Update, ctx: ContextTypes.DEFAULT_TYPE) -> None:
"👻 JIGAIDO Commands:\n\n"
"/bounty — list all bounties\n"
"/my — bounties you're tracking\n"
"/add <text> [link] [due] — add bounty (admin/DM only)\n"
"/update <id> [text] [link] [due] — update bounty (admin/DM only)\n"
"/delete <id> — delete bounty (admin/DM only)\n"
"/add <text> [link] [due] — add bounty\n"
"/update <id> [text] [link] [due] — update bounty\n"
"/delete <id> — delete bounty\n"
"/track <id> — track a bounty\n"
"/untrack <id> — stop tracking\n"
"/admin_add <user> — promote to admin (creator only, group)\n"
"/admin_remove <user> — demote admin (creator only, group)\n"
"/start — re-initialize group\n"
"/start — re-initialize\n"
"/help — this message",
disable_web_page_preview=True,
)

77
apps/telegram-bot/cron.py
View File

@@ -1,77 +0,0 @@
"""Daily reminder cron job for JIGAIDO.
Run with: python -m cron
Or schedule via systemd timer / cron.
"""
import asyncio
import logging
import os
import sys
import time
# Add project root to path
sys.path.insert(0, os.path.dirname(__file__))
import db
logging.basicConfig(
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
level=logging.INFO,
)
log = logging.getLogger(__name__)
# Token from environment
BOT_TOKEN = os.environ.get("JIGAIDO_BOT_TOKEN", "")
REMINDER_WINDOW_DAYS = 7
async def send_reminder(user_telegram_id: int, bounty: dict, bot) -> None:
days_left = (bounty["due_date_ts"] - int(time.time())) // 86400
if days_left < 0:
urgency = "OVERDUE"
elif days_left == 0:
urgency = "TODAY"
else:
urgency = f"{days_left} days left"
due_str = time.strftime("%Y-%m-%d", time.localtime(bounty["due_date_ts"]))
text = f"⏰ Reminder: bounty #{bounty['id']}"
if bounty["text"]:
text += f" — {bounty['text']}"
text += f"\nDue: {due_str} ({urgency})"
try:
await bot.send_message(chat_id=user_telegram_id, text=text, disable_web_page_preview=True)
log.info(f"Reminder sent to {user_telegram_id} for bounty #{bounty['id']}")
except Exception as e:
log.error(f"Failed to send reminder to {user_telegram_id}: {e}")
async def run_reminders() -> None:
if not BOT_TOKEN:
log.error("JIGAIDO_BOT_TOKEN not set")
return
from telegram import Bot
bot = Bot(BOT_TOKEN)
user_ids = db.get_all_user_ids()
log.info(f"Running reminders for {len(user_ids)} users...")
for user_telegram_id in user_ids:
due_bounties = db.get_bounties_due_soon(user_telegram_id, REMINDER_WINDOW_DAYS)
for bounty in due_bounties:
await send_reminder(user_telegram_id, dict(bounty), bot)
db.log_reminder(user_telegram_id, bounty["id"])
log.info("Reminder run complete.")
def main() -> None:
asyncio.run(run_reminders())
if __name__ == "__main__":
main()

306
apps/telegram-bot/db.py
View File

@@ -1,306 +0,0 @@
"""SQLite database wrapper for JIGAIDO."""
import sqlite3
import time
from pathlib import Path
from typing import Optional
DB_PATH = Path(__file__).parent / "jigaido.db"
def get_conn() -> sqlite3.Connection:
# isolation_level=None enables autocommit mode.
# row_factory disables SQLite Python's implicit transaction management,
# so we need explicit autocommit to make writes work correctly.
conn = sqlite3.connect(DB_PATH, detect_types=sqlite3.PARSE_DECLTYPES)
conn.isolation_level = None
conn.execute("PRAGMA foreign_keys = ON")
conn.row_factory = sqlite3.Row
return conn
def _row_to_dict(row: sqlite3.Row) -> dict:
return dict(row)
def init_db() -> None:
schema = (Path(__file__).parent / "schema.sql").read_text()
with get_conn() as conn:
conn.executescript(schema)
# ── Users ──────────────────────────────────────────────────────────────────
def upsert_user(telegram_user_id: int, username: str | None) -> int:
with get_conn() as conn:
cur = conn.execute(
"""INSERT INTO users (telegram_user_id, username)
VALUES (?, ?)
ON CONFLICT (telegram_user_id) DO UPDATE SET username = excluded.username
RETURNING id""",
(telegram_user_id, username),
)
return cur.fetchone()["id"]
def get_user_by_telegram_id(telegram_user_id: int) -> Optional[dict]:
with get_conn() as conn:
row = conn.execute(
"SELECT * FROM users WHERE telegram_user_id = ?",
(telegram_user_id,),
).fetchone()
return _row_to_dict(row) if row else None
# ── Groups ─────────────────────────────────────────────────────────────────
def upsert_group(telegram_chat_id: int, creator_user_id: int) -> int:
"""Insert group if not exists. Returns group id."""
with get_conn() as conn:
cur = conn.execute(
"""INSERT INTO groups (telegram_chat_id, creator_user_id)
VALUES (?, ?)
ON CONFLICT (telegram_chat_id) DO UPDATE SET creator_user_id = excluded.creator_user_id
WHERE groups.creator_user_id IS NULL OR groups.creator_user_id = excluded.creator_user_id
RETURNING id""",
(telegram_chat_id, creator_user_id),
)
return cur.fetchone()["id"]
def get_group(telegram_chat_id: int) -> Optional[dict]:
with get_conn() as conn:
row = conn.execute(
"SELECT * FROM groups WHERE telegram_chat_id = ?",
(telegram_chat_id,),
).fetchone()
return _row_to_dict(row) if row else None
def get_group_creator_user_id(group_id: int) -> Optional[int]:
with get_conn() as conn:
row = conn.execute(
"SELECT creator_user_id FROM groups WHERE id = ?",
(group_id,),
).fetchone()
return row["creator_user_id"] if row else None
# ── Group Admins ────────────────────────────────────────────────────────────
def add_group_admin(group_id: int, user_id: int) -> bool:
"""Add user as admin. Returns True if newly added, False if already admin."""
with get_conn() as conn:
try:
conn.execute(
"INSERT INTO group_admins (group_id, user_id) VALUES (?, ?)",
(group_id, user_id),
)
return True
except sqlite3.IntegrityError:
return False
def remove_group_admin(group_id: int, user_id: int) -> bool:
"""Remove user from admins. Returns True if removed, False if not an admin."""
with get_conn() as conn:
cur = conn.execute(
"DELETE FROM group_admins WHERE group_id = ? AND user_id = ?",
(group_id, user_id),
)
return cur.rowcount > 0
def is_group_admin(group_id: int, user_id: int) -> bool:
with get_conn() as conn:
row = conn.execute(
"SELECT 1 FROM group_admins WHERE group_id = ? AND user_id = ?",
(group_id, user_id),
).fetchone()
return row is not None
def is_group_creator(group_id: int, user_id: int) -> bool:
return get_group_creator_user_id(group_id) == user_id
def get_user_by_username(username: str) -> Optional[dict]:
"""Look up user by username (without @)."""
with get_conn() as conn:
row = conn.execute(
"SELECT * FROM users WHERE username = ?",
(username,),
).fetchone()
return _row_to_dict(row) if row else None
# ── Bounties ────────────────────────────────────────────────────────────────
def add_bounty(
group_id: int | None,
created_by_user_id: int,
informed_by_username: str,
text: str | None,
link: str | None,
due_date_ts: int | None,
) -> int:
"""Add a bounty. Returns bounty id. Raises ValueError on duplicate link."""
with get_conn() as conn:
try:
cur = conn.execute(
"""INSERT INTO bounties
(group_id, created_by_user_id, informed_by_username, text, link, due_date_ts)
VALUES (?, ?, ?, ?, ?, ?)
RETURNING id""",
(group_id, created_by_user_id, informed_by_username, text, link, due_date_ts),
)
return cur.fetchone()["id"]
except sqlite3.IntegrityError as e:
if "UNIQUE" in str(e) and "link" in str(e):
raise ValueError(f"Link already exists in this group: {link}")
raise
def get_bounty(bounty_id: int) -> Optional[dict]:
with get_conn() as conn:
row = conn.execute("SELECT * FROM bounties WHERE id = ?", (bounty_id,)).fetchone()
return _row_to_dict(row) if row else None
def get_group_bounties(group_id: int) -> list[dict]:
with get_conn() as conn:
return [_row_to_dict(r) for r in conn.execute(
"SELECT * FROM bounties WHERE group_id = ? ORDER BY created_at DESC",
(group_id,),
)]
def get_user_personal_bounties(user_id: int) -> list[dict]:
"""Bounties created by user in DM (group_id IS NULL)."""
with get_conn() as conn:
return [_row_to_dict(r) for r in conn.execute(
"SELECT * FROM bounties WHERE group_id IS NULL AND created_by_user_id = ? ORDER BY created_at DESC",
(user_id,),
)]
def update_bounty(
bounty_id: int,
text: str | None,
link: str | None,
due_date_ts: int | None,
) -> bool:
"""Update bounty fields. Returns True if updated. Raises ValueError on duplicate link."""
with get_conn() as conn:
try:
cur = conn.execute(
"""UPDATE bounties
SET text = COALESCE(?, text),
link = COALESCE(?, link),
due_date_ts = COALESCE(?, due_date_ts)
WHERE id = ?""",
(text, link, due_date_ts, bounty_id),
)
return cur.rowcount > 0
except sqlite3.IntegrityError as e:
if "UNIQUE" in str(e) and "link" in str(e):
raise ValueError(f"Link already exists in this group: {link}")
raise
def delete_bounty(bounty_id: int) -> bool:
with get_conn() as conn:
cur = conn.execute("DELETE FROM bounties WHERE id = ?", (bounty_id,))
return cur.rowcount > 0
# ── Tracking ────────────────────────────────────────────────────────────────
def track_bounty(user_id: int, bounty_id: int) -> bool:
"""Add bounty to user's tracking. Returns True if newly tracked, False if already tracking."""
with get_conn() as conn:
try:
conn.execute(
"INSERT INTO user_bounty_tracking (user_id, bounty_id) VALUES (?, ?)",
(user_id, bounty_id),
)
return True
except sqlite3.IntegrityError:
return False
def untrack_bounty(user_id: int, bounty_id: int) -> bool:
with get_conn() as conn:
cur = conn.execute(
"DELETE FROM user_bounty_tracking WHERE user_id = ? AND bounty_id = ?",
(user_id, bounty_id),
)
return cur.rowcount > 0
def is_tracking(user_id: int, bounty_id: int) -> bool:
with get_conn() as conn:
row = conn.execute(
"SELECT 1 FROM user_bounty_tracking WHERE user_id = ? AND bounty_id = ?",
(user_id, bounty_id),
).fetchone()
return row is not None
def get_user_tracked_bounties_in_group(user_id: int, group_id: int) -> list[dict]:
with get_conn() as conn:
return [_row_to_dict(r) for r in conn.execute(
"""SELECT b.* FROM bounties b
JOIN user_bounty_tracking t ON t.bounty_id = b.id
WHERE t.user_id = ? AND b.group_id = ?
ORDER BY b.created_at DESC""",
(user_id, group_id),
)]
def get_user_tracked_bounties_personal(user_id: int) -> list[dict]:
"""Tracked bounties where group_id IS NULL (personal)."""
with get_conn() as conn:
return [_row_to_dict(r) for r in conn.execute(
"""SELECT b.* FROM bounties b
JOIN user_bounty_tracking t ON t.bounty_id = b.id
WHERE t.user_id = ? AND b.group_id IS NULL
ORDER BY b.created_at DESC""",
(user_id,),
)]
# ── Reminders ───────────────────────────────────────────────────────────────
def get_bounties_due_soon(user_id: int, days: int = 7) -> list[dict]:
"""Get tracked bounties with due_date within `days` that haven't been reminded yet."""
now = int(time.time())
deadline = now + days * 86400
with get_conn() as conn:
return [_row_to_dict(r) for r in conn.execute(
"""SELECT b.*, u.username, u.telegram_user_id FROM bounties b
JOIN user_bounty_tracking t ON t.bounty_id = b.id
JOIN users u ON u.id = b.created_by_user_id
WHERE t.user_id = ?
AND b.due_date_ts IS NOT NULL
AND b.due_date_ts <= ?
AND b.due_date_ts >= ?
AND b.id NOT IN (
SELECT bounty_id FROM reminder_log WHERE user_id = ?
)
ORDER BY b.due_date_ts ASC""",
(user_id, deadline, now, user_id),
)]
def log_reminder(user_id: int, bounty_id: int) -> None:
with get_conn() as conn:
conn.execute(
"INSERT OR IGNORE INTO reminder_log (user_id, bounty_id) VALUES (?, ?)",
(user_id, bounty_id),
)
def get_all_user_ids() -> list[int]:
with get_conn() as conn:
return [row["telegram_user_id"] for row in conn.execute("SELECT telegram_user_id FROM users")]

49
apps/telegram-bot/schema.sql
View File

@@ -1,49 +0,0 @@
-- JIGAIDO Database Schema
CREATE TABLE IF NOT EXISTS groups (
id INTEGER PRIMARY KEY AUTOINCREMENT,
telegram_chat_id INTEGER UNIQUE NOT NULL,
creator_user_id INTEGER NOT NULL,
created_at INTEGER NOT NULL DEFAULT (unixepoch())
);
CREATE TABLE IF NOT EXISTS group_admins (
group_id INTEGER REFERENCES groups(id) ON DELETE CASCADE,
user_id INTEGER NOT NULL,
PRIMARY KEY (group_id, user_id)
);
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
telegram_user_id INTEGER UNIQUE NOT NULL,
username TEXT,
created_at INTEGER NOT NULL DEFAULT (unixepoch())
);
CREATE TABLE IF NOT EXISTS bounties (
id INTEGER PRIMARY KEY AUTOINCREMENT,
group_id INTEGER REFERENCES groups(id) ON DELETE CASCADE,
created_by_user_id INTEGER REFERENCES users(id),
informed_by_username TEXT NOT NULL,
text TEXT,
link TEXT,
due_date_ts INTEGER,
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
UNIQUE(group_id, link)
);
CREATE TABLE IF NOT EXISTS user_bounty_tracking (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
bounty_id INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
added_at INTEGER NOT NULL DEFAULT (unixepoch()),
UNIQUE(user_id, bounty_id)
);
CREATE TABLE IF NOT EXISTS reminder_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
bounty_id INTEGER NOT NULL REFERENCES bounties(id) ON DELETE CASCADE,
reminded_at INTEGER NOT NULL DEFAULT (unixepoch()),
UNIQUE(user_id, bounty_id)
);

49
apps/telegram-bot/storage.py Normal file
View File

@@ -0,0 +1,49 @@
"""Per-user JSON file storage for JIGAIDO."""
import json
import tempfile
import os
from pathlib import Path
from typing import Optional
DATA_DIR = Path(__file__).parent / "data"
USERS_DIR = DATA_DIR / "users"
def _ensure_dirs() -> None:
USERS_DIR.mkdir(parents=True, exist_ok=True)
def _user_file_path(telegram_user_id: int) -> Path:
return USERS_DIR / f"{telegram_user_id}.json"
def load_user(telegram_user_id: int) -> dict:
"""Load user data from JSON file. Returns empty user structure if not found."""
_ensure_dirs()
path = _user_file_path(telegram_user_id)
if not path.exists():
return {
"user_id": telegram_user_id,
"username": None,
"personal_bounties": [],
"tracked_bounties": [],
}
with open(path) as f:
return json.load(f)
def save_user(user_data: dict) -> None:
"""Atomically save user data to JSON file."""
_ensure_dirs()
path = _user_file_path(user_data["user_id"])
with tempfile.NamedTemporaryFile(mode="w", dir=USERS_DIR, delete=False) as tmp:
json.dump(user_data, tmp, indent=2)
tmp_path = tmp.name
os.rename(tmp_path, path)
def next_bounty_id(user_data: dict) -> int:
"""Get next sequential bounty ID for user's file."""
existing_ids = [b["id"] for b in user_data.get("personal_bounties", [])]
return (max(existing_ids) + 1) if existing_ids else 1

298
apps/telegram-bot/tests/test_db.py
View File

@@ -1,298 +0,0 @@
"""Tests for db.py"""
import time
import pytest
import db as _db
class TestUsers:
def test_upsert_user_creates_new(self):
uid = _db.upsert_user(123, "alice")
assert uid > 0
row = _db.get_user_by_telegram_id(123)
assert row is not None
assert row["telegram_user_id"] == 123
assert row["username"] == "alice"
def test_upsert_user_updates_username(self):
# Two upserts to the same telegram_user_id: second one updates the username.
# Returns the same id both times (idempotent).
uid1 = _db.upsert_user(123, "alice")
uid2 = _db.upsert_user(123, "alice_updated")
assert uid1 == uid2
row = _db.get_user_by_telegram_id(123)
assert row["username"] == "alice_updated"
def test_get_user_by_telegram_id_not_found(self):
row = _db.get_user_by_telegram_id(999999)
assert row is None
class TestGroups:
def test_upsert_group_creates_new(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
assert gid > 0
row = _db.get_group(-100123)
assert row is not None
assert row["telegram_chat_id"] == -100123
assert row["creator_user_id"] == uid
def test_upsert_group_idempotent(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid1 = _db.upsert_group(-100123, uid)
gid2 = _db.upsert_group(-100123, uid)
assert gid1 == gid2
def test_get_group_creator_user_id(self, fresh_db):
uid = _db.upsert_user(1, "creator")
_db.upsert_group(-100123, uid)
assert _db.get_group_creator_user_id(_db.get_group(-100123)["id"]) == uid
def test_get_group_not_found(self, fresh_db):
row = _db.get_group(-999999)
assert row is None
class TestGroupAdmins:
def test_add_remove_is_admin(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
assert not _db.is_group_admin(gid, uid)
added = _db.add_group_admin(gid, uid)
assert added is True
assert _db.is_group_admin(gid, uid) is True
# Adding again returns False (already admin)
assert _db.add_group_admin(gid, uid) is False
removed = _db.remove_group_admin(gid, uid)
assert removed is True
assert _db.is_group_admin(gid, uid) is False
def test_remove_nonexistent_admin_returns_false(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
assert _db.remove_group_admin(gid, uid) is False
def test_is_group_creator(self, fresh_db):
uid = _db.upsert_user(1, "creator")
other = _db.upsert_user(2, "other")
gid = _db.upsert_group(-100123, uid)
_db.add_group_admin(gid, uid)
assert _db.is_group_creator(gid, uid) is True
assert _db.is_group_creator(gid, other) is False
def test_get_user_by_username(self, fresh_db):
uid = _db.upsert_user(1, "alice")
row = _db.get_user_by_username("alice")
assert row is not None
assert row["id"] == uid
assert _db.get_user_by_username("nobody") is None
class TestBounties:
def test_add_bounty_group(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
_db.add_group_admin(gid, uid)
bid = _db.add_bounty(
group_id=gid,
created_by_user_id=uid,
informed_by_username="bob",
text="Fix bug",
link="https://github.com/bob/repo",
due_date_ts=int(time.time()) + 86400,
)
assert bid > 0
bounty = _db.get_bounty(bid)
assert bounty["text"] == "Fix bug"
assert bounty["link"] == "https://github.com/bob/repo"
assert bounty["informed_by_username"] == "bob"
assert bounty["group_id"] == gid
def test_add_bounty_personal(self, fresh_db):
uid = _db.upsert_user(1, "alice")
bid = _db.add_bounty(
group_id=None,
created_by_user_id=uid,
informed_by_username="alice",
text="Personal reminder",
link=None,
due_date_ts=None,
)
assert bid > 0
bounty = _db.get_bounty(bid)
assert bounty["group_id"] is None
assert bounty["text"] == "Personal reminder"
def test_add_bounty_duplicate_link_rejected(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
_db.add_bounty(gid, uid, "user1", "text1", "https://example.com", None)
with pytest.raises(ValueError, match="Link already exists"):
_db.add_bounty(gid, uid, "user2", "text2", "https://example.com", None)
def test_add_bounty_null_link_allows_multiples(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
bid1 = _db.add_bounty(gid, uid, "user1", "text only 1", None, None)
bid2 = _db.add_bounty(gid, uid, "user2", "text only 2", None, None)
assert bid1 != bid2
def test_get_group_bounties(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
_db.add_group_admin(gid, uid)
_db.add_bounty(gid, uid, "user", "bounty1", None, None)
_db.add_bounty(gid, uid, "user", "bounty2", None, None)
bounties = _db.get_group_bounties(gid)
assert len(bounties) == 2
def test_get_user_personal_bounties(self, fresh_db):
uid = _db.upsert_user(1, "alice")
_db.add_bounty(None, uid, "alice", "personal1", None, None)
_db.add_bounty(None, uid, "alice", "personal2", None, None)
# Group bounty should not appear
other = _db.upsert_user(2, "bob")
gid = _db.upsert_group(-100, other)
_db.add_bounty(gid, other, "bob", "group bounty", None, None)
personal = _db.get_user_personal_bounties(uid)
assert len(personal) == 2
def test_update_bounty(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
bid = _db.add_bounty(gid, uid, "user", "old text", None, None)
_db.update_bounty(bid, "new text", None, None)
updated = _db.get_bounty(bid)
assert updated["text"] == "new text"
def test_update_bounty_duplicate_link_rejected(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
_db.add_bounty(gid, uid, "user1", "bounty1", "https://a.com", None)
bid2 = _db.add_bounty(gid, uid, "user2", "bounty2", None, None)
with pytest.raises(ValueError, match="Link already exists"):
_db.update_bounty(bid2, None, "https://a.com", None)
def test_delete_bounty(self, fresh_db):
uid = _db.upsert_user(1, "creator")
gid = _db.upsert_group(-100123, uid)
bid = _db.add_bounty(gid, uid, "user", "to delete", None, None)
assert _db.delete_bounty(bid) is True
assert _db.get_bounty(bid) is None
# Deleting again returns False
assert _db.delete_bounty(bid) is False
class TestTracking:
def test_track_untrack_is_tracking(self, fresh_db):
uid = _db.upsert_user(1, "alice")
uid2 = _db.upsert_user(2, "bob")
gid = _db.upsert_group(-100123, uid)
bid = _db.add_bounty(gid, uid, "alice", "task", None, None)
assert _db.track_bounty(uid, bid) is True
assert _db.is_tracking(uid, bid) is True
# Track again → False (already tracking)
assert _db.track_bounty(uid, bid) is False
# Other user tracking same bounty
assert _db.track_bounty(uid2, bid) is True
assert _db.is_tracking(uid2, bid) is True
# Untrack
assert _db.untrack_bounty(uid, bid) is True
assert _db.is_tracking(uid, bid) is False
assert _db.is_tracking(uid2, bid) is True # other user still tracking
# Untrack again → False
assert _db.untrack_bounty(uid, bid) is False
def test_get_user_tracked_bounties_in_group(self, fresh_db):
uid = _db.upsert_user(1, "alice")
gid = _db.upsert_group(-100123, uid)
bid1 = _db.add_bounty(gid, uid, "alice", "task1", None, None)
bid2 = _db.add_bounty(gid, uid, "alice", "task2", None, None)
# Different group bounty
other_gid = _db.upsert_group(-100124, uid)
bid3 = _db.add_bounty(other_gid, uid, "alice", "other group task", None, None)
_db.track_bounty(uid, bid1)
_db.track_bounty(uid, bid3)
tracked = _db.get_user_tracked_bounties_in_group(uid, gid)
assert len(tracked) == 1
assert tracked[0]["id"] == bid1
def test_get_user_tracked_bounties_personal(self, fresh_db):
uid = _db.upsert_user(1, "alice")
bid1 = _db.add_bounty(None, uid, "alice", "personal1", None, None)
bid2 = _db.add_bounty(None, uid, "alice", "personal2", None, None)
gid = _db.upsert_group(-100123, uid)
bid3 = _db.add_bounty(gid, uid, "alice", "group task", None, None)
_db.track_bounty(uid, bid1)
_db.track_bounty(uid, bid3)
tracked = _db.get_user_tracked_bounties_personal(uid)
assert len(tracked) == 1
assert tracked[0]["id"] == bid1
class TestReminders:
def test_get_bounties_due_soon(self, fresh_db):
uid = _db.upsert_user(1, "alice")
gid = _db.upsert_group(-100123, uid)
now = int(time.time())
# Due in 3 days (< 7 days)
bid_soon = _db.add_bounty(gid, uid, "alice", "soon", None, now + 3 * 86400)
# Due in 10 days (> 7 days)
_db.add_bounty(gid, uid, "alice", "later", None, now + 10 * 86400)
# No due date
bid_no_date = _db.add_bounty(gid, uid, "alice", "no date", None, None)
_db.track_bounty(uid, bid_soon)
_db.track_bounty(uid, bid_no_date)
due = _db.get_bounties_due_soon(uid, days=7)
assert len(due) == 1
assert due[0]["id"] == bid_soon
def test_reminder_log_prevents_duplicate_reminders(self, fresh_db):
uid = _db.upsert_user(1, "alice")
gid = _db.upsert_group(-100123, uid)
now = int(time.time())
bid = _db.add_bounty(gid, uid, "alice", "task", None, now + 2 * 86400)
_db.track_bounty(uid, bid)
due1 = _db.get_bounties_due_soon(uid, days=7)
assert len(due1) == 1
# Log that we reminded
_db.log_reminder(uid, bid)
# Should not appear again
due2 = _db.get_bounties_due_soon(uid, days=7)
assert len(due2) == 0
def test_get_all_user_ids(self, fresh_db):
_db.upsert_user(1, "alice")
_db.upsert_user(2, "bob")
ids = _db.get_all_user_ids()
assert sorted(ids) == [1, 2]