180 lines
9.6 KiB
Python
180 lines
9.6 KiB
Python
from discord.ext import commands
|
|
import discord
|
|
import logging
|
|
import asyncio
|
|
import hashlib
|
|
from datetime import datetime
|
|
|
|
import util
|
|
import eventbus
|
|
|
|
# Generate a "phone" address
|
|
# Not actually for phones
|
|
def generate_address(ctx):
|
|
h = hashlib.blake2b(str(ctx.guild.id).encode("utf-8")).digest()
|
|
words = open("wordlist-8192.txt").readlines()
|
|
out = ""
|
|
for i in range(3):
|
|
out += words[int.from_bytes(h[i * 2:i * 2 + 3], "little") % 8192].strip().title()
|
|
return out
|
|
|
|
def setup(bot):
|
|
@bot.group(name="apiotelephone", aliases=["tel", "tele", "telephone", "apiotel"], brief="ApioTelephone lets you 'call' other servers.", help=f"""
|
|
Call other (participating) servers with ApioTelephone! To configure a channel for telephony, do `{bot.command_prefix}tel setup` (requires Manage Channels).
|
|
It's recommended that you give the bot Manage Webhooks permissions in this channel so that it can use webhook calls mode.
|
|
To place a call, do `{bot.command_prefix}tel dial [number]` - the other end has to accept the call.
|
|
When you want to end a call, do {bot.command_prefix}tel disconnect.
|
|
""")
|
|
async def telephone(ctx): pass
|
|
|
|
async def get_channel_config(channel):
|
|
return await bot.database.execute_fetchone("SELECT * FROM telephone_config WHERE channel_id = ?", (channel,))
|
|
|
|
async def get_addr_config(addr):
|
|
return await bot.database.execute_fetchone("SELECT * FROM telephone_config WHERE id = ?", (addr,))
|
|
|
|
@telephone.command(brief="Link to other channels", help="""Connect to another channel on Discord or any supported bridges.
|
|
Virtual channels also exist.
|
|
""")
|
|
@commands.check(util.admin_check)
|
|
async def link(ctx, target_type, target_id):
|
|
try:
|
|
target_id = int(target_id)
|
|
except ValueError: pass
|
|
await eventbus.add_bridge_link(bot.database, ("discord", ctx.channel.id), (target_type, util.extract_codeblock(target_id)))
|
|
await ctx.send(f"Link established.")
|
|
pass
|
|
|
|
@telephone.command(brief="Undo link commands.")
|
|
@commands.check(util.admin_check)
|
|
async def unlink(ctx, target_type, target_id):
|
|
try:
|
|
target_id = int(target_id)
|
|
except ValueError: pass
|
|
await eventbus.remove_bridge_link(bot.database, ("discord", ctx.channel.id), (target_type, util.extract_codeblock(target_id)))
|
|
await ctx.send(f"Successfully deleted.")
|
|
pass
|
|
|
|
@telephone.command(brief="Generate a webhook")
|
|
@commands.check(util.admin_check)
|
|
async def init_webhook(ctx):
|
|
webhook = (await ctx.channel.create_webhook(name="ABR webhook", reason=f"requested by {ctx.author.name}")).url
|
|
await bot.database.execute("INSERT OR REPLACE INTO discord_webhooks VALUES (?, ?)", (ctx.channel.id, webhook))
|
|
await bot.database.commit()
|
|
await ctx.send("Done.")
|
|
|
|
@telephone.command()
|
|
@commands.check(util.server_mod_check)
|
|
async def setup(ctx):
|
|
num = generate_address(ctx)
|
|
await ctx.send(f"Your address is {num}.")
|
|
info = await get_addr_config(num)
|
|
webhook = None
|
|
if info: webhook = info["webhook"]
|
|
if not info or not webhook:
|
|
try:
|
|
webhook = (await ctx.channel.create_webhook(name="incoming message display", reason="configure for apiotelephone")).url
|
|
await bot.database.execute("INSERT OR REPLACE INTO discord_webhooks VALUES (?, ?)", (ctx.channel.id, webhook))
|
|
await ctx.send("Created webhook.")
|
|
except discord.Forbidden as f:
|
|
logging.warn("could not create webhook in #%s %s", ctx.channel.name, ctx.guild.name, exc_info=f)
|
|
await ctx.send("Webhook creation failed - please ensure permissions are available. This is not necessary but is recommended.")
|
|
await bot.database.execute("INSERT OR REPLACE INTO telephone_config VALUES (?, ?, ?, ?)", (num, ctx.guild.id, ctx.channel.id, webhook))
|
|
await bot.database.commit()
|
|
await ctx.send("Configured.")
|
|
|
|
@telephone.command(aliases=["call"], brief="Dial another telephone channel.")
|
|
async def dial(ctx, address):
|
|
# basic checks - ensure this is a phone channel and has no other open calls
|
|
channel_info = await get_channel_config(ctx.channel.id)
|
|
if not channel_info: return await ctx.send(embed=util.error_embed("Not in a phone channel."))
|
|
originating_address = channel_info["id"]
|
|
if address == originating_address: return await ctx.send(embed=util.error_embed("A channel cannot dial itself. That means *you*, Gibson."))
|
|
recv_info = await get_addr_config(address)
|
|
if not recv_info: return await ctx.send(embed=util.error_embed("Destination address not found. Please check for typos and/or antimemes."))
|
|
|
|
current_call = await bot.database.execute_fetchone("SELECT * FROM calls WHERE from_id = ?", (originating_address,))
|
|
if current_call: return await ctx.send(embed=util.error_embed(f"A call is already open (to {current_call['to_id']}) from this channel. Currently, only one outgoing call is permitted at a time."))
|
|
|
|
# post embed in the receiving channel prompting people to accept/decline call
|
|
recv_channel = bot.get_channel(recv_info["channel_id"])
|
|
_, call_message = await asyncio.gather(
|
|
ctx.send(embed=util.info_embed("Outgoing call", f"Dialing {address}...")),
|
|
recv_channel.send(embed=util.info_embed("Incoming call",
|
|
f"Call from {originating_address}. Click :white_check_mark: to accept or :negative_squared_cross_mark: to decline."))
|
|
)
|
|
# add clickable reactions to it
|
|
await asyncio.gather(
|
|
call_message.add_reaction("✅"),
|
|
call_message.add_reaction("❎")
|
|
)
|
|
|
|
def check(re, u): return (str(re.emoji) == "✅" or str(re.emoji) == "❎") and u != bot.user
|
|
|
|
reaction = None
|
|
# wait until someone clicks the reactions, or time out and say so
|
|
try:
|
|
reaction, user = await bot.wait_for("reaction_add", timeout=util.config["call_timeout"], check=check)
|
|
except asyncio.TimeoutError:
|
|
await asyncio.gather(
|
|
ctx.send(embed=util.error_embed("Timed out", "Outgoing call timed out - the other end did not pick up.")),
|
|
recv_channel.send(embed=util.error_embed("Timed out", "Call timed out - no response in time"))
|
|
)
|
|
|
|
await asyncio.gather(call_message.remove_reaction("✅", bot.user), call_message.remove_reaction("❎", bot.user))
|
|
em = str(reaction.emoji) if reaction else "❎"
|
|
if em == "✅": # accept call
|
|
await bot.database.execute("INSERT INTO calls VALUES (?, ?, ?)", (originating_address, address, util.timestamp()))
|
|
await bot.database.commit()
|
|
await eventbus.add_bridge_link(bot.database, ("discord", ctx.channel.id), ("discord", recv_channel.id))
|
|
await asyncio.gather(
|
|
ctx.send(embed=util.info_embed("Outgoing call", "Call accepted and connected.")),
|
|
recv_channel.send(embed=util.info_embed("Incoming call", "Call accepted and connected."))
|
|
)
|
|
elif em == "❎": # drop call
|
|
await ctx.send(embed=util.error_embed("Your call was declined.", "Call declined"))
|
|
|
|
@telephone.command(aliases=["disconnect", "quit"], brief="Disconnect latest call.")
|
|
async def hangup(ctx):
|
|
channel_info = await get_channel_config(ctx.channel.id)
|
|
addr = channel_info["id"]
|
|
if not channel_info: return await ctx.send(embed=util.error_embed("Not in a phone channel."))
|
|
from_here = await bot.database.execute_fetchone("SELECT * FROM calls WHERE from_id = ?", (addr,))
|
|
to_here = await bot.database.execute_fetchone("SELECT * FROM calls WHERE to_id = ?", (addr,))
|
|
if (not to_here) and (not from_here): return await ctx.send(embed=util.error_embed("No calls are active."))
|
|
|
|
other = None
|
|
if from_here:
|
|
other = from_here["to_id"]
|
|
await bot.database.execute("DELETE FROM calls WHERE from_id = ? AND to_id = ?", (addr, other))
|
|
elif to_here:
|
|
other = to_here["from_id"]
|
|
await bot.database.execute("DELETE FROM calls WHERE to_id = ? AND from_id = ?", (addr, other))
|
|
await bot.database.commit()
|
|
other_channel = (await get_addr_config(other))["channel_id"]
|
|
await eventbus.remove_bridge_link(bot.database, ("discord", other_channel), ("discord", ctx.channel.id))
|
|
|
|
await asyncio.gather(
|
|
ctx.send(embed=util.info_embed("Hung up", f"Call to {other} disconnected.")),
|
|
bot.get_channel(other_channel).send(embed=util.info_embed("Hung up", f"Call to {addr} disconnected."))
|
|
)
|
|
|
|
@telephone.command(aliases=["status"], brief="List inbound/outbound calls.")
|
|
async def info(ctx):
|
|
channel_info = await get_channel_config(ctx.channel.id)
|
|
if not channel_info: return await ctx.send(embed=util.info_embed("Phone status", "Not a phone channel"))
|
|
addr = channel_info['id']
|
|
title = f"{addr} status"
|
|
|
|
fields = []
|
|
|
|
now = datetime.utcnow()
|
|
def delta(ts):
|
|
return util.format_timedelta(datetime.utcfromtimestamp(ts), now)
|
|
|
|
incoming = await bot.database.execute_fetchall("SELECT * FROM calls WHERE to_id = ?", (addr,))
|
|
fields.extend(map(lambda x: ["Incoming call", f"From {x['from_id']} - for {delta(x['start_time'])}"], incoming))
|
|
outgoing = await bot.database.execute_fetchall("SELECT * FROM calls WHERE from_id = ?", (addr,))
|
|
fields.extend(map(lambda x: ["Outgoing call", f"To {x['to_id']} - for {delta(x['start_time'])}"], outgoing))
|
|
await ctx.send(embed=util.info_embed(title, f"Connected: {len(incoming) + len(outgoing)}", fields))
|