async def roster(self, ctx, *args):
"""Show roster for all connected clans"""
manager = MessageManager(ctx)
clan_dbs = await self.bot.database.get_clans_by_guild(ctx.guild.id)
if not clan_dbs:
return await manager.send_and_clean("No connected clans found")
members = []
members_redis = await self.bot.ext_conns['redis_cache'].lrange(
f"{ctx.guild.id}-clan-roster", 0, -1)
if members_redis and '-nocache' not in args:
await self.bot.ext_conns['redis_cache'].expire(
f"{ctx.guild.id}-clan-roster", constants.TIME_HOUR_SECONDS)
for member in members_redis:
members.append(deserializer(member))
else:
members_db = await self.bot.database.get_clan_members(
[clan_db.clan_id for clan_db in clan_dbs],
sorted_by='username')
for member in members_db:
await self.bot.ext_conns['redis_cache'].rpush(
f"{ctx.guild.id}-clan-roster", serializer(member))
await self.bot.ext_conns['redis_cache'].expire(
f"{ctx.guild.id}-clan-roster", constants.TIME_HOUR_SECONDS)
members = members_db
entries = []
for member in members:
timezone = "Not Set"
if member.timezone:
tz = datetime.now(pytz.timezone(member.timezone))
timezone = f"{tz.strftime('UTC%z')} ({tz.tzname()})"
member_info = (
member.username,
f"Clan: {member.clanmember.clan.name} [{member.clanmember.clan.callsign}]\n"
f"Join Date: {date_as_string(member.clanmember.join_date)}\n"
f"Timezone: {timezone}")
entries.append(member_info)
p = FieldPages(ctx,
entries=entries,
per_page=5,
title="Roster for All Connected Clans",
color=constants.BLUE)
await p.paginate()
async def set_cached_members(ctx, guild_id, guild_name):
cache_key = f'{guild_id}-members'
redis_cache = ctx['redis_cache']
database = ctx['database']
members = []
member_dbs = await database.get_clan_members_by_guild_id(guild_id)
for member_db in member_dbs:
member_dict = model_to_dict(member_db.clanmember, recurse=False)
member_dict['member'] = model_to_dict(member_db, recurse=False)
members.append(member_dict)
members = serializer([member for member in members])
await redis_cache.set(cache_key,
members,
expire=constants.TIME_HOUR_SECONDS)
log.info(f"Successfully cached all members of {guild_name} ({guild_id})")
return members
async def create_redis_jobs_pool():
return await arq.create_pool(
config.arq_redis,
job_serializer=lambda b: serializer(b),
job_deserializer=lambda b: deserializer(b),
)
def job_serializer(b):
return serializer(b)
async def info(self, ctx, *args):
"""Show information for all connected clans"""
redis_cache = self.bot.ext_conns["redis_cache"]
manager = MessageManager(ctx)
clan_dbs = await self.bot.database.get_clans_by_guild(ctx.guild.id)
if not clan_dbs:
return await manager.send_and_clean(
"No connected clans found", mention=False
)
embeds = []
clan_redis_key = f"{ctx.guild.id}-clan-info"
clan_info_redis = await redis_cache.get(clan_redis_key)
if clan_info_redis and "-nocache" not in args:
log.debug(f"{clan_redis_key} {clan_info_redis}")
await redis_cache.expire(clan_redis_key, constants.TIME_HOUR_SECONDS)
embeds = [
discord.Embed.from_dict(embed)
for embed in deserializer(clan_info_redis)
]
else:
for clan_db in clan_dbs:
group = await execute_pydest(
self.bot.destiny.api.get_group,
clan_db.clan_id,
return_type=DestinyGroupResponse,
)
if not group.response:
log.error(
f"Could not get details for clan {clan_db.name} ({clan_db.clan_id}) - "
f"{group.error_status} {group.error_description}"
)
return await manager.send_and_clean(
f"Clan {clan_db.name} not found", mention=False
)
else:
group = group.response
embed = discord.Embed(
colour=constants.BLUE,
title=group.detail.motto,
description=group.detail.about,
)
embed.set_author(
name=f"{group.detail.name} [{group.detail.clan_info.clan_callsign}]",
url=f"https://www.bungie.net/en/ClanV2?groupid={clan_db.clan_id}",
)
embed.add_field(
name="Members", value=group.detail.member_count, inline=True
)
embed.add_field(
name="Founder",
value=group.founder.bungie_net_user_info.display_name,
inline=True,
)
embed.add_field(
name="Founded",
value=date_as_string(group.detail.creation_date),
inline=True,
)
embeds.append(embed)
await redis_cache.set(
clan_redis_key,
serializer([embed.to_dict() for embed in embeds]),
expire=constants.TIME_HOUR_SECONDS,
)
if len(embeds) > 1:
paginator = EmbedPages(ctx, embeds)
await paginator.paginate()
else:
await manager.send_embed(embeds[0])
async def create_application_embed(self, ctx, requestor_db, guild_db):
redis_cache = self.bot.ext_conns["redis_cache"]
if requestor_db.bungie_username:
membership_name = requestor_db.bungie_username
platform_id, membership_id, _ = get_primary_membership(requestor_db)
group_id = None
group_name = None
groups_info = await execute_pydest(
self.bot.destiny.api.get_groups_for_member,
platform_id,
membership_id,
return_type=DestinyMemberGroupResponse,
)
if len(groups_info.response.results) > 0:
for group in groups_info.response.results:
if group.member.destiny_user_info.membership_id == membership_id:
group_id = group.group.group_id
group_name = group.group.name
if group_id and group_name:
group_url = f"https://www.bungie.net/en/ClanV2/Index?groupId={group_id}"
group_link = f"[{group_name}]({group_url})"
else:
group_link = "None"
last_active = await get_last_active(
self.bot.ext_conns, platform_id=platform_id, member_id=membership_id
)
embed = discord.Embed(
colour=constants.BLUE,
title=f"Clan Application for {ctx.author.display_name}",
)
bungie_url = f"https://www.bungie.net/en/Profile/{platform_id}/{membership_id}"
bungie_link = f"[{membership_name}]({bungie_url})"
if requestor_db.discord_id:
member_discord = await commands.MemberConverter().convert(
ctx, str(requestor_db.discord_id)
)
discord_username = str(member_discord)
embed.add_field(name="Last Active Date", value=date_as_string(last_active))
embed.add_field(name="Bungie Username", value=bungie_link)
embed.add_field(name="Current Clan", value=group_link)
embed.add_field(name="Xbox Gamertag", value=requestor_db.xbox_username)
embed.add_field(name="PSN Username", value=requestor_db.psn_username)
embed.add_field(name="Steam Username", value=requestor_db.steam_username)
embed.add_field(name="Stadia Username", value=requestor_db.stadia_username)
embed.add_field(name="Discord Username", value=discord_username)
embed.set_footer(text="All times shown in UTC")
embed.set_thumbnail(url=str(ctx.author.avatar_url))
await redis_cache.set(
f"{ctx.guild.id}-clan-application-{requestor_db.id}", serializer(embed)
)
return embed