310 lines
7.8 KiB
Python
310 lines
7.8 KiB
Python
import discord
|
|
import json
|
|
import logging
|
|
import nio
|
|
import os
|
|
|
|
|
|
def config_gen(config_file):
|
|
config_dict = {
|
|
"homeserver": "https://matrix.org",
|
|
"room_id": "room:matrix.org",
|
|
"username": "@name:matrix.org",
|
|
"password": "my-secret-password",
|
|
"channel_id": "channel",
|
|
"token": "my-secret-token"
|
|
}
|
|
|
|
if not os.path.exists(config_file):
|
|
with open(config_file, "w") as f:
|
|
json.dump(config_dict, f, indent=4)
|
|
print(f"Example configuration dumped to {config_file}")
|
|
exit()
|
|
|
|
with open(config_file, "r") as f:
|
|
config = json.loads(f.read())
|
|
|
|
return config
|
|
|
|
|
|
config = config_gen("config.json")
|
|
|
|
intents = discord.Intents.default()
|
|
intents.members = True
|
|
discord_client = discord.Client(intents=intents)
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
message_cache = {}
|
|
|
|
|
|
@discord_client.event
|
|
async def on_ready():
|
|
print(f"Logged in as {discord_client.user}")
|
|
|
|
# Start Matrix bot
|
|
await create_matrix_client()
|
|
|
|
|
|
@discord_client.event
|
|
async def on_message(message):
|
|
if message.author.bot or str(message.channel.id) != config["channel_id"]:
|
|
return
|
|
|
|
content = await process_discord(message)
|
|
|
|
matrix_message = await message_send(content)
|
|
message_cache[message.id] = matrix_message
|
|
|
|
|
|
@discord_client.event
|
|
async def on_message_edit(before, after):
|
|
if after.author.bot or str(after.channel.id) != config["channel_id"]:
|
|
return
|
|
|
|
content = await process_discord(after) + " (edited)"
|
|
|
|
await message_redact(message_cache[before.id], "Message edited")
|
|
|
|
matrix_message = await message_send(content)
|
|
message_cache[after.id] = matrix_message
|
|
|
|
|
|
@discord_client.event
|
|
async def on_message_delete(message):
|
|
if message.id in message_cache:
|
|
await message_redact(message_cache[message.id], "Message deleted")
|
|
|
|
|
|
@discord_client.event
|
|
async def on_typing(channel, user, when):
|
|
if user.bot or str(channel.id) != config["channel_id"]:
|
|
return
|
|
|
|
# Send typing event
|
|
await matrix_client.room_typing(config["room_id"], timeout=0)
|
|
|
|
|
|
async def get_channel():
|
|
channel = int(config["channel_id"])
|
|
channel = discord_client.get_channel(channel)
|
|
|
|
return channel
|
|
|
|
|
|
async def process_discord(message):
|
|
content = message.content
|
|
|
|
emote_list = await process_split(content, "<:", ">")
|
|
mention_list = await process_split(content, "<@", ">")
|
|
|
|
for emote in emote_list:
|
|
emote_name = emote.split(":")[1]
|
|
content = content.replace(emote, f":{emote_name}:")
|
|
|
|
for mention in mention_list:
|
|
# Discord mentions can start with either "<@" or "<@!"
|
|
try:
|
|
mention_ = int(mention[2:-1])
|
|
except ValueError:
|
|
mention_ = int(mention[3:-1])
|
|
|
|
user = discord_client.get_user(mention_)
|
|
content = content.replace(mention, f"@{user.name}")
|
|
|
|
# Append attachments to message
|
|
for attachment in message.attachments:
|
|
content += f"\n{attachment.url}"
|
|
|
|
content = f"<{message.author.name}> {content}"
|
|
|
|
return content
|
|
|
|
|
|
async def process_matrix(message):
|
|
# Don't mention @everyone or @here
|
|
message = message.replace("@everyone", "@\u200Beveryone")
|
|
message = message.replace("@here", "@\u200Bhere")
|
|
|
|
emote_list = await process_split(message, ":", ":")
|
|
mention_list = await process_split(message, "@", "")
|
|
|
|
for emote in emote_list:
|
|
emote_ = discord.utils.get(discord_client.emojis, name=emote[1:-1])
|
|
|
|
if emote_:
|
|
message = message.replace(emote, str(emote_))
|
|
|
|
channel = await get_channel()
|
|
guild = channel.guild
|
|
|
|
for mention in mention_list:
|
|
for member in await guild.query_members(query=mention[1:]):
|
|
message = message.replace(mention, member.mention)
|
|
|
|
return message
|
|
|
|
|
|
async def process_split(message, start, end):
|
|
return_list = []
|
|
|
|
for item in message.split():
|
|
if item.startswith(start) and item.endswith(end):
|
|
return_list.append(item)
|
|
|
|
return return_list
|
|
|
|
|
|
async def webhook_send(author, avatar, message, event_id):
|
|
channel = await get_channel()
|
|
|
|
# Create webhook if it doesn't exist
|
|
hook_name = "matrix_bridge"
|
|
hooks = await channel.webhooks()
|
|
hook = discord.utils.get(hooks, name=hook_name)
|
|
if hook is None:
|
|
hook = await channel.create_webhook(name=hook_name)
|
|
|
|
# 'wait=True' allows us to store the sent message
|
|
hook = await hook.send(username=author, avatar_url=avatar, content=message,
|
|
wait=True)
|
|
|
|
message_cache[event_id] = hook
|
|
|
|
|
|
async def create_matrix_client():
|
|
homeserver = config["homeserver"]
|
|
username = config["username"]
|
|
password = config["password"]
|
|
|
|
timeout = 30000
|
|
|
|
global matrix_client
|
|
|
|
matrix_client = nio.AsyncClient(homeserver, username)
|
|
print(await matrix_client.login(password))
|
|
|
|
# Sync once before adding callback to avoid acting on old messages
|
|
await matrix_client.sync(timeout)
|
|
|
|
matrix_client.add_event_callback(message_callback, (nio.RoomMessageText,
|
|
nio.RoomMessageMedia))
|
|
|
|
matrix_client.add_event_callback(redaction_callback, nio.RedactionEvent)
|
|
|
|
matrix_client.add_ephemeral_callback(typing_callback, nio.EphemeralEvent)
|
|
|
|
# Sync forever
|
|
await matrix_client.sync_forever(timeout=timeout)
|
|
|
|
await matrix_client.logout()
|
|
await matrix_client.close()
|
|
|
|
|
|
async def message_send(message):
|
|
message = await matrix_client.room_send(
|
|
room_id=config["room_id"],
|
|
message_type="m.room.message",
|
|
content={
|
|
"msgtype": "m.text",
|
|
"body": message
|
|
}
|
|
)
|
|
|
|
return message.event_id
|
|
|
|
|
|
async def message_redact(message, reason):
|
|
await matrix_client.room_redact(
|
|
room_id=config["room_id"],
|
|
event_id=message,
|
|
reason=reason
|
|
)
|
|
|
|
|
|
async def message_callback(room, event):
|
|
# Don't act on activities in other rooms
|
|
if room.room_id != config["room_id"]:
|
|
return
|
|
|
|
message = event.body
|
|
|
|
if not message:
|
|
return
|
|
|
|
# Don't act on ourselves
|
|
if event.sender == matrix_client.user:
|
|
return
|
|
|
|
author = event.sender[1:]
|
|
avatar = None
|
|
|
|
homeserver = author.split(":")[-1]
|
|
url = "https://matrix.org/_matrix/media/r0/download"
|
|
|
|
# Replace Discord mentions and emotes with IDs
|
|
message = await process_matrix(message)
|
|
|
|
# Get attachments
|
|
try:
|
|
attachment = event.url.split("/")[-1]
|
|
|
|
# Highlight attachment name
|
|
message = f"`{message}`"
|
|
|
|
message += f"\n{url}/{homeserver}/{attachment}"
|
|
except AttributeError:
|
|
pass
|
|
|
|
# Get avatar
|
|
for user in room.users.values():
|
|
if user.user_id == event.sender:
|
|
if user.avatar_url:
|
|
avatar = user.avatar_url.split("/")[-1]
|
|
avatar = f"{url}/{homeserver}/{avatar}"
|
|
break
|
|
|
|
await webhook_send(author, avatar, message, event.event_id)
|
|
|
|
|
|
async def redaction_callback(room, event):
|
|
# Don't act on activities in other rooms
|
|
if room.room_id != config["room_id"]:
|
|
return
|
|
|
|
# Don't act on ourselves
|
|
if event.sender == matrix_client.user:
|
|
return
|
|
|
|
# Redact webhook message
|
|
try:
|
|
message = message_cache[event.redacts]
|
|
await message.delete()
|
|
except KeyError:
|
|
pass
|
|
|
|
|
|
async def typing_callback(room, event):
|
|
channel = await get_channel()
|
|
|
|
# Don't act on activities in other rooms
|
|
if room.room_id != config["room_id"]:
|
|
return
|
|
|
|
if room.typing_users:
|
|
# Don't act on ourselves
|
|
if len(room.typing_users) == 1 \
|
|
and room.typing_users[0] == matrix_client.user:
|
|
return
|
|
|
|
# Send typing event
|
|
async with channel.typing():
|
|
pass
|
|
|
|
|
|
def main():
|
|
# Start Discord bot
|
|
discord_client.run(config["token"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|