async def create_event(self, ctx, event_name, date):
if ctx.message.server.id != '459911387490025493':
return
if not is_mod(ctx):
return
dt = parse(date)
if event_name in self.timers:
if not is_mod(ctx):
return
else:
self.timers[event_name] = dt.astimezone(timezone("UTC"))
await self.bot.say("Added event: " + event_name + " at time: " +
dt.strftime("%Y-%m-%d %H:%M:%S %Z%z"))
return
async def cmd_owner(self, ctx, new_owner: disnake.Member = None):
group_config = self.groups["groups"].get(str(ctx.channel.id))
if not group_config:
self.groups["groups"][str(ctx.channel.id)] = {}
group_config = self.groups["groups"][str(ctx.channel.id)]
owner_id = group_config.get("owner_id")
if not owner_id:
return
if not new_owner:
user = await self.bot.fetch_user(owner_id)
await ctx.channel.send(f"Besitzerin: @{user.name}#{user.discriminator}")
elif isinstance(group_config, dict):
owner = await self.bot.fetch_user(owner_id)
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
group_config["owner_id"] = new_owner.id
await self.remove_member_from_group(ctx.channel, new_owner, False)
if new_owner != owner:
await self.add_member_to_group(ctx.channel, owner, False)
await self.save_groups()
await self.update_permissions(ctx.channel)
await ctx.channel.send(
f"Glückwunsch {new_owner.mention}! Du bist jetzt die Besitzerin dieser Lerngruppe.")
async def mute(self, ctx, *args):
member = MemberConverter(ctx, args[0]).convert(
) if len(args) > 0 and args[0] else ctx.message.author
server = ctx.message.server
if server.id not in self.bot.audit_log.keys() or not is_mod(ctx):
return
if len(args) < 2 or not args[1].isdigit():
await self.bot.say(
"Invalid argument. Please specify a user and a time in minutes as a number."
)
return
if get(member.roles, name="Muted"):
await self.bot.say(
f"The user: {str(member.name)}\#{str(member.discriminator)} was already muted."
)
return
e = Embed(
title=
f"Member: {str(member.name)}\#{str(member.discriminator)} muted for {args[1]} minute(s)",
description=member.mention + " " + member.display_name,
colour=Colour.red(),
)
e.set_author(name=get_nick(member), icon_url=get_avatar(member))
e.set_thumbnail(url=get_avatar(member))
await self.bot.send_message(self.bot.get_channel(
self.bot.audit_log[member.server.id]),
embed=e)
await self.bot.add_rank(server, "Muted", member)
emojimeme = get(self.bot.get_all_emojis(), name='jellysad')
await self.bot.add_reaction(ctx.message, emojimeme)
await self.unmuteinternal(server, member, args[1])
async def unmute(self, ctx, *args):
member = MemberConverter(ctx, args[0]).convert(
) if len(args) > 0 and args[0] else ctx.message.author
server = ctx.message.server
if server.id not in self.bot.audit_log.keys() or not is_mod(ctx):
return
if not get(member.roles, name="Muted"):
await self.bot.say(
f"The user: {str(member.name)}\#{str(member.discriminator)} was not muted."
)
return
await self.bot.remove_rank(server, "Muted", member)
e = Embed(
title=
f"Member: {str(member.name)}\#{str(member.discriminator)} unmuted",
description=member.mention + " " + member.display_name,
colour=0xFFFF00,
)
e.set_author(name=get_nick(member), icon_url=get_avatar(member))
e.set_thumbnail(url=get_avatar(member))
await self.bot.send_message(self.bot.get_channel(
self.bot.audit_log[member.server.id]),
embed=e)
emojimeme = get(self.bot.get_all_emojis(), name='gladrad')
await self.bot.add_reaction(ctx.message, emojimeme)
async def help_card(self, ctx, name):
try:
command = data['command'][name]
if command['mod'] and not utils.is_mod(ctx):
return #raise KeyError
except KeyError:
await ctx.channel.send(
"Fehler! Für dieses Kommando habe ich keinen Hilfe-Eintrag. Gib `!help` ein um eine Übersicht zu erhalten. "
)
return
title = command['name']
text = f"**{title}**\n"
text += f"{command['brief']}\n\n" if command['brief'] else ""
text += f"**Syntax:**\n `{command['syntax']}`\n"
text += "**Parameter:**\n" if len(command['parameters']) > 0 else ""
for param, desc in command['parameters'].items():
text += f"`{param}` - {desc}\n"
text += f"**Beispiel:**\n `{command['example']}`\n" if command[
'example'] else ""
text += f"\n{command['description']}\n" if command[
'description'] else ""
embed = disnake.Embed(title=title, description=text, color=19607)
text += "==========================\n"
await utils.send_dm(ctx.author, text) # , embed=embed)
for subname in data['command']:
if subname.startswith(f"{name} "):
await self.help_card(ctx, subname)
async def copy_channel(self,
ctx,
from_channel: str,
to_channel: Channel,
to_filter=None,
limit=10000):
if not is_mod(ctx): return
from_channel = self.bot.get_channel(
from_channel) or self.bot.get_channel(from_channel[2:-1])
if from_channel is None:
await self.bot.say("Invalid from_channel")
return
if to_filter == "image":
def to_filter(msg: Message):
if msg.attachments or msg.embeds:
return True
else:
# noinspection PyUnusedLocal
def to_filter(msg: Message):
return True
msglist = []
async for i in afilter(
self.bot.logs_from(from_channel,
before=dt.utcnow(),
limit=limit), to_filter):
msglist.append(i)
for i in msglist[::-1]:
i: Message = i
embed = Embed()
embed.set_author(name=get_nick(i.author),
icon_url=get_avatar(i.author))
if len(i.attachments) == 1:
embed.set_image(url=i.attachments[0]["url"])
elif len(i.attachments) > 1:
for ind, j in enumerate(i.attachments):
aembed = deepcopy(embed)
aembed.description = f"Image {ind+1}/{len(i.attachments)}"
aembed.set_image(url=j["url"])
await self.bot.send_message(to_channel, embed=aembed)
if i.embeds:
with (suppress(IndexError, KeyError)):
aembed = deepcopy(embed)
aembed.set_image(url=i.embeds[0]['image']['url'])
await self.bot.send_message(to_channel, embed=aembed)
embed.description = i.content
if embed.description or embed.image.url:
await self.bot.send_message(to_channel, embed=embed)
async def delete_this(self, ctx, msg_id: str, channel_id=None):
"""Delete a message by id"""
if not is_mod(ctx): return
channel = self.bot.get_channel(
channel_id) if channel_id else ctx.message.channel
await self.bot.delete_message(await
self.bot.get_message(channel, msg_id))
await self.bot.delete_message(ctx.message)
async def cmd_id(self, ctx):
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
group_config = self.groups["groups"].get(str(ctx.channel.id))
if not group_config:
await ctx.channel.send("Das ist kein Lerngruppenkanal.")
return
await ctx.channel.send(f"Die ID dieser Lerngruppe lautet: `{str(ctx.channel.id)}`.\n"
f"Beitrittsanfrage mit: `!lg join {str(ctx.channel.id)}`")
async def cmd_kick(self, ctx, arg_member: disnake.Member):
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
group_config = self.groups["groups"].get(str(ctx.channel.id))
if not group_config:
await ctx.channel.send("Das ist keine gültiger Lerngruppenkanal.")
return
await self.remove_member_from_group(ctx.channel, arg_member)
await self.update_permissions(ctx.channel)
async def delete_event(self, ctx, event_name):
if ctx.message.server.id != '459911387490025493':
return
if not is_mod(ctx):
return
if event_name in self.timers:
del self.timers[event_name]
await self.bot.say("Deleted event: " + event_name)
return
async def cmd_add_member(self, ctx, arg_member: disnake.Member, arg_channel: disnake.TextChannel = None):
if not arg_channel:
if not self.channels.get(str(ctx.channel.id)):
await ctx.channel.send("Wenn das Kommando außerhalb eines Lerngruppenkanals aufgerufen wird, muss der"
"Lerngruppenkanal angehängt werden. `!lg addmember <@usermention> <#channel>`")
return
arg_channel = ctx.channel
if self.is_group_owner(arg_channel, ctx.author) or utils.is_mod(ctx):
await self.add_member_to_group(arg_channel, arg_member)
await self.update_permissions(arg_channel)
async def cmd_show(self, ctx):
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
channel_config = self.channels[str(ctx.channel.id)]
if channel_config:
if channel_config.get("state") == GroupState.PRIVATE:
if await self.set_channel_listing(ctx.channel, True):
await ctx.channel.send("Die Lerngruppe wird nun in der Lerngruppenliste angezeigt.")
elif channel_config.get("state") == GroupState.OPEN:
await ctx.channel.send("Nichts zu tun. Offene Lerngruppen werden sowieso in der Liste angezeigt.")
elif channel_config.get("state") == GroupState.CLOSED:
await ctx.channel.send("Möchtest du die Gruppen öffnen? Versuch‘s mit `!lg open`")
async def reload(self, ctx, r_command):
if not is_mod(ctx):
return
print("Reloading because mod used command!")
if r_command == "all":
for i in self.command_channels.keys():
await self.load_command(i, self.command_channels[i], True)
return
await self.load_command(r_command, self.command_channels[r_command], True)
async def del_time_tz(self, ctx, tzi, after, before=None):
"""Deletes messages given a time zone, a time at which to start, and an optional time at which to end"""
if not is_mod(ctx): return
args = {}
if before: args['before'] = get_utc_date(before, tzi)
args['after'] = get_utc_date(after, tzi)
try:
await self.bot.purge_from(ctx.message.channel, **args, limit=4000)
except Exception as e:
await self.bot.say(e)
async def del_time(self, ctx, after, before=None):
"""Deletes messages given a time at which to start and an optional time at which to end"""
if not is_mod(ctx): return
args = {'after': get_utc_date(after)}
if before is not None:
args['before'] = get_utc_date(before)
try:
print(args)
await self.bot.purge_from(ctx.message.channel, **args, limit=4000)
except Exception as e:
await self.bot.say(e)
async def roleping(self, ctx, *, role):
if not is_mod(ctx): return
role = role.title() if role == role.lower() else role
s = ctx.message.server
role = get(s.roles, name=role)
if role is None:
await self.bot.say("Role not found in server")
return
await self.bot.say(
repr([x.mention for x in s.members if role in x.roles]))
async def cmd_hide(self, ctx):
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
channel_config = self.channels[str(ctx.channel.id)]
if channel_config:
if channel_config.get("state") == GroupState.PRIVATE:
if await self.set_channel_listing(ctx.channel, False):
await ctx.channel.send("Die Lerngruppe wird nun nicht mehr in der Lerngruppenliste angezeigt.")
return
elif channel_config.get("state") == GroupState.OPEN:
await ctx.channel.send("Offene Lerngruppen können nicht aus der Lerngruppenliste entfernt werden. "
"Führe `!lg close` aus um die Lerngruppe zu schließen, "
"oder `!lg private` um diese auf "
"privat zu schalten.")
elif channel_config.get("state") == GroupState.CLOSED:
await ctx.channel.send("Wenn diese Gruppe privat werden soll, ist das Kommando das du brauchst: `!lg private`")
async def cmd_commands_add(self,
ctx,
cmd,
text,
help_message=None,
category=None):
if utils.is_mod(ctx):
await self.add_command(cmd,
text,
help_message=help_message,
category=category)
else:
await self.suggest_command(ctx,
cmd,
text,
help_message=help_message,
category=category)
async def del_time_user(self, ctx, after, user: User):
"""Deletes messages given a time at which to start and an optional time at which to end"""
if not is_mod(ctx): return
args = {}
def check_user(msg: Message):
return msg.author == user
args['after'] = get_utc_date(after)
try:
await self.bot.purge_from(ctx.message.channel,
**args,
limit=4000,
check=check_user)
except Exception as e:
await self.bot.say(e)
async def clear(self, ctx, num: int, user: User = None):
"""Clear the given number of messages. Optional user param."""
if not is_mod(ctx): return
counter = 0
channel = ctx.message.channel
if channel.server.id in self.bot.audit_log.keys():
embedded = Embed(
title="Bulk delete in " + channel.name,
description=str(num) + " messages deleted in " +
channel.mention,
colour=Colour.red(),
)
await self.bot.send_message(self.bot.get_channel(
self.bot.audit_log[channel.server.id]),
embed=embedded)
def check_user(msg: Message):
nonlocal counter
if counter < num + 1 and user is None:
counter += 1
return True
elif counter < num + 1 and msg.author == user:
counter += 1
return True
return False
try:
await self.bot.purge_from(ctx.message.channel,
around=ctx.message,
limit=101,
before=ctx.message.timestamp +
timedelta(seconds=5),
check=check_user)
except Exception as e:
await self.bot.say(e)
async def say_in(self, ctx, channel: Channel, *, msg: str):
"""Say a message in a given channel"""
if not is_mod(ctx):
return
await self.send_message(channel, msg)
async def cmd_close(self, ctx):
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
await self.set_channel_state(ctx.channel, state=GroupState.CLOSED)
async def cmd_private(self, ctx):
if self.is_group_owner(ctx.channel, ctx.author) or utils.is_mod(ctx):
if await self.set_channel_state(ctx.channel, state=GroupState.PRIVATE):
await self.update_permissions(ctx.channel)