def create_guild_event(self, raid_id):
conn = self.bot.conn
channel_id, guild_id, name, tier, description, timestamp = select_one(conn, 'Raids', ['channel_id', 'guild_id', 'name', 'tier', 'boss', 'time'], ['raid_id'], [raid_id])
res = select_one(conn, 'Settings', ['guild_events'], ['guild_id'], [guild_id])
if not res:
return
metadata = {"location": f"https://discord.com/channels/{guild_id}/{channel_id}/{raid_id}"}
start_time = datetime.utcfromtimestamp(timestamp).isoformat() + 'Z'
end_time = datetime.utcfromtimestamp(timestamp+7200).isoformat() + 'Z'
data = {
"entity_metadata": metadata,
'name': " ".join([name, tier]),
"privacy_level": 2,
"scheduled_start_time": start_time,
"scheduled_end_time": end_time,
"description": description,
"entity_type": 3
}
url = self.bot.api + f"guilds/{guild_id}/scheduled-events"
r = requests.post(url, headers=self.headers, json=data)
r.raise_for_status()
event = r.json()
event_id = event['id']
return event_id
async def sign_up_cancel(self, i):
await i.response.defer()
raid_id = i.message.id
timestamp = int(time.time())
assigned_slot = select_one(self.conn, 'Assignment', ['slot_id'],
['player_id', 'raid_id'],
[i.user.id, raid_id])
if assigned_slot is not None:
class_name = select_one(self.conn, 'Assignment', ['class_name'],
['player_id', 'raid_id'],
[i.user.id, raid_id])
error_msg = _(
"Dearest raid leader, {0} has cancelled their availability. "
"Please note they were assigned to {1} in the raid.").format(
i.user.mention, class_name)
await i.channel.send(error_msg)
class_names = ','.join(
self.raid_cog.slots_class_names[assigned_slot])
assign_columns = ['player_id', 'byname', 'class_name']
assign_values = [None, _("<Open>"), class_names]
upsert(self.conn, 'Assignment', assign_columns, assign_values,
['raid_id', 'slot_id'], [raid_id, assigned_slot])
r = select_one(self.conn, 'Players', ['byname'],
['player_id', 'raid_id'], [i.user.id, raid_id])
if r:
delete(self.conn, 'Players', ['player_id', 'raid_id'],
[i.user.id, raid_id])
else:
byname = self.process_name(i.guild.id, i.user)
upsert(self.conn, 'Players',
['byname', 'timestamp', 'unavailable'],
[byname, timestamp, True], ['player_id', 'raid_id'],
[i.user.id, raid_id])
self.conn.commit()
await self.raid_cog.update_raid_post(raid_id, i.channel)
def build_raid_message(self, guild, raid_id, embed_texts):
timestamp = int(
select_one(self.conn, 'Raids', 'time',
raid_id)) # Why can't this return an int by itself?
time = datetime.datetime.utcfromtimestamp(timestamp)
name = select_one(self.conn, 'Raids', 'name', raid_id)
tier = select_one(self.conn, 'Raids', 'tier', raid_id)
boss = select_one(self.conn, 'Raids', 'boss', raid_id)
roster = select_one(self.conn, 'Raids', 'roster', raid_id)
player_ids = select(self.conn, 'Players', 'player_id', raid_id)
if player_ids:
number_of_players = len(player_ids)
else:
number_of_players = 0
server_tz = TimeCog.get_server_time(guild)
server_time = TimeCog.local_time(time, server_tz)
header_time = TimeCog.format_time(server_time) + _(" server time")
embed_title = _("{0} {1} at {2}").format(name, tier, header_time)
embed_description = _("Bosses: {0}").format(boss)
embed = discord.Embed(title=embed_title,
colour=discord.Colour(0x3498db),
description=embed_description)
time_string = self.build_time_string(time, guild)
embed.add_field(name=_("Time zones:"), value=time_string)
if roster:
result = select_rows(self.conn, 'Assignment', 'byname, class_name',
raid_id)
number_of_slots = len(result)
# Add first half
embed_name = _("Selected line up:")
embed_text = ""
for row in result[:number_of_slots // 2]:
class_names = row[1].split(',')
for class_name in class_names:
embed_text = embed_text + self.class_emojis_dict[class_name]
embed_text = embed_text + ": " + row[0] + "\n"
embed.add_field(name=embed_name, value=embed_text)
# Add second half
embed_name = "\u200B"
embed_text = ""
for row in result[number_of_slots // 2:]:
class_names = row[1].split(',')
for class_name in class_names:
embed_text = embed_text + self.class_emojis_dict[class_name]
embed_text = embed_text + ": " + row[0] + "\n"
embed.add_field(name=embed_name, value=embed_text)
# Add a field for each embed text
for i in range(len(embed_texts)):
if i == 0:
embed_name = _("The following {0} players are available:"
).format(number_of_players)
else:
embed_name = "\u200B"
embed.add_field(name=embed_name, value=embed_texts[i])
embed.set_footer(text=_("Raid time in your local time (beta)"))
embed.timestamp = time
return embed
async def background_task(self):
bot = self.bot
raids = self.raids
expiry_time = datetime.timedelta(
seconds=7200) # Delete raids after 2 hours.
notify_seconds = 300 # Notify raiders 5 minutes before.
notify_time = datetime.timedelta(seconds=notify_seconds)
current_time = datetime.datetime.utcnow(
) # Raid time is stored in UTC.
# Copy the list to iterate over.
for raid_id in raids[:]:
timestamp = int(select_one(self.conn, 'Raids', 'time', raid_id))
time = datetime.datetime.utcfromtimestamp(timestamp)
if current_time >= time - notify_time * 2:
channel_id = select_one(self.conn, 'Raids', 'channel_id',
raid_id)
channel = bot.get_channel(channel_id)
if not channel:
self.cleanup_old_raid(raid_id,
"Raid channel has been deleted.")
continue
try:
post = await channel.fetch_message(raid_id)
except discord.NotFound:
self.cleanup_old_raid(raid_id,
"Raid post already deleted.")
except discord.Forbidden:
self.cleanup_old_raid(
raid_id,
"We are missing required permissions to see raid post."
)
else:
if current_time > time + expiry_time:
await post.delete()
self.cleanup_old_raid(raid_id,
"Deleted expired raid post.")
elif current_time < time - notify_time:
roster = select_one(self.conn, 'Raids', 'roster',
raid_id)
if roster:
raid_start_msg = _("Gondor calls for aid! ")
players = select_rows(self.conn, 'Assignment',
'player_id', raid_id)
for player in players:
player_id = player[0]
if player_id:
raid_start_msg = raid_start_msg + "<@{0}> ".format(
player_id)
raid_start_msg = raid_start_msg + _(
"will you answer the call? We are forming for the raid now."
)
await channel.send(raid_start_msg,
delete_after=notify_seconds * 2)
self.conn.commit()
async def callback(self, interaction: discord.Interaction):
raid_id = self.view.raid_id
if self.view.player is None:
msg = _("Please select a player first.")
await interaction.response.send_message(msg, ephemeral=True)
return
slot = select_one(self.view.conn, 'Assignment', ['slot_id', 'byname'],
['player_id', 'raid_id'],
[self.view.player, raid_id])
if slot is not None:
assignment_columns = ['player_id', 'byname', 'class_name']
class_names = ','.join(
self.view.raid_cog.slots_class_names[slot[0]])
assignment_values = [None, _("<Open>"), class_names]
upsert(self.view.conn, 'Assignment', assignment_columns,
assignment_values, ['raid_id', 'slot_id'],
[raid_id, slot[0]])
await self.view.raid_cog.update_raid_post(raid_id,
interaction.channel)
if self.values[0] == 'remove':
return
signup = select_one(self.view.conn, 'Players',
[self.values[0], 'byname'],
['player_id', 'raid_id'],
[self.view.player, raid_id])
if not signup[0]:
msg = _("{0} did not sign up with {1}.").format(
signup[1], self.values[0])
await interaction.response.send_message(msg, ephemeral=True)
return
if self.view.slot == -1:
search = '%' + self.values[0] + '%'
slot_id = select_one(self.view.conn, 'Assignment', ['slot_id'],
['raid_id'], [raid_id], ['player_id'],
['class_name'], [search])
else:
slot_id = self.view.slot
if slot_id is None:
msg = _(
"There are no slots available for the selected class. "
"Please select the slot manually or pick a different class.")
await interaction.response.send_message(msg, ephemeral=True)
return
assignment_columns = ['player_id', 'byname', 'class_name']
assignment_values = [self.view.player, signup[1], self.values[0]]
upsert(self.view.conn, 'Assignment', assignment_columns,
assignment_values, ['raid_id', 'slot_id'], [raid_id, slot_id])
await self.view.raid_cog.update_raid_post(raid_id, interaction.channel)
def build_raid_players(self, raid_id, available=True, block_size=6):
guild_id = select_one(self.conn, 'Raids', 'guild_id', raid_id)
guild = self.bot.get_guild(guild_id)
columns = 'raid_id, player_id, byname'
if available:
for name in self.role_names:
columns = columns + ", " + name
unavailable = (int(available) + 1) % 2
result = select_players(self.conn,
columns,
raid_id,
unavailable=unavailable)
player_strings = []
if result:
number_of_players = len(result)
number_of_fields = ((number_of_players - 1) // block_size) + 1
# Create the player strings
for row in result:
i = 2
if available:
player_string = row[i] + " "
for name in self.role_names:
i = i + 1
if row[i]:
player_string = player_string + self.class_emojis_dict[
name]
else:
player_string = "\u274C " + row[i]
player_string = player_string + "\n"
player_strings.append(player_string)
# Sort the strings by length
player_strings.sort(key=len, reverse=True)
else:
if not available:
return None
number_of_players = 0
number_of_fields = 1
# Compute number of fields
msg = [""] * number_of_fields
# Add the players to the fields, spreading large strings.
number_of_players_added = 0
remainder = number_of_players % block_size
if remainder:
cap_index_last_field = number_of_fields * remainder
else:
cap_index_last_field = number_of_fields * block_size
for player_string in player_strings:
if number_of_players_added < cap_index_last_field:
index = number_of_players_added % number_of_fields
else:
index = number_of_players_added % (number_of_fields - 1)
number_of_players_added = number_of_players_added + 1
msg[index] = msg[index] + player_string
# Do not send an empty embed if there are no players.
if msg[0] == "":
msg[0] = "\u200B"
# Check if the length does not exceed embed limit and split if we can.
if len(max(msg, key=len)) >= 1024 and block_size >= 2:
msg = self.build_raid_players(raid_id, block_size=block_size // 2)
return msg
def get_user_timezone(self, user_id, guild_id):
conn = self.bot.conn
result = select_one(conn, 'Timezone', ['timezone'], ['player_id'],
[user_id])
if result is None:
result = self.get_server_timezone(guild_id)
return result
def get_server_timezone(self, guild_id):
conn = self.bot.conn
result = select_one(conn, 'Settings', ['server'], ['guild_id'],
[guild_id])
if result is None:
result = self.bot.server_tz
return result
def find_first(cls, where, *args):
"""
通过where语句进行条件查询，返回1个查询结果。如果有多个查询结果
仅取第一个，如果没有结果，则返回None
"""
d = database.select_one('select * from %s %s' % (cls.__table__, where), *args)
return cls(**d) if d else None
async def select(self, button: discord.ui.Button,
interaction: discord.Interaction):
if not await self.raid_cog.has_raid_permission(
interaction.user, interaction.guild, interaction.message.id):
perm_msg = _(
"You do not have permission to change the raid settings.")
await interaction.response.send_message(perm_msg, ephemeral=True)
return
raid_id = interaction.message.id
available = select(self.conn, 'Players', ['player_id, byname'],
['raid_id', 'unavailable'], [raid_id, False])
if not available:
msg = _("There are no players to assign for this raid!")
await interaction.response.send_message(msg, ephemeral=True)
return
msg = _("Please first select the player. The roster is updated when a class is selected. "
"You can select a slot manually or leave it on automatic.\n") \
+ _("(This selection message is ephemeral and will cease to work after 60s without interaction.)")
view = SelectView(self.raid_cog, raid_id)
await interaction.response.send_message(msg, view=view, ephemeral=True)
roster = select_one(self.conn, 'Raids', ['roster'], ['raid_id'],
[raid_id])
if not roster:
upsert(self.conn, 'Raids', ['roster'], [True], ['raid_id'],
[raid_id])
def get_display_times(guild):
result = select_one(TimeCog.conn, 'Settings', 'display', guild.id, pk_column='guild_id')
if result is None:
result = TimeCog.display_times
else:
result = result.split(',')
return result
def get(cls, pk):
"""
Get by primary key.
"""
d = database.select_one(
'select * from %s where %s=?' %
(cls.__table__, cls.__primary_key__.name), pk)
return cls(**d) if d else None
async def is_raid_leader(self, ctx):
conn = self.bot.conn
if ctx.author.guild_permissions.administrator:
return True
raid_leader_id = select_one(conn, 'Settings', ['raid_leader'], ['guild_id'], [ctx.guild.id])
if raid_leader_id in [role.id for role in ctx.author.roles]:
return True
error_msg = _("You do not have permission to change the settings.")
await ctx.send(error_msg, delete_after=15)
return False
def is_raid_leader(self, user, guild_id):
if user.guild_permissions.administrator:
return True
raid_leader_id = select_one(self.conn, 'Settings', ['raid_leader'],
['guild_id'], [guild_id])
if raid_leader_id:
guild = self.bot.get_guild(guild_id)
raid_leader = guild.get_role(raid_leader_id)
if raid_leader in user.roles:
return True
return False
async def has_raid_permission(self, user, guild, raid_id, channel=None):
if user.guild_permissions.administrator:
return True
organizer_id = select_one(self.conn, 'Raids', ['organizer_id'],
['raid_id'], [raid_id])
if organizer_id == user.id:
return True
raid_leader_id = select_one(self.conn, 'Settings', ['raid_leader'],
['guild_id'], [guild.id])
if raid_leader_id:
raid_leader = guild.get_role(raid_leader_id)
if raid_leader in user.roles:
return True
if channel:
perm_msg = _(
"You do not have permission to change the raid settings.")
await channel.send(perm_msg, delete_after=15)
return False
def process_name(self, guild_id, user):
role_id = select_one(self.conn, 'Settings', ['priority'], ['guild_id'],
[guild_id])
if role_id in [role.id for role in user.roles]:
byname = "\U0001F46A " + user.display_name
else:
if "\U0001F46A" in user.display_name:
byname = "iMAhACkEr"
else:
byname = user.display_name
return byname
async def cleanup_old_raid(self, raid_id, message):
logger.info(message)
guild_id = select_one(self.conn, 'Raids', ['guild_id'], ['raid_id'],
[raid_id])
delete(self.conn, 'Raids', ['raid_id'], [raid_id])
delete(self.conn, 'Players', ['raid_id'], [raid_id])
delete(self.conn, 'Assignment', ['raid_id'], [raid_id])
logger.info("Deleted old raid from database.")
await self.calendar_cog.update_calendar(guild_id, new_run=False)
try:
self.raids.remove(raid_id)
except ValueError:
logger.info("Raid already deleted from memory.")
def delete_guild_event(self, raid_id):
conn = self.bot.conn
try:
guild_id, event_id = select_one(conn, 'Raids', ['guild_id', 'event_id'], ['raid_id'], [raid_id])
except TypeError:
logger.info("Raid already deleted from database.")
return
if not event_id:
return
url = self.bot.api + f"guilds/{guild_id}/scheduled-events/{event_id}"
r = requests.delete(url, headers=self.headers)
r.raise_for_status()
async def predicate(ctx):
raid_leader_name = select_one(conn, 'Settings', 'raid_leader', ctx.guild.id, 'guild_id')
if not raid_leader_name:
raid_leader_name = TimeCog.raid_leader_name
raid_leader = await get_role(ctx.guild, raid_leader_name)
if raid_leader in ctx.author.roles:
return True
if ctx.invoked_with == 'help': # Do not ask me why it executes this check for the help command.
return False
error_msg = _("You do not have permission to change the raid settings. "
"You need to have the '{0}' role.").format(TimeCog.raid_leader_name)
logger.info("Putting {0} on the naughty list.".format(ctx.author.name))
await ctx.send(error_msg, delete_after=15)
return False
def modify_guild_event(self, raid_id):
conn = self.bot.conn
guild_id, event_id, name, tier, description, timestamp = select_one(conn, 'Raids', ['guild_id', 'event_id', 'name', 'tier', 'boss', 'time'], ['raid_id'], [raid_id])
if not event_id:
return
start_time = datetime.utcfromtimestamp(timestamp).isoformat() + 'Z'
end_time = datetime.utcfromtimestamp(timestamp+7200).isoformat() + 'Z'
data = {
'name': " ".join([name, tier]),
'description': description,
'scheduled_start_time': start_time,
'scheduled_end_time': end_time
}
url = self.bot.api + f"guilds/{guild_id}/scheduled-events/{event_id}"
r = requests.patch(url, headers=self.headers, json=data)
r.raise_for_status()
async def update_calendar(self, guild_id):
res = select_one(self.conn, 'Settings', 'calendar', guild_id,
'guild_id')
if not res:
return
result = res.split("/")
chn_id = int(result[0])
msg_id = int(result[1])
chn = self.bot.get_channel(chn_id)
try:
msg = await chn.fetch_message(msg_id)
except (AttributeError, discord.NotFound):
logger.warning("Calendar post not found.")
res = remove_setting(self.conn, 'calendar', guild_id)
self.conn.commit()
return
embed = self.calendar_embed(guild_id)
await msg.edit(embed=embed)
await chn.send(_("A new run has been posted!"), delete_after=3600)
async def update_calendar(self, guild_id, new_run=True):
conn = self.bot.conn
res = select_one(conn, 'Settings', ['calendar'], ['guild_id'], [guild_id])
if not res:
return
result = res.split("/")
chn_id = int(result[0])
msg_id = int(result[1])
chn = self.bot.get_channel(chn_id)
try:
msg = chn.get_partial_message(msg_id)
except AttributeError:
logger.warning("Calendar channel not found for guild {0}.".format(guild_id))
res = upsert(conn, 'Settings', ['calendar'], [None], ['guild_id'], [guild_id])
if res:
conn.commit()
return
embed = self.calendar_embed(guild_id)
try:
await msg.edit(embed=embed)
except discord.Forbidden:
logger.warning("Calendar access restricted for guild {0}.".format(guild_id))
return
except discord.NotFound:
logger.warning("Calendar post not found for guild {0}.".format(guild_id))
upsert(conn, 'Settings', ['calendar'], [None], ['guild_id'], [guild_id])
conn.commit()
return
except discord.HTTPException as e:
logger.warning("Failed to update calendar for guild {0}.".format(guild_id))
logger.warning(e)
return
if new_run:
try:
await chn.send(_("A new run has been posted!"), delete_after=3600)
except discord.Forbidden:
logger.warning("No write access to calendar channel for guild {0}.".format(guild_id))
async def roster_configure(self, author, channel, raid_id):
bot = self.bot
roster = select_one(self.conn, 'Raids', 'roster', raid_id)
def check(msg):
return author == msg.author
text = _(
"Please respond with 'yes/no' to indicate whether you want to use the roster for this raid."
)
msg = await channel.send(text)
try:
reply = await bot.wait_for('message', timeout=20, check=check)
except asyncio.TimeoutError:
await channel.send(_("Roster configuration finished!"),
delete_after=10)
return
else:
await reply.delete()
if reply.content.lower().startswith(_("n")):
if roster:
update_raid(self.conn, 'raids', 'roster', False, raid_id)
await channel.send(_(
"Roster disabled for this raid.\nRoster configuration finished!"
),
delete_after=10)
return
elif not reply.content.lower().startswith(_("y")):
await channel.send(_("Roster configuration finished!"),
delete_after=10)
return
finally:
await msg.delete()
if not roster:
update_raid(self.conn, 'raids', 'roster', True, raid_id)
await channel.send(_("Roster enabled for this raid."),
delete_after=10)
await self.roster_overwrite(author, channel, raid_id)
import database
database.insert('recipes.txt', 'ketchup', 'Tomatoes, sugar, vinegar')
database.insert('recipes.txt', 'mustard', 'Mustard seeds and vinegar')
database.insert('recipes.txt', 'mayo', 'Oil and egg yolk')
mustard_recipe = database.select_one('recipes.txt', 'mustard')
print(mustard_recipe)
def build_raid_message(self, raid_id, embed_texts_av, embed_texts_unav):
try:
name, tier, time, boss, roster = select_one(
self.conn, 'Raids', ['name', 'tier', 'time', 'boss', 'roster'],
['raid_id'], [raid_id])
except TypeError:
logger.info("The raid has been deleted during editing.")
return
timestamp = int(time)
number_of_players = count(self.conn, 'Players', 'player_id',
['raid_id', 'unavailable'], [raid_id, False])
if tier:
embed_title = f"{name} {tier}\n<t:{timestamp}:F>"
else:
embed_title = f"{name}\n<t:{timestamp}:F>"
if boss:
embed_description = _("Aim: {0}").format(boss)
else:
embed_description = ""
embed = discord.Embed(title=embed_title,
colour=discord.Colour(0x3498db),
description=embed_description)
if roster:
result = select(self.conn, 'Assignment', ['byname, class_name'],
['raid_id'], [raid_id])
number_of_slots = len(result)
# Add first half
embed_name = _("Selected line up:")
embed_text = ""
for row in result[:number_of_slots // 2]:
class_names = row[1].split(',')
for class_name in class_names:
embed_text = embed_text + self.class_emojis_dict[class_name]
embed_text = embed_text + ": " + row[0] + "\n"
embed.add_field(name=embed_name, value=embed_text)
# Add second half
embed_name = "\u200B"
embed_text = ""
for row in result[number_of_slots // 2:]:
class_names = row[1].split(',')
for class_name in class_names:
embed_text = embed_text + self.class_emojis_dict[class_name]
embed_text = embed_text + ": " + row[0] + "\n"
embed.add_field(name=embed_name, value=embed_text)
embed.add_field(name="\u200B", value="\u200B")
# Add a field for each embed text
for i in range(len(embed_texts_av)):
if i == 0:
embed_name = _("The following {0} players are available:"
).format(number_of_players)
else:
embed_name = "\u200B"
embed.add_field(name=embed_name, value=embed_texts_av[i])
if len(embed_texts_av) == 1:
embed.add_field(name="\u200B", value="\u200B")
if embed_texts_unav:
number_of_unav_players = count(self.conn, 'Players', 'player_id',
['raid_id', 'unavailable'],
[raid_id, True])
for i in range(len(embed_texts_unav)):
if i == 0:
embed_name = _("The following {0} players are unavailable:"
).format(number_of_unav_players)
else:
embed_name = "\u200B"
embed.add_field(name=embed_name, value=embed_texts_unav[i])
return embed
import database
while True:
type = input("type: ")
if type=="a":
name = input("name: ")
number = input("number: ")
database.insert('directory.txt', name, number)
if type=="f":
name = input("name: ")
found = str(database.select_one('directory.txt', name))
if found == "None":
print("Name not in directory")
else:
print(found)
if type=="d":
name = input("name: ")
found = str(database.select_one('directory.txt', name))
if found == "None":
print("Name not in directory")
else:
database.delete('directory.txt', name)
if type=="u":
name = input("name: ")
found = str(database.select_one('directory.txt', name))
if found == "None":
print("Name not in directory")
else:
number = input("new number: ")
database.update('directory.txt', name, number)
if type=="q":
def get_user_timezone(author):
result = select_one(TimeCog.conn, 'Timezone', 'timezone', author.id, pk_column='player_id')
if result is None:
result = TimeCog.server_tz
return result
async def raid_update(self, payload):
bot = self.bot
guild = bot.get_guild(payload.guild_id)
channel = guild.get_channel(payload.channel_id)
user = payload.member
raid_id = payload.message_id
emoji = payload.emoji
raid_deleted = False
if str(emoji) in ["\U0001F6E0", "\u26CF"]:
organizer_id = select_one(self.conn, 'Raids', 'organizer_id',
raid_id)
raid_leader_name = select_one(self.conn, 'Settings', 'raid_leader',
guild.id, 'guild_id')
if not raid_leader_name:
raid_leader_name = self.raid_leader_name
raid_leader = await get_role(guild, raid_leader_name)
if raid_leader not in user.roles and organizer_id != user.id:
error_msg = _(
"You do not have permission to change the raid settings. "
"You need to have the '{0}' role.").format(
raid_leader_name)
logger.info("Putting {0} on the naughty list.".format(
user.name))
await channel.send(error_msg, delete_after=15)
return
if str(emoji) == "\u26CF": # Pick emoji
roster = select_one(self.conn, 'raids', 'roster', raid_id)
if not roster:
update_raid(self.conn, 'raids', 'roster', True, raid_id)
await channel.send(_("Enabling roster for this raid."),
delete_after=10)
await self.get_players(user, channel, raid_id)
elif str(emoji) == "\U0001F6E0": # Config emoji
raid_deleted = await self.configure(user, channel, raid_id)
elif str(emoji) == "\u274C": # Cancel emoji
assigned_slot = select_one_player(self.conn, 'Assignment',
'slot_id', user.id, raid_id)
if assigned_slot is not None:
class_name = select_one_player(self.conn, 'Assignment',
'class_name', user.id, raid_id)
error_msg = _(
"Dearest raid leader, {0} has cancelled their availability. "
"Please note they were assigned to {1} in the raid."
).format(user.mention, class_name)
await channel.send(error_msg)
class_names = ','.join(self.slots_class_names[assigned_slot])
assign_player(self.conn, raid_id, assigned_slot, None,
_("<Available>"), class_names)
r = select_one_player(self.conn, 'Players', 'byname', user.id,
raid_id)
if r:
delete_raid_player(self.conn, user.id, raid_id)
else:
add_player_class(self.conn,
raid_id,
user.id,
user.display_name, [],
unavailable=1)
elif str(emoji) == "\u2705": # Check mark emoji
role_names = [
role.name for role in user.roles
if role.name in self.role_names
]
if role_names:
add_player_class(self.conn, raid_id, user.id,
user.display_name, role_names)
else:
error_msg = _(
"{0} you have not assigned yourself any class roles."
).format(user.mention)
await channel.send(error_msg, delete_after=15)
elif emoji.name in self.role_names:
add_player_class(self.conn, raid_id, user.id, user.display_name,
[emoji.name])
try:
role = await get_role(guild, emoji.name)
if role not in user.roles:
await user.add_roles(role)
except discord.Forbidden:
await channel.send(
_("Error: Missing 'Manage roles' permission to assign the class role."
))
self.conn.commit()
if raid_deleted:
post = await channel.fetch_message(raid_id)
await post.delete()
return True
else:
await self.update_raid_post(raid_id, channel)
return
async def twitter_task(self):
last_tweet_id = select_one(self.conn, 'Twitter', ['tweet_id'],
['user_id'], [self.twitter_id])
await self.get_new_tweets(self.twitter_id, last_tweet_id)
logger.debug("Completed twitter background task.")
def get_server_time(guild_id):
result = select_one(TimeCog.conn, 'Settings', 'server', guild_id, pk_column='guild_id')
if result is None:
result = TimeCog.server_tz
return result
