mirror of https://xfnw.ttm.sh/git/oirc.git
261 lines
7.6 KiB
Python
261 lines
7.6 KiB
Python
import importlib, time, asyncio, random
|
|
from bot import *
|
|
|
|
quitmessages = [
|
|
"time to die",
|
|
"you can hide, but you can not run!",
|
|
"you're next",
|
|
"bye",
|
|
"the balun has been popped.",
|
|
]
|
|
|
|
|
|
async def commit(self, chan, source, msg):
|
|
await self.quit("{} told me to commit {}".format(source, msg))
|
|
|
|
|
|
async def quit(self, chan, source, msg):
|
|
await self.send(build("QUIT", [random.choice(quitmessages)]))
|
|
|
|
|
|
async def reloadmods(self, chan, source, msg):
|
|
await self.message(chan, "[\x036admin\x0f] reloading modules...")
|
|
shared.oldcmd = shared.commands
|
|
shared.commands = {}
|
|
shared.rawm = {}
|
|
shared.listeners = []
|
|
shared.help = {}
|
|
try:
|
|
for i in shared.modules:
|
|
importlib.reload(shared.modules[i])
|
|
await shared.modules[i].init(self)
|
|
# await self.message(chan, '[\x036admin\x0f] load {} sucess!'.format(i))
|
|
await self.message(
|
|
chan,
|
|
"[\x036admin\x0f] done! {} modules reloaded!".format(len(shared.modules)),
|
|
)
|
|
except:
|
|
await self.message(
|
|
chan, "[\x036admin\x0f] reload failed... attempting to recover..."
|
|
)
|
|
shared.commands = shared.oldcmd
|
|
|
|
|
|
async def rawcmd(self, chan, source, msg):
|
|
await self.send_raw(msg)
|
|
|
|
|
|
async def joins(self, chan, source, msg):
|
|
await self.message(chan, "[\x036admin\x0f] joining slowly as to not flood...")
|
|
for i in self.chandb.all():
|
|
await self.send(build("JOIN", [i["name"]]))
|
|
await asyncio.sleep(1)
|
|
print("joined {}".format(i["name"]))
|
|
await self.message(
|
|
chan,
|
|
"[\x036admin\x0f] Sucess! i may be laggy for a bit while i sort through all these channels...",
|
|
)
|
|
|
|
|
|
async def aexec(self, code):
|
|
# Make an async function with the code and `exec` it
|
|
exec(f"async def __ex(self): " + "".join(f"\n {l}" for l in code.split("\n")))
|
|
|
|
# Get `__ex` from local variables, call it and return the result
|
|
return await locals()["__ex"](self)
|
|
|
|
|
|
async def ev(self, chan, source, msg):
|
|
msg = msg.split(" ")
|
|
try:
|
|
await self.message(
|
|
chan,
|
|
"[\x036admin\x0f] ok, output: {}".format(
|
|
str(await aexec(self, " ".join(msg)))[:400]
|
|
),
|
|
)
|
|
except:
|
|
await self.message(chan, "[\x036admin\x0f] exception in eval!")
|
|
|
|
|
|
async def send(self, c, n, m):
|
|
msg = m.split(" ")
|
|
await self.message(msg.pop(0), " ".join(msg))
|
|
await self.message(c, "[\x036admin\x0f] sent")
|
|
|
|
|
|
async def shut(self, c, n, m):
|
|
shared.qtime[c] = time.time() + (60 * 10)
|
|
await self.message(c, "[\x036admin\x0f] Ok, il be back in 10 minutes")
|
|
|
|
|
|
async def schans(self, c, n, m):
|
|
self.chandb.delete()
|
|
for i in self.channels:
|
|
self.chandb.insert(dict(name=i))
|
|
await self.message(c, "[\x036admin\x0f] Ok")
|
|
|
|
|
|
async def addalias(self, c, n, m):
|
|
al = m.split(" ")[0]
|
|
m = m[len(al) + 1 :] # dont use the list since i want trailing spaces
|
|
if al in self.cmd:
|
|
await self.message(c, "[\x036admin\x0f] no dont overwrite a command dummy")
|
|
return
|
|
self.cmd[al] = Alias(m).alias
|
|
|
|
await self.message(c, '[\x036admin\x0f] added "{}" alias for "{}"'.format(al, m))
|
|
|
|
|
|
async def addot(self, c, n, m):
|
|
al = m.split(" ")[0]
|
|
m = m[len(al) + 1 :] # dont use the list since i want trailing spaces
|
|
if al in shared.rawm:
|
|
await self.message(c, "[\x036admin\x0f] no dont overwrite a command dummy")
|
|
return
|
|
shared.rawm[al] = Ot(m, al).ot
|
|
|
|
await self.message(c, '[\x036admin\x0f] added "{}" trigger for "{}"'.format(al, m))
|
|
|
|
|
|
async def addspook(self, c, n, m):
|
|
al = m.split(" ")[0]
|
|
m = m[len(al) + 1 :] # dont use the list since i want trailing spaces
|
|
if al in shared.rawm:
|
|
await self.message(c, "[\x036admin\x0f] no dont overwrite a command dummy")
|
|
return
|
|
shared.rawm[al] = Spook(m, al).spook
|
|
|
|
await self.message(c, '[\x036admin\x0f] added "{}" trigger for "{}"'.format(al, m))
|
|
|
|
|
|
async def addtrigger(self, c, n, m):
|
|
al = m.split(" ")[0]
|
|
m = m[len(al) + 1 :] # dont use the list since i want trailing spaces
|
|
if al in shared.rawm:
|
|
await self.message(c, "[\x036admin\x0f] no dont overwrite a command dummy")
|
|
return
|
|
shared.rawm[al] = Trigger(m, al).trigger
|
|
|
|
await self.message(c, '[\x036admin\x0f] added "{}" trigger for "{}"'.format(al, m))
|
|
|
|
|
|
class Ot:
|
|
def __init__(self, ms, al):
|
|
self.ms = str(ms)
|
|
self.al = str(al)
|
|
|
|
async def ot(alself, self, c, n, m):
|
|
if alself.al in m and n != self.nickname:
|
|
asyncio.create_task(
|
|
self.on_privmsg(
|
|
build("PRIVMSG", [c, alself.ms.format(m)], n + "!spoof@spoof")
|
|
)
|
|
)
|
|
shared.rawm.pop(alself.al)
|
|
|
|
|
|
class Spook:
|
|
def __init__(self, ms, al):
|
|
self.ms = str(ms)
|
|
self.al = str(al)
|
|
|
|
async def spook(alself, self, c, n, m):
|
|
if alself.al in m and n != self.nickname:
|
|
asyncio.create_task(self.message(c, alself.ms.format(m)))
|
|
shared.rawm.pop(alself.al)
|
|
|
|
|
|
class Trigger:
|
|
def __init__(self, ms, al):
|
|
self.ms = str(ms)
|
|
self.al = str(al)
|
|
|
|
async def trigger(alself, self, c, n, m):
|
|
if alself.al in m:
|
|
asyncio.create_task(
|
|
self.on_privmsg(
|
|
build("PRIVMSG", [c, alself.ms.format(m)], n + "!spoof@spoof")
|
|
)
|
|
)
|
|
|
|
|
|
class Alias:
|
|
def __init__(self, ms):
|
|
self.ms = str(ms)
|
|
|
|
async def alias(alself, self, c, n, m):
|
|
asyncio.create_task(
|
|
self.on_privmsg(
|
|
build("PRIVMSG", [c, alself.ms.format(m)], n + "!spoof@spoof")
|
|
)
|
|
)
|
|
|
|
|
|
commands = {
|
|
"quit": quit,
|
|
"reload": reloadmods,
|
|
"commit": commit,
|
|
"raw": rawcmd,
|
|
"eval": ev,
|
|
"send": send,
|
|
"joins": joins,
|
|
"shut": shut,
|
|
"schans": schans,
|
|
"addalias": addalias,
|
|
"addtrigger": addtrigger,
|
|
"addot": addot,
|
|
"addspook": addspook,
|
|
}
|
|
|
|
|
|
@command("admin")
|
|
@is_admin
|
|
async def adminHandle(self, chan, source, msg):
|
|
msg = msg.split(" ")
|
|
if len(msg) < 1 or not msg[0] in commands:
|
|
await self.message(chan, "[\x036admin\x0f] Invalid command")
|
|
return
|
|
print("[ADMIN MODULE] {} told me to {}!!!".format(source, msg[0]))
|
|
asyncio.create_task(commands[msg.pop(0)](self, chan, source, " ".join(msg)))
|
|
|
|
|
|
async def init(self):
|
|
self.chandb = shared.db["chan"]
|
|
|
|
self.admins = ["xfnw"]
|
|
return
|
|
self.cmd["admin"] = adminHandle
|
|
|
|
self.help["admin"] = [
|
|
"admin - various bot owner commands (more for subcommands)",
|
|
"sub-commands of admin, for more info do help admin <command>: quit reload commit part join joins eval send",
|
|
]
|
|
self.help["admin quit"] = ["admin quit <message> - make the bot disconnect", "no"]
|
|
self.help["admin reload"] = [
|
|
"admin reload - reload the modules and configs",
|
|
"nothing to see here",
|
|
]
|
|
self.help["admin commit"] = [
|
|
"admin commit <action> - oh no (more)",
|
|
"suggested with <3 by khux",
|
|
]
|
|
self.help["admin part"] = ["admin part <channel> - leave a channel", ":o"]
|
|
self.help["admin join"] = [
|
|
"admin join <channel> - make the bot join a channel",
|
|
"...",
|
|
]
|
|
self.help["admin joins"] = [
|
|
"admin joins - join more channels",
|
|
"dont reconnect to a bunch of chans when the bots crashing etc",
|
|
]
|
|
self.help["admin eval"] = [
|
|
"admin eval <command> - absolute power corrupts absolutely",
|
|
"lmao",
|
|
]
|
|
self.help["admin send"] = [
|
|
"admin send <channel> <message> - send a message",
|
|
"lmao",
|
|
]
|
|
self.help["admin schans"] = ["admin schans - save the commands to join", ";p;"]
|