async def skiermod(self, ctx, *, mod: str = None):
if mod is None:
return await ctx.error("You need to provide a mod name")
route = Route(
'GET',
f'/mods'
)
try:
mods = await self.bot.http.sk1er.request(route)
except Exception:
return await ctx.error(f'Failed to fetch mods')
names = {}
for m in mods:
names[mods[m]['display'].lower()] = m
for mod_id in mods[m]['mod_ids']:
names[mod_id.lower()] = m
if mod.lower() not in names:
return await ctx.error(f'Unknown mod.')
else:
mod = mods[names[mod.lower()]]
route = Route(
'GET',
f'/mods_analytics'
)
try:
analytics = await self.bot.http.sk1er.request(route)
analytics = analytics.get(mod['mod_ids'][0], {})
except Exception:
return await ctx.error(f'Failed to fetch mod analytics')
embed = discord.Embed(
title=mod['display'],
colour=ctx.author.color,
url=f"https://sk1er.club/mods/{mod['mod_ids'][0]}",
description=mod['short'],
timestamp=datetime.datetime.utcnow()
)
embed.add_field(name="Versions", value='\n'.join([f'**{k}**: {v}' for k, v in mod['latest'].items()]), inline=False)
embed.add_field(name="Creator", value=f'''**__{mod['vendor']['name']}__**
[Website]({mod['vendor']['website']})
[Twitter]({mod['vendor']['twitter']})
[YouTube]({mod['vendor']['youtube']})
''', inline=False)
if analytics:
embed.add_field(name="Analytics", value=f"Total: {analytics['total']:,d}, Online: {analytics['online']:,d}, Last Day: {analytics['day']:,d}, Last Week: {analytics['week']:,d}", inline=False)
await ctx.send(embed=embed)
paginator = WrappedPaginator(prefix='', suffix='', max_size=490)
for mcv in mod['changelog']:
paginator.add_line(f'**__{mcv}__**')
for v in mod['changelog'][mcv]:
changelog = mod["changelog"][mcv][v][0]
time = datetime.datetime.utcfromtimestamp(changelog["time"] / 1000).strftime('%d/%m/%Y @ %I:%M:%S %p')
paginator.add_line(f'**{v}**: {changelog["text"]} ({time})')
paginator.add_line('-----------------')
embed = discord.Embed(color=ctx.author.color, title='Changelogs', timestamp=datetime.datetime.utcnow())
interface = PaginatorEmbedInterface(ctx.bot, paginator, owner=ctx.author, _embed=embed)
await interface.send_to(ctx)
async def cfstatus(self, ctx):
colors = {
'none': ctx.author.color,
'minor': discord.Color.gold(),
'major': discord.Color.orange(),
'critical': discord.Color.red(),
'maintenance': discord.Color.blue()
}
emoji = {
'operational': '<:operational:685538400639385649>',
'degraded_performance':
'<:degraded_performance:685538400228343808>',
'partial_outage': '<:partial_outage:685538400555499675>',
'major_outage': '<:major_outage:685538400639385706>',
'under_maintenance': '<:maintenance:685538400337395743>'
}
sroute = Route('GET', '/summary.json')
iroute = Route('GET', '/incidents.json')
try:
summary = await self.bot.http.cfstatus.request(sroute)
incidents = await self.bot.http.cfstatus.request(iroute)
except Exception:
return await ctx.error(f'Failed to fetch Cloudflare status')
# Cloudflare is a special little snowflake with a shit ton of compontents, too many for the embed description
paginator = WrappedPaginator(prefix='', suffix='', max_size=1980)
groups = {}
for c in [c for c in summary['components'] if c['group_id']]:
if c['status'] == 'operational':
continue
if c['group_id'] not in groups:
groups[c['group_id']] = [c]
else:
groups[c['group_id']].append(c)
for c in [c for c in summary['components'] if not c['group_id']]:
paginator.add_line(
f'├{emoji[c["status"]]} **{c["name"]}**: {c["status"].replace("_", " ").title()}'
)
for s in groups.get(c['id'], []):
paginator.add_line(
f'├─{emoji[s["status"]]} **{s["name"]}**: {s["status"].replace("_", " ").title()}'
)
embed = discord.Embed(color=colors[str(
summary['status']['indicator'])],
title=summary['status']['description'],
timestamp=datetime.datetime.utcnow())
incident = incidents['incidents'][0]
embed.add_field(
name='Latest Incident',
value=
f'[{incident["name"]}]({incident["shortlink"]})\nStatus: **{incident["status"].capitalize()}**'
)
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await interface.send_to(ctx)
async def on_member_remove(self, member):
if self.nitro in member.roles:
route = Route(
'GET',
f'/gists/{self.gist}'
)
try:
gist = await self.bot.http.github.request(route, headers=self.gistheaders)
except Exception:
self.bot.logger.error(
f'$REDFailed to fetch booster gist for $CYAN{member}')
return
text = gist.get('files', {}).get(
'boosters.json', {}).get('content', ['error'])
current = json.loads(text)
if 'error' in current:
return
try:
user = next(i for i in current if i["id"] == str(member.id))
mcuuid = user['uuid']
current.remove(user)
except Exception:
return
payload = {
'description': 'Nitro Booster dots for the Hyperium Client!',
'files': {
'boosters.json': {
'content': json.dumps(current, indent=2)
}
}
}
route = Route(
'GET',
f'/nitro/{mcuuid}/false'
)
try:
await self.bot.http.modcore.request(route, headers=self.modcoreheaders)
except Exception as e:
self.bot.logger.error(
f'$REDFailed to remove nitro perks for $CYAN{mcuuid}')
route = Route(
'PATCH',
f'/gists/{self.gist}'
)
try:
gist = await self.bot.http.github.request(
route,
json=payload,
headers=self.gistheaders
)
except Exception:
self.bot.logger.error(
f'$REDFailed to patch booster gist for $CYAN{mcuuid}')
return
general = self.guild.get_channel(411620457754787841)
await general.send(f'{member} left and their nitro perks have been removed.')
async def command(self, ctx):
colors = {
'none': ctx.author.color,
'minor': discord.Color.gold(),
'major': discord.Color.orange(),
'critical': discord.Color.red(),
'maintenance': discord.Color.blue()
}
emoji = {
'operational': '<:operational:685538400639385649>',
'degraded_performance': '<:degraded_performance:685538400228343808>',
'partial_outage': '<:partial_outage:685538400555499675>',
'major_outage': '<:major_outage:685538400639385706>',
'under_maintenance': '<:maintenance:685538400337395743>'
}
sroute = Route(
'GET',
'/summary.json'
)
iroute = Route(
'GET',
'/incidents.json'
)
try:
summary = await self.bot.http.firestatus.request(sroute)
incidents = await self.bot.http.firestatus.request(iroute)
except Exception:
return await ctx.error(f'Failed to fetch Fire status (but, as you can tell, I am online)')
desc = []
groups = {}
for c in [c for c in summary['components'] if c['group_id']]:
if c['group_id'] == 'jmsbww1qjnz5' and c['status'] == 'operational':
continue
if c['group_id'] not in groups:
groups[c['group_id']] = [c]
else:
groups[c['group_id']].append(c)
for c in [c for c in summary['components'] if not c['group_id']]:
desc.append(
f'├{emoji[c["status"]]} **{c["name"]}**: {c["status"].replace("_", " ").title()}')
for s in groups.get(c['id'], []):
desc.append(
f'├─{emoji[s["status"]]} **{s["name"]}**: {s["status"].replace("_", " ").title()}')
embed = discord.Embed(color=colors[str(summary['status']['indicator'])], title=summary['status']
['description'], timestamp=datetime.datetime.now(datetime.timezone.utc), description='\n'.join(desc))
incident = incidents['incidents'][0]
embed.add_field(name='Latest Incident',
value=f'[{incident["name"]}]({incident["shortlink"]})\nStatus: **{incident["status"].capitalize()}**', inline=False)
maintenance = summary.get('scheduled_maintenances', [])
if len(maintenance) >= 1:
maintenance = maintenance[0]
embed.add_field(name='Scheduled Maintenance',
value=f'[{maintenance["name"]}]({maintenance["shortlink"]})\nStatus: **{maintenance["status"].replace("_", " ").capitalize()}**', inline=False)
await ctx.send(embed=embed)
async def token_gist(self, tokens, message):
files = {}
for t in tokens:
now = datetime.datetime.now(datetime.timezone.utc).timestamp()
files[f'token_leak_{now}.md'] = {'content':f'''
Oh no, it seems a token has been leaked! Fire (Fire#0682) scans for tokens in Discord messages and uploads them to GitHub to be reset.
You can learn more about GitHub's token scanning at https://help.github.com/en/github/administering-a-repository/about-token-scanning
The token in question was found in a message sent by {message.author} in the channel #{message.channel} in the guild {message.guild}.
Here's the link to the message: {message.jump_url}
The token in question *was* {t}
Discord should send the owner of this bot a system message letting them know their token has been leaked pretty much instantly.
If you are the owner of said bot, you should look into how this happened and try prevent it in the future!
Examples of how you can protect your token is by using a config file or environment variables.
This ensures the token is not directly in your code.
If you have an eval command, make sure only **you** can use it
I hope you keep your token safe in the future :)
If you have any queries about this gist, feel free to email [email protected] or leave a comment.
'''}
body = {
'description': '',
'public': True,
'files': files
}
route = Route(
'POST',
f'/gists'
)
try:
gist = await self.bot.http.github.request(
route,
json=body,
headers=self.gistheaders
)
await asyncio.sleep(30)
route = Route(
'DELETE',
f'/gists/{gist["id"]}'
)
await self.bot.http.github.request(
route,
headers=self.gistheaders
)
except Exception as e:
self.bot.logger.warn(f'$YELLOWFailed to create gist for tokens!', exc_info=e)
async def post_guilds(self):
route = Route('POST', f'/bot/{self.bot.user.id}')
await self.http.request(route,
json={'server_count': len(self.bot.guilds)})
self.bot.logger.info(
f'$GREENPosted guild count $CYAN({len(self.bot.guilds)}) $GREENto $CYANdiscord.boats'
)
async def request_fetch(self):
route = Route('PUT', '/fetch')
try:
await self.bot.http.invwtf.request(route)
except Exception as e:
self.bot.logger.warn(f'$YELLOWFailed to request vanity url fetch',
exc_info=e)
async def get_status(self, cid: str):
route = Route(
'GET',
f'/pages/fhrcp0477jwt/components/{cid}'
)
component = await self.bot.http.statuspage.request(route)
return component['status']
async def mods(self, ctx, *, ign: str):
if ctx.channel.id != 577203509863251989:
return await ctx.error(
f'You must run this command in <#577203509863251989>')
mid = await self.name_to_uuid(ign)
if not mid:
return await ctx.error(f'Player not found')
route = Route('GET', f'/user_mods/{ign}')
try:
modlist = await self.bot.http.sk1er.request(
route, headers=self.modcoreheaders)
except Exception as e:
return await ctx.error(f'Failed to retrieve mods for {ign}')
[
modlist.remove(m) for m in ['mcp', 'forge', 'fml', 'modcore']
if m in modlist
]
[
modlist.remove(m) for m in modlist
if m in self.modconf['blacklisted_mods']
]
if not modlist:
return await ctx.error(f'No mods found for {ign}')
embed = discord.Embed(
color=ctx.author.color,
timestamp=datetime.datetime.now(datetime.timezone.utc)).set_author(
name=ign,
icon_url=f'https://crafatar.com/avatars/{mid}?overlay=true'
).add_field(name='» Mods', value=', '.join(modlist), inline=False)
return await ctx.send(embed=embed)
async def get_bots(self, **kwargs):
params = ['limit', 'offset', 'search', 'sort', 'fields']
for k in kwargs:
if k not in params:
kwargs.pop(k)
route = Route('GET', f'/bots')
bots = await self.http.request(route, params=kwargs)
return bots
async def avideo_info(self, vid: str):
params = {'part': 'snippet,contentDetails,statistics', 'id': vid}
route = Route(
'GET',
'/videos',
)
response = await self.bot.http.youtube.request(route, params=params)
return [v for v in response.get('items', [])]
async def get_votes(self):
route = Route(
'GET',
f'/bots/{self.bot.user.id}/votes'
)
votes = await self.http.request(
route
)
return votes
async def get_vanity(self, code: str):
route = Route(
'GET',
f'/api/{code}'
)
try:
return await self.bot.http.invwtf.request(route)
except Exception as e:
return False
async def is_weekend(self):
route = Route(
'GET',
f'/weekend'
)
weekend = await self.http.request(
route
)
return weekend.get('is_weekend', False)
async def get_stats(self, bot: int):
route = Route(
'GET',
f'/bots/{bot}/stats'
)
stats = await self.http.request(
route
)
return stats
async def get_bot(self, bot: int):
route = Route(
'GET',
f'/bots/{bot}'
)
bot = await self.http.request(
route
)
return bot
async def check_vote(self, user: int):
route = Route(
'GET',
f'/bots/{self.bot.user.id}/check'
)
vote = await self.http.request(
route,
params={'userId':user}
)
return bool(vote.get('voted', 0))
async def description_updater(self):
try:
session = aiohttp.ClientSession()
m = (await self.bot.http.sk1er.request(Route('GET', '/mods_analytics')))['combined_total']
m += (await (await session.get('https://api.autotip.pro/counts')).json())['total']
m += (await (await session.get('https://api.hyperium.cc/users')).json())['all']
await session.close()
await self.guild.edit(description=f'The Official Discord for Sk1er & Sk1er Mods ({m:,d} total players)')
except Exception:
pass
async def check_vote(self, user: int):
route = Route(
'GET',
f'/bot/{self.bot.user.id}/voted'
)
vote = await self.http.request(
route,
params={'id': user}
)
return vote
async def set_status(self, cid: str, status: str = 'operational'):
self.bot.logger.warn(
f'$YELLOWSetting status for $CYAN{cid} $YELLOWto $CYAN{status}')
route = Route('PATCH', f'/pages/fhrcp0477jwt/components/{cid}')
payload = {
"component": {
"status": status,
}
}
await self.bot.http.statuspage.request(route, json=payload)
async def achannel_info(self, channel: str):
params = {'part': 'snippet,contentDetails,statistics'}
if channel.startswith('UC'):
params.update({'id': channel})
else:
params.update({'forUsername': channel})
route = Route(
'GET',
'/channels',
)
response = await self.bot.http.youtube.request(route, params=params)
return response
async def name_to_uuid(self, player: str):
try:
self.uuidcache[player]
except KeyError:
route = Route('GET', f'/users/profiles/minecraft/{player}')
try:
profile = await self.bot.http.mojang.request(route)
if profile:
self.uuidcache.update({player: profile['id']})
except Exception:
pass # whatever is using this should check for None
return self.uuidcache.get(player, None)
async def apopular(self):
params = {
'part': 'snippet,contentDetails,statistics',
'chart': 'mostPopular',
'maxResults': '5',
'regionCode': 'US'
}
route = Route(
'GET',
'/videos',
)
response = await self.bot.http.youtube.request(route, params=params)
videos = [v for v in response.get('items', [])]
return videos
async def haste(self, content, fallback: bool = False):
route = Route('POST', '/documents')
client = self.http.hst
if fallback:
client = self.http.hinvwtf
try:
h = await client.request(route, data=content)
return f'{client.BASE_URL}/' + h['key']
except Exception as e:
if not fallback:
return await self.haste(content, fallback=True)
self.logger.warn(
f'$REDFailed to create haste on $CYAN{client.BASE_URL}/',
exc_info=e)
return 'Failed to create haste'
async def modcore(self, ctx, player: str = None):
if player is None:
return await ctx.error(
"You must provide a player to check their profile")
uuid = await self.bot.get_cog('Hypixel Commands').name_to_uuid(player)
if not uuid:
raise commands.UserInputError('Couldn\'t find that player\'s UUID')
route = Route('GET', f'/profile/{uuid}')
try:
profile = await self.bot.http.modcore.request(route)
except Exception:
return await ctx.error(f'Failed to fetch profile')
purchases = [
self.modcoref(c) for c, e in profile.get('purchase_profile', {
'No Cosmetics': True
}).items() if e
]
for c, s in profile.get('cosmetic_settings', {}).items():
if s != {} and s.get('enabled', False):
if 'STATIC' in c:
cid = s['id']
purchases = [
p.replace(
self.modcoref(c),
f'**[{self.modcoref(c)}](https://api.modcore.sk1er.club/serve/cape/static/{cid})**'
) for p in purchases
]
elif 'DYNAMIC' in c:
cid = s['id']
purchases = [
p.replace(
self.modcoref(c),
f'**[{self.modcoref(c)}](https://api.modcore.sk1er.club/serve/cape/dynamic/{cid})**'
) for p in purchases
]
purchases = ', '.join([i for i in purchases])
embed = discord.Embed(title=f'{player}\'s Modcore Profile',
color=ctx.author.color)
embed.add_field(name='Name', value=player, inline=False)
embed.add_field(name='UUID', value=uuid, inline=False)
embed.add_field(name='Enabled Cosmetics',
value=purchases or 'No Cosmetics',
inline=False)
return await ctx.send(embed=embed)
async def on_member_update(self, before, after):
if not after.guild or after.guild.id != self.guild.id:
return
if before.roles != after.roles:
sk1roles = [
discord.utils.get(self.guild.roles, id=585534346551754755),
discord.utils.get(self.guild.roles, id=436306157762773013),
discord.utils.get(self.guild.roles, id=698943379181928520)
]
if not any(r for r in sk1roles if r in after.roles):
if not self.bot.isascii(after.nick or after.name) or self.bot.ishoisted(after.nick or after.name):
await after.edit(nick=self.bot.get_config(self.guild.id).get('utils.badname') or f'John Doe {after.discriminator}')
broles = []
aroles = []
changed = []
for role in before.roles:
broles.append(role)
for role in after.roles:
aroles.append(role)
s = set(aroles)
removed = [x for x in broles if x not in s]
if self.nitro in removed:
route = Route(
'GET',
f'/gists/{self.gist}'
)
try:
gist = await self.bot.http.github.request(
route,
headers=self.gistheaders
)
except Exception:
self.bot.logger.error(
f'$REDFailed to get booster gist for $CYAN{after}')
return
text = gist.get('files', {}).get(
'boosters.json', {}).get('content', ['error'])
current = json.loads(text)
if 'error' in current:
return
try:
user = next(i for i in current if i["id"] == str(after.id))
mcuuid = user['uuid']
current.remove(user)
except Exception:
return
route = Route(
'GET',
f'/nitro/{mcuuid}/false'
)
try:
await self.bot.http.modcore.request(route, headers=self.modcoreheaders)
except Exception as e:
self.bot.logger.error(
f'$REDFailed to remove modcore nitro perks for $CYAN{mcuuid}')
payload = {
'description': 'Nitro Booster dots for the Hyperium Client!',
'files': {
'boosters.json': {
'content': json.dumps(current, indent=2)
}
}
}
route = Route(
'PATCH',
f'/gists/{self.gist}'
)
try:
gist = await self.bot.http.github.request(
route,
json=payload,
headers=self.gistheaders
)
except Exception:
self.bot.logger.error(
f'$REDFailed to patch booster gist for $CYAN{mcuuid}')
return
general = self.guild.get_channel(411620457754787841)
await general.send(f'{after.mention} Your nitro perks have been removed. Boost the server to get them back :)',
allowed_mentions=discord.AllowedMentions(
users=True)
)
async def nitroperks(self, ctx, ign: str = None):
if self.nitro not in ctx.author.roles and self.testrole not in ctx.author.roles:
return await ctx.send('no')
if not ign:
return await ctx.error('You must provide your Minecraft name!')
mid = await self.bot.get_cog('Hypixel Commands').name_to_uuid(ign)
if not mid:
return await ctx.error('No UUID found!')
progress = await ctx.send('Give me a moment.')
route = Route('GET', f'/gists/{self.gist}')
try:
gist = await self.bot.http.github.request(route,
headers=self.gistheaders)
except Exception:
return await progress.edit(
content=
'<:xmark:674359427830382603> Something went wrong when getting the list of boosters'
)
text = gist.get('files', {}).get('boosters.json',
{}).get('content', ['error'])
current = json.loads(text)
if 'error' in current:
return await progress.edit(
content=
'<:xmark:674359427830382603> Something went wrong when getting the list of boosters'
)
try:
user = next(i for i in current if i["id"] == str(ctx.author.id))
route = Route('GET', f'/nitro/{user["uuid"]}/false')
try:
await self.bot.http.modcore.request(
route, headers=self.modcoreheaders)
except Exception as e:
return await progress.edit(
f'<:xmark:674359427830382603> Failed to remove perks from previous user, {user["ign"]}'
)
current.remove(user)
user['uuid'] = str(uuid.UUID(mid))
user['ign'] = ign
except Exception:
user = {
"uuid": str(uuid.UUID(mid)),
"ign": ign,
"id": str(ctx.author.id),
"color": "LIGHT_PURPLE"
}
current.append(user)
route = Route('GET', f'/nitro/{user["uuid"]}/true')
try:
await self.bot.http.modcore.request(route,
headers=self.modcoreheaders)
except Exception as e:
self.bot.logger.warn(f'$YELLOWFailed to give perks on modcore',
exc_info=e)
await ctx.error(f'Failed to give perks on modcore.')
payload = {
'description': 'Nitro Booster dots for the Hyperium Client!',
'files': {
'boosters.json': {
'content': json.dumps(current, indent=2)
}
}
}
route = Route('PATCH', f'/gists/{self.gist}')
try:
gist = await self.bot.http.github.request(route,
json=payload,
headers=self.gistheaders)
except Exception:
return await ctx.error('Failed to give you the perks in Hyperium')
return await progress.edit(
content=
'<:check:674359197378281472> Successfully gave you the perks!')
async def on_member_update(self, before, after):
if self.testrole in after.roles and after.id != 287698408855044097:
await after.remove_roles(self.testrole, reason='not geek')
if before.roles != after.roles:
broles = []
aroles = []
changed = []
for role in before.roles:
broles.append(role)
for role in after.roles:
aroles.append(role)
s = set(aroles)
removed = [x for x in broles if x not in s]
if self.nitro in removed or (self.testrole in removed
and after.id == 287698408855044097):
if not self.bot.isascii(after.nick
or after.name) or self.bot.ishoisted(
after.nick or after.name):
await after.edit(nick=f'John Doe {after.discriminator}')
route = Route('GET', f'/gists/{self.gist}')
try:
gist = await self.bot.http.github.request(
route, headers=self.gistheaders)
except Exception:
self.bot.logger.error(
f'$REDFailed to get booster gist for $CYAN{after}')
return
text = gist.get('files', {}).get('boosters.json',
{}).get('content', ['error'])
current = json.loads(text)
if 'error' in current:
return
try:
user = next(i for i in current if i["id"] == str(after.id))
mcuuid = user['uuid']
current.remove(user)
except Exception:
return
route = Route('GET', f'/nitro/{mcuuid}/false')
try:
await self.bot.http.modcore.request(
route, headers=self.modcoreheaders)
except Exception as e:
self.bot.logger.error(
f'$REDFailed to remove modcore nitro perks for $CYAN{mcuuid}'
)
payload = {
'description':
'Nitro Booster dots for the Hyperium Client!',
'files': {
'boosters.json': {
'content': json.dumps(current, indent=2)
}
}
}
route = Route('PATCH', f'/gists/{self.gist}')
try:
gist = await self.bot.http.github.request(
route, json=payload, headers=self.gistheaders)
except Exception:
self.bot.logger.error(
f'$REDFailed to patch booster gist for $CYAN{mcuuid}')
return
general = self.guild.get_channel(411620457754787841)
await general.send(
f'{after.mention} Your nitro perks have been removed. Boost the server to get them back :)'
)
async def hypixel(self, ctx, arg1: str = None, arg2: str = None):
if arg1 is None:
return await ctx.send("I need an IGN or `watchdog`",
delete_after=5)
arg1 = arg1.lower().replace('-', '')
if arg2:
arg2 = arg2.lower()
if arg1.lower() == "watchdog":
route = Route('GET', '/watchdogstats')
watchdog = await self.bot.http.hypixel.request(route)
color = ctx.author.color
embed = discord.Embed(title="Watchdog Stats",
colour=color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
embed.set_thumbnail(
url="https://hypixel.net/attachments/cerbtrimmed-png.245674/")
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(name="Watchdog Bans in the last minute",
value=watchdog['watchdog_lastMinute'],
inline=False)
embed.add_field(name="Staff bans in the last day",
value=format(watchdog['staff_rollingDaily'], ',d'),
inline=False)
embed.add_field(name="Watchdog bans in the last day",
value=format(watchdog['watchdog_rollingDaily'],
',d'),
inline=False)
embed.add_field(name="Staff Total Bans",
value=format(watchdog['staff_total'], ',d'),
inline=False)
embed.add_field(name="Watchdog Total Bans",
value=format(watchdog['watchdog_total'], ',d'),
inline=False)
return await ctx.send(embed=embed)
elif arg1.lower() == 'skyblock':
if not arg2 or arg2 == 'news':
route = Route('GET', '/skyblock/news')
sbnews = await self.bot.http.hypixel.request(route)
paginator = WrappedPaginator(prefix='',
suffix='',
max_size=250)
for entry in sbnews['items']:
paginator.add_line(
f'[{entry["title"]}]({entry["link"]})\n{entry["text"]}\n'
)
embed = discord.Embed(color=ctx.author.color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
return await interface.send_to(ctx)
if arg2 is None:
channel = ctx.message.channel
color = ctx.author.color
async with channel.typing():
try:
player = hypixel.Player(arg1)
except hypixel.PlayerNotFoundException:
raise commands.ArgumentParsingError(
'Couldn\'t find that player...')
except AttributeError:
raise commands.ArgumentParsingError(
'Couldn\'t find that player...')
p = player.JSON
tributes = p.get('tourney', {}).get('total_tributes',
0) # TOURNAMENT TRIBUTES
level = str(player.getLevel()).split('.')[0]
lastlogin = p.get('lastLogin', 0)
lastlogout = p.get('lastLogout', 1)
if lastlogin > lastlogout:
status = "Online!"
else:
status = "Offline!"
tag = None
route = Route('GET', f'/guild/player/{player.UUID}')
guild = await self.bot.http.sk1er.request(route)
if guild.get('success', False):
guild = guild['guild']
tag = guild['tag'] if 'tag' in guild else None
if tag:
tagcolor = guild[
'tagColor'] if 'tagColor' in guild else 'GRAY'
if tagcolor == 'GRAY' or tagcolor == 'GREY':
tag = f'§7[{tag}]'
elif tagcolor == 'GOLD':
tag = f'§6[{tag}]'
elif tagcolor == 'DARK_GREEN':
tag = f'§2[{tag}]'
elif tagcolor == 'YELLOW':
tag = f'§e[{tag}]'
elif tagcolor == 'DARK_AQUA':
tag = f'§3[{tag}]'
if not tag:
tag = f'§7[{tag}]'
route = Route('GET', f'/player/{player.UUID}')
apiplayer = await self.bot.http.sk1er.request(route)
if apiplayer['success']:
try:
nametag = apiplayer['player']['playerdisplay'].replace(
'§0YOUTUBE', '§fYOUTUBE'
) if 'playerdisplay' in apiplayer else apiplayer[
'player']['display'].replace(
'§0YOUTUBE', '§fYOUTUBE')
except Exception:
displayname = p['displayname']
nametag = f'§f{displayname}'
if tag:
nametag = f'{nametag} {tag}'
if nametag:
parsedtxt = mcfont.parse(nametag)
width = mcfont.get_width(parsedtxt)
img = Image.new('RGBA', (width + 25, 42))
mcfont.render((5, 0), parsedtxt, img)
buf = BytesIO()
img.save(buf, format='PNG')
buf.seek(0)
customtag = discord.File(buf,
'imaginereadingthefilename.png')
if arg2 is None:
msg = await ctx.send(
f"Retrieving {discord.utils.escape_mentions(discord.utils.escape_markdown(p['displayname']))}'s info..."
)
uuid = player.UUID
embed = discord.Embed(
title=
f"{discord.utils.escape_markdown(p['displayname'])}'s Info",
colour=color,
timestamp=datetime.datetime.now(datetime.timezone.utc))
if nametag:
embed.set_image(
url=f'attachment://imaginereadingthefilename.png')
embed.set_thumbnail(
url=f"https://crafatar.com/avatars/{uuid}?overlay=true"
)
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
embed.add_field(name="Online Status",
value=status,
inline=True)
language = p.get('userLanguage', 'Not Set')
embed.add_field(name="Language",
value=language,
inline=True)
channel = p.get('channel', 'ALL')
embed.add_field(name="Chat Channel",
value=channel,
inline=True)
embed.add_field(name="Level", value=level, inline=True)
embed.add_field(name="Karma",
value=format(p.get('karma', 0), ',d'),
inline=True)
if 'twitter' not in ctx.config.get('mod.linkfilter'):
twitter = p.get('socialMedia',
{}).get('TWITTER', 'Not Set')
else:
twitter = 'Hidden'
if 'youtube' not in ctx.config.get('mod.linkfilter'):
yt = p.get('socialMedia',
{}).get('links',
{}).get('YOUTUBE', 'Not Set')
else:
yt = 'Hidden'
insta = p.get('socialMedia',
{}).get('INSTAGRAM', 'Not Set')
if 'twitch' not in ctx.config.get('mod.linkfilter'):
twitch = p.get('socialMedia',
{}).get('TWITCH', 'Not Set')
else:
twitch = 'Hidden'
beam = p.get('socialMedia', {}).get('BEAM', 'Not Set')
if 'discord' not in ctx.config.get('mod.linkfilter'):
dscrd = p.get('socialMedia',
{}).get('links',
{}).get('DISCORD', 'Not Set')
else:
dscrd = 'Hidden'
embed.add_field(
name="Social Media",
value=
f"Twitter: {twitter}\nYouTube: {yt}\nInstagram: {insta}\nTwitch: {twitch}\nBeam: {beam}\nDiscord: {dscrd}",
inline=False)
if tributes != 0:
embed.add_field(name="Tournament Tributes",
value=tributes,
inline=False)
if customtag:
await msg.delete()
await ctx.send(embed=embed, file=customtag)
else:
await msg.edit(content=None, embed=embed)
elif arg2 == 'friends':
uuid = await self.name_to_uuid(arg1)
if not uuid:
return await ctx.error(f'Couldn\'t find that player')
route = Route('GET', f'/friends/{uuid}')
friends = await self.bot.http.sk1er.request(route)
paginator = WrappedPaginator(
prefix=f'''-----------------------------------------------------
Friends ({len(friends)}) >>''',
suffix='-----------------------------------------------------',
max_size=512)
for uuid in friends:
friend = friends[uuid]
try:
name = re.sub(remcolor, '', friend['display'], 0,
re.IGNORECASE)
time = str(
datetime.datetime.fromtimestamp(
friend['time'] / 1000,
datetime.timezone.utc)).split('.')[0]
except TypeError:
raise commands.ArgumentParsingError(
'Couldn\'t find that persons friends. Check the name and try again'
)
return
paginator.add_line(
discord.utils.escape_markdown(f'{name} added on {time}'))
embed = discord.Embed(color=ctx.author.color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=embed)
await interface.send_to(ctx)
elif arg2 == 'guild':
uuid = await self.name_to_uuid(arg1)
if not uuid:
return await ctx.error(f'Couldn\'t find that player')
route = Route('GET', f'/guild/player/{uuid}')
guild = await self.bot.http.sk1er.request(route)
if guild['success'] != True:
raise commands.ArgumentParsingError(
'Couldn\'t find a guild. Maybe they aren\'t in one...')
guild = guild['guild']
embed = discord.Embed(colour=ctx.author.color,
timestamp=datetime.datetime.now(
datetime.timezone.utc))
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some"
)
gtagcolor = guild.get('tagColor',
'GRAY').lower().replace('_',
' ').capitalize()
gtag = guild.get('tag', '')
if gtag:
gtag = f'[{gtag}] ({gtagcolor})'
desc = guild.get('description', 'No Description Set.')
embed.add_field(
name=f"{arg1}'s guild",
value=
f"{guild['name']} {gtag}\n{desc}\n\nLevel: {guild['level_calc']}"
)
embed.add_field(name="Joinable?",
value=guild.get('joinable', 'False'),
inline=False)
embed.add_field(name="Publicly Listed?",
value=guild.get('publiclyListed', 'False'),
inline=False)
embed.add_field(name="Legacy Rank",
value=format(guild.get('legacyRanking', -1), ',d'),
inline=False)
games = []
for game in guild.get('preferredGames', ['this is a placeholder']):
games.append(picklegames.get(game, 'Preferred Games not set.'))
embed.add_field(name="Preferred Games",
value=', '.join(games)
if games else 'Preferred Games not set.',
inline=False)
ranks = []
for rank in guild.get('ranks', {
'name': 'No custom ranks',
'tag': ''
}):
name = rank['name']
if not rank.get('tag', ''):
tag = ''
else:
tag = rank['tag']
tag = f'[{tag}]'
ranks.append(f'{name} {tag}')
embed.add_field(
name="Ranks",
value='\n'.join(ranks) if ranks else 'No custom ranks',
inline=False)
await ctx.send(embed=embed)
gname = guild['name']
paginatorembed = discord.Embed(
title=f'{gname}\'s Members ({len(guild["members"])})',
color=ctx.author.color,
timestamp=datetime.datetime.now(datetime.timezone.utc))
ranktags = {}
for rank in ranks:
ranktags[rank.split(' ')[0]] = rank.split(' ')[1]
paginator = WrappedPaginator(prefix='', suffix='', max_size=380)
for member in guild['members']:
name = re.sub(
remcolor, '',
member.get('displayname',
member.get('name', 'Unknown Player')), 0,
re.IGNORECASE)
joined = str(
datetime.datetime.fromtimestamp(
member['joined'] / 1000,
datetime.timezone.utc)).split('.')[0]
try:
ranktag = ranktags[member['rank']]
except KeyError:
ranktag = ''
if ranktag != '':
paginator.add_line(f'{name} {ranktag} joined on {joined}')
else:
paginator.add_line(f'{name} joined on {joined}')
interface = PaginatorEmbedInterface(ctx.bot,
paginator,
owner=ctx.author,
_embed=paginatorembed)
await interface.send_to(ctx)
async def levelhead(self, ctx, player: str = None):
if player is None:
return await ctx.send("What user should I check?")
route = Route('GET', f'/levelheadv5/{player}/LEVEL')
try:
levelhead = await self.bot.http.sk1er.request(route)
except Exception:
return await ctx.error(f'Failed to fetch levelhead info')
uuid = levelhead.get('uuid', '')
if not uuid:
strlevel = levelhead['strlevel']
try:
hcolor = levelhead['header_obj']['color']
fcolor = levelhead['footer_obj']['color']
except KeyError:
hcolor = '§b'
fcolor = '§e'
embed = discord.Embed(
title=f"{player}'s Levelhead",
colour=ctx.author.color,
url="https://purchase.sk1er.club/category/1050972",
timestamp=datetime.datetime.now(datetime.timezone.utc),
description=f'Level: {levelhead["level"]}')
return await ctx.send(embed=embed)
if len(uuid) < 28:
return await ctx.error(
'Malformed UUID. Check the spelling of the player\'s name')
route = Route('GET', f'/levelhead_purchase_status/{uuid}')
try:
purchase = await self.bot.http.sk1er.request(route)
except Exception:
return await ctx.error(f'Failed to fetch levelhead purchase status'
)
async with aiohttp.ClientSession() as session:
async with session.get(
f'https://api.hyperium.cc/levelhead_propose/{uuid}'
) as resp:
await session.close()
try:
proposal = await resp.json()
except Exception:
proposal = None
header = re.sub(remcolor, '', levelhead.get('header', 'Level'), 0,
re.IGNORECASE)
strlevel = re.sub(remcolor, '', levelhead['strlevel'], 0,
re.IGNORECASE)
level = levelhead['level']
nocustom = True if header == "Level" else False
tab = 'Purchased!' if purchase.get('tab', False) else 'Not Purchased'
chat = 'Purchased!' if purchase.get('chat', False) else 'Not Purchased'
head = purchase['head']
embed = discord.Embed(
title=f"{player}'s Levelhead",
colour=ctx.author.color,
url="https://purchase.sk1er.club/category/1050972",
timestamp=datetime.datetime.now(datetime.timezone.utc))
embed.set_footer(
text=
"Want more integrations? Use the suggest command to suggest some")
if nocustom:
embed.add_field(name="IGN", value=player, inline=False)
embed.add_field(name="Levelhead",
value=f"Level: {levelhead['level']}",
inline=False)
embed.add_field(
name="Other items",
value=f"Tab: {tab} \nChat: {chat} \nAddon Head Layers: {head}",
inline=False)
else:
embed.add_field(name="Custom Levelhead?",
value="Yeah!",
inline=False)
embed.add_field(name="IGN", value=player, inline=False)
embed.add_field(name="Levelhead",
value=f"{header}:{strlevel}",
inline=False)
if proposal and 'header_obj' not in proposal:
nheader = re.sub(remcolor, '', proposal['header'], 0,
re.IGNORECASE)
nstrlevel = re.sub(remcolor, '', proposal['strlevel'], 0,
re.IGNORECASE)
embed.add_field(name='Proposed Levelhead',
value=f'{nheader}:{nstrlevel}',
inline=False)
embed.add_field(name='Denied?',
value=proposal['denied'],
inline=False)
embed.add_field(
name="Other items",
value=f"Tab: {tab} \nChat: {chat} \nAddon Head Layers: {head}",
inline=False)
return await ctx.send(embed=embed)
