226 lines
9.9 KiB
Python
226 lines
9.9 KiB
Python
#!/usr/bin/env python3
|
|
import os
|
|
import asyncio
|
|
import json
|
|
import io
|
|
import requests
|
|
import logging
|
|
from datetime import datetime
|
|
from dateutil.relativedelta import relativedelta
|
|
import qrcode
|
|
|
|
import discord
|
|
from discord import File, Embed
|
|
from discord.ext import commands
|
|
|
|
import websockets
|
|
|
|
from sqlalchemy import (
|
|
create_engine, Column, String, Integer, DateTime, Text, Enum, ForeignKey
|
|
)
|
|
from sqlalchemy.dialects.postgresql import JSONB
|
|
from sqlalchemy.ext.declarative import declarative_base
|
|
from sqlalchemy.orm import sessionmaker, relationship
|
|
|
|
from apscheduler.schedulers.asyncio import AsyncIOScheduler
|
|
|
|
# ─── Logging ──────────────────────────────────────────────────────────────
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s | %(message)s")
|
|
logger = logging.getLogger("discord_lnbits_bot")
|
|
|
|
# ─── Database & Config Seeding ────────────────────────────────────────────
|
|
DATABASE_URL = os.environ["DATABASE_URL"]
|
|
engine = create_engine(DATABASE_URL, future=True)
|
|
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
|
|
Base = declarative_base()
|
|
|
|
class Config(Base):
|
|
__tablename__ = "config"
|
|
key = Column(String, primary_key=True)
|
|
value = Column(Text, nullable=False)
|
|
|
|
class Plan(Base):
|
|
__tablename__ = "plans"
|
|
id = Column(Integer, primary_key=True)
|
|
name = Column(Text, nullable=False, unique=True)
|
|
command_name = Column(Text, nullable=False, unique=True)
|
|
role_id = Column(String(64), nullable=False)
|
|
channel_id = Column(String(64), nullable=False)
|
|
price_sats = Column(Integer, nullable=False)
|
|
invoice_message = Column(Text, nullable=False)
|
|
expiry_type = Column(Enum("fixed_date","rolling_days","calendar_month", name="expiry_type"), nullable=False)
|
|
duration_days = Column(Integer, default=30)
|
|
subs = relationship("Subscription", back_populates="plan")
|
|
|
|
class Subscription(Base):
|
|
__tablename__ = "subscriptions"
|
|
id = Column(Integer, primary_key=True)
|
|
plan_id = Column(Integer, ForeignKey("plans.id"), nullable=False)
|
|
user_id = Column(String(64), nullable=False)
|
|
invoice_hash = Column(String(256), unique=True, nullable=False)
|
|
invoice_request = Column(Text, nullable=False)
|
|
status = Column(Enum("pending","active","expired","cancelled", name="sub_status"), nullable=False, default="pending")
|
|
created_at = Column(DateTime, default=datetime.utcnow)
|
|
paid_at = Column(DateTime)
|
|
expires_at = Column(DateTime)
|
|
role_assigned_at = Column(DateTime)
|
|
role_removed_at = Column(DateTime)
|
|
raw_invoice_json = Column(JSONB)
|
|
raw_payment_json = Column(JSONB)
|
|
plan = relationship("Plan", back_populates="subs")
|
|
|
|
Base.metadata.create_all(engine)
|
|
logger.info("✅ Database schema ready.")
|
|
|
|
# Seed Config keys (if missing)
|
|
session = SessionLocal()
|
|
for key in ("discord_token", "guild_id", "lnbits_url", "lnbits_api_key"):
|
|
if not session.get(Config, key):
|
|
session.add(Config(key=key, value=""))
|
|
session.commit()
|
|
session.close()
|
|
|
|
# ─── Config helper ─────────────────────────────────────────────────────────
|
|
def get_cfg(k: str) -> str:
|
|
db = SessionLocal()
|
|
row = db.get(Config, k)
|
|
db.close()
|
|
return row.value if row else ""
|
|
|
|
DISCORD_TOKEN = get_cfg("discord_token")
|
|
GUILD_ID = int(get_cfg("guild_id") or 0)
|
|
LNBITS_URL = get_cfg("lnbits_url")
|
|
LNBITS_API_KEY = get_cfg("lnbits_api_key")
|
|
|
|
for name, val in (("discord_token", DISCORD_TOKEN), ("guild_id", GUILD_ID),
|
|
("lnbits_url", LNBITS_URL), ("lnbits_api_key", LNBITS_API_KEY)):
|
|
if not val:
|
|
logger.critical(f"Config '{name}' is empty in DB. Fill via UI first.")
|
|
exit(1)
|
|
|
|
# Build WS URL
|
|
if LNBITS_URL.startswith("https://"):
|
|
ws_base = LNBITS_URL.replace("https://", "wss://", 1)
|
|
elif LNBITS_URL.startswith("http://"):
|
|
ws_base = LNBITS_URL.replace("http://", "ws://", 1)
|
|
else:
|
|
logger.critical("LNBITS_URL must start with http:// or https://")
|
|
exit(1)
|
|
LNBITS_WS_URL = f"{ws_base}/api/v1/ws/{LNBITS_API_KEY}"
|
|
|
|
# ─── Discord Bot ──────────────────────────────────────────────────────────
|
|
intents = discord.Intents.default(); intents.members = True
|
|
bot = commands.Bot(command_prefix="!", intents=intents)
|
|
|
|
def compute_expiry(paid_at: datetime, plan: Plan) -> datetime:
|
|
if plan.expiry_type == "calendar_month":
|
|
first = paid_at.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
|
|
return first + relativedelta(months=1)
|
|
if plan.expiry_type == "rolling_days":
|
|
return paid_at + relativedelta(days=plan.duration_days)
|
|
return paid_at
|
|
|
|
async def handle_plan_purchase(interaction, plan: Plan):
|
|
invoice_ch = bot.get_channel(int(plan.channel_id))
|
|
if not invoice_ch:
|
|
return await interaction.response.send_message("❌ Invoice channel not found.", ephemeral=True)
|
|
|
|
invoice_data = {"out": False, "amount": plan.price_sats, "memo": plan.invoice_message}
|
|
headers = {"X-Api-Key": LNBITS_API_KEY, "Content-Type": "application/json"}
|
|
loop = asyncio.get_running_loop()
|
|
def create_invoice():
|
|
r = requests.post(f"{LNBITS_URL}/api/v1/payments", json=invoice_data, headers=headers, timeout=10)
|
|
r.raise_for_status()
|
|
return r.json()
|
|
try:
|
|
inv = await loop.run_in_executor(None, create_invoice)
|
|
except Exception:
|
|
logger.exception("Invoice creation failed")
|
|
return await interaction.response.send_message("❌ Could not generate invoice.", ephemeral=True)
|
|
|
|
pay_req, pay_hash = inv["bolt11"], inv["payment_hash"]
|
|
db = SessionLocal()
|
|
sub = Subscription(plan_id=plan.id, user_id=str(interaction.user.id),
|
|
invoice_hash=pay_hash, invoice_request=pay_req,
|
|
raw_invoice_json=inv)
|
|
db.add(sub); db.commit(); db.close()
|
|
|
|
def make_qr_buf():
|
|
buf = io.BytesIO(); qrcode.make(pay_req).save(buf, format="PNG"); buf.seek(0); return buf
|
|
qr_buf = await loop.run_in_executor(None, make_qr_buf)
|
|
qr_file= File(qr_buf, "invoice.png")
|
|
|
|
embed = Embed(title=f"⚡ Pay {plan.price_sats} sats for {plan.name} ⚡",
|
|
description=plan.invoice_message, color=discord.Color.gold())
|
|
embed.add_field(name="Invoice", value=f"```{pay_req}```", inline=False)
|
|
embed.set_image(url="attachment://invoice.png")
|
|
embed.set_footer(text=f"Hash: {pay_hash}")
|
|
|
|
await invoice_ch.send(content=interaction.user.mention, embed=embed, file=qr_file)
|
|
await interaction.response.send_message(f"✅ Invoice posted in {invoice_ch.mention}", ephemeral=True)
|
|
|
|
async def lnbits_ws_listener():
|
|
await bot.wait_until_ready()
|
|
logger.info(f"Listening on WS {LNBITS_WS_URL}")
|
|
while True:
|
|
try:
|
|
async with websockets.connect(LNBITS_WS_URL) as ws:
|
|
async for msg in ws:
|
|
data = json.loads(msg); pay = data.get("payment", {})
|
|
hsh = pay.get("checking_id") or pay.get("payment_hash")
|
|
if not (hsh and pay.get("status")=="success"): continue
|
|
|
|
db = SessionLocal()
|
|
sub= db.query(Subscription).filter_by(invoice_hash=hsh, status="pending").first()
|
|
if not sub: db.close(); continue
|
|
|
|
paid_at= datetime.utcnow()
|
|
expires_at= compute_expiry(paid_at, sub.plan)
|
|
sub.status=sub.paid_at=paid_at; sub.expires_at=expires_at
|
|
sub.raw_payment_json=pay; db.commit(); db.close()
|
|
|
|
guild = bot.get_guild(GUILD_ID)
|
|
member = guild.get_member(int(sub.user_id)) or await guild.fetch_member(int(sub.user_id))
|
|
role = guild.get_role(int(sub.plan.role_id))
|
|
chan = bot.get_channel(int(sub.plan.channel_id))
|
|
|
|
await member.add_roles(role, reason="Subscription paid")
|
|
await chan.send(f"🎉 {member.mention} paid **{sub.plan.price_sats} sats** "
|
|
f"for **{sub.plan.name}**, expires {expires_at:%Y-%m-%d}.")
|
|
except Exception:
|
|
logger.exception("WS error, reconnecting in 10s"); await asyncio.sleep(10)
|
|
|
|
async def cleanup_expired():
|
|
now= datetime.utcnow(); db= SessionLocal()
|
|
rows= db.query(Subscription).filter(Subscription.status=="active", Subscription.expires_at<=now).all()
|
|
for sub in rows:
|
|
guild = bot.get_guild(GUILD_ID)
|
|
member = guild.get_member(int(sub.user_id))
|
|
role = guild.get_role(int(sub.plan.role_id))
|
|
if member and role in member.roles:
|
|
try:
|
|
await member.remove_roles(role, reason="Subscription expired")
|
|
sub.status="expired"; sub.role_removed_at=now; db.commit()
|
|
logger.info(f"Removed expired role from {member.display_name}")
|
|
except Exception:
|
|
logger.exception("Failed to remove expired role")
|
|
db.close()
|
|
|
|
@bot.event
|
|
async def on_ready():
|
|
logger.info(f"Logged in as {bot.user}")
|
|
db = SessionLocal(); plans = db.query(Plan).all()
|
|
for plan in plans:
|
|
@bot.tree.command(name=plan.command_name, description=f"Buy {plan.name}")
|
|
async def _cmd(interaction, plan=plan):
|
|
await handle_plan_purchase(interaction, plan)
|
|
db.close()
|
|
await bot.tree.sync()
|
|
bot.loop.create_task(lnbits_ws_listener())
|
|
sched= AsyncIOScheduler(timezone="UTC")
|
|
sched.add_job(cleanup_expired, "cron", hour=0, minute=0)
|
|
sched.start()
|
|
|
|
if __name__=="__main__":
|
|
bot.run(DISCORD_TOKEN)
|