def clear_infractions(self):
expired = list(Infraction.select().where((Infraction.active == 1) & (
Infraction.expires_at < datetime.utcnow())))
for item in expired:
guild = self.state.guilds.get(item.guild_id)
if not guild:
continue
# TODO: hacky
type_ = {i.index: i for i in Infraction.Types.attrs}[item.type_]
if type_ == Infraction.Types.TEMPBAN:
# TODO: debounce
guild.delete_ban(item.user_id)
elif type_ == Infraction.Types.TEMPMUTE:
member = guild.get_member(item.user_id)
if member:
if item.metadata['role'] in member.roles:
member.remove_role(item.metadata['role'])
else:
GuildMemberBackup.remove_role(item.guild_id, item.user_id,
item.metadata['role'])
# TODO: n+1
item.active = False
item.save()
self.queue_infractions()
def infractions_archive(self, event):
user = User.alias()
actor = User.alias()
q = Infraction.select(Infraction, user, actor).join(
user,
on=((Infraction.user_id == user.user_id).alias('user'))
).switch(Infraction).join(
actor,
on=((Infraction.actor_id == actor.user_id).alias('actor'))
).where(Infraction.guild_id == event.guild.id)
buff = StringIO()
w = csv.writer(buff)
for inf in q:
w.writerow([
inf.id,
inf.user_id,
unicode(inf.user).encode('utf-8'),
inf.actor_id,
unicode(inf.actor).encode('utf-8'),
unicode({i.index: i for i in Infraction.Types.attrs}[inf.type_]).encode('utf-8'),
unicode(inf.reason).encode('utf-8'),
])
event.msg.reply('Ok, here is an archive of all infractions', attachments=[
('infractions.csv', buff.getvalue())
])
def infraction_search(self, event, query=None):
q = (Infraction.guild_id == event.guild.id)
if query and isinstance(query, list) and isinstance(
query[0], DiscoUser):
query = query[0].id
elif query:
query = ' '.join(query)
if query and (isinstance(query, int) or query.isdigit()):
q &= ((Infraction.id == int(query)) |
(Infraction.user_id == int(query)) |
(Infraction.actor_id == int(query)))
elif query:
q &= (Infraction.reason**query)
user = User.alias()
actor = User.alias()
infractions = Infraction.select(Infraction, user, actor).join(
user, on=((Infraction.user_id == user.user_id).alias('user')
)).switch(Infraction).join(
actor,
on=((Infraction.actor_id == actor.user_id
).alias('actor'))).where(q).order_by(
Infraction.created_at.desc()).limit(6)
tbl = MessageTable()
tbl.set_header('ID', 'Created', 'Type', 'User', 'Moderator', 'Active',
'Reason')
last_tbl_str = None
for inf in infractions:
type_ = {i.index: i for i in Infraction.Types.attrs}[inf.type_]
reason = inf.reason or ''
if len(reason) > 256:
reason = reason[:256] + '...'
if inf.active:
active = 'yes'
if inf.expires_at:
active += ' (expires in {})'.format(
humanize.naturaldelta(inf.expires_at -
datetime.utcnow()))
else:
active = 'no'
tbl.add(inf.id, inf.created_at.isoformat(), str(type_),
unicode(inf.user), unicode(inf.actor), active,
clamp(reason, 128))
tbl_str = tbl.compile()
if len(tbl_str) >= 2000:
break
last_tbl_str = tbl_str
event.msg.reply(last_tbl_str or "No infractions found.")
def queue_infractions(self):
next_infraction = list(Infraction.select().where(
(Infraction.active == 1) &
(~(Infraction.expires_at >> None))
).order_by(Infraction.expires_at.asc()).limit(1))
if not next_infraction:
self.log.info('[INF] no infractions to wait for')
return
self.log.info('[INF] waiting until %s for %s', next_infraction[0].expires_at, next_infraction[0].id)
self.inf_task.set_next_schedule(next_infraction[0].expires_at)
def infraction_info(self, event, infraction):
try:
user = User.alias()
actor = User.alias()
infraction = Infraction.select(Infraction, user, actor).join(
user, on=((Infraction.user_id == user.user_id).alias('user'))
).switch(Infraction).join(
actor,
on=((Infraction.actor_id == actor.user_id).alias('actor')
)).where((Infraction.id == infraction)
& (Infraction.guild_id == event.guild.id)).get()
except Infraction.DoesNotExist:
raise CommandFail(
'cannot find an infraction with ID `{}`'.format(infraction))
type_ = {i.index: i for i in Infraction.Types.attrs}[infraction.type_]
embed = MessageEmbed()
if type_ in (Infraction.Types.MUTE, Infraction.Types.TEMPMUTE,
Infraction.Types.TEMPROLE):
embed.color = 0xfdfd96
elif type_ in (Infraction.Types.KICK, Infraction.Types.SOFTBAN):
embed.color = 0xffb347
else:
embed.color = 0xff6961
embed.title = str(type_).title()
embed.set_thumbnail(url=infraction.user.get_avatar_url())
embed.add_field(name='User',
value=unicode(infraction.user),
inline=True)
embed.add_field(name='Moderator',
value=unicode(infraction.actor),
inline=True)
embed.add_field(name='Active',
value='yes' if infraction.active else 'no',
inline=True)
if infraction.active and infraction.expires_at:
embed.add_field(name='Expires',
value=humanize.naturaldelta(infraction.expires_at -
datetime.utcnow()))
embed.add_field(name='Reason',
value=infraction.reason or '_No Reason Given',
inline=False)
embed.timestamp = infraction.created_at.isoformat()
event.msg.reply('', embed=embed)
def queue_infractions(self):
next_infraction = list(Infraction.select().where(
(Infraction.active == 1)
& (~(Infraction.expires_at >> None))).order_by(
Infraction.expires_at.asc()).limit(1))
if not next_infraction:
self.log.info('[INF] no infractions to wait for')
return
wait_until = next_infraction[0].expires_at
wait_until_barrier = datetime.utcnow() + timedelta(seconds=10)
if wait_until < wait_until_barrier:
self.log.info('[INF] wait until %s is already past!', wait_until)
wait_until = wait_until_barrier
self.log.info('[INF] waiting until %s for %s', wait_until,
next_infraction[0].id)
self.inf_task.set_next_schedule(wait_until)
def clear_infractions(self):
expired = list(Infraction.select().where(
(Infraction.active == 1) &
(Infraction.expires_at < datetime.utcnow())
))
self.log.info('[INF] attempting to clear %s expired infractions', len(expired))
for item in expired:
guild = self.state.guilds.get(item.guild_id)
if not guild:
self.log.warning('[INF] failed to clear infraction %s, no guild exists', item.id)
continue
# TODO: hacky
type_ = {i.index: i for i in Infraction.Types.attrs}[item.type_]
if type_ == Infraction.Types.TEMPBAN:
# TODO: debounce
guild.delete_ban(item.user_id)
elif type_ == Infraction.Types.TEMPMUTE or Infraction.Types.TEMPROLE:
member = guild.get_member(item.user_id)
if member:
if item.metadata['role'] in member.roles:
member.remove_role(item.metadata['role'])
else:
GuildMemberBackup.remove_role(
item.guild_id,
item.user_id,
item.metadata['role'])
else:
self.log.warning('[INF] failed to clear infraction %s, type is invalid %s', item.id, item.type_)
continue
# TODO: n+1
item.active = False
item.save()
# Wait a few seconds to backoff from a possible bad loop, and requeue new infractions
gevent.sleep(5)
self.queue_infractions()
def guild_infractions_list(guild):
user = User.alias()
actor = User.alias()
columns = [
Infraction.id,
Infraction.type_,
user.user_id,
user.username,
actor.user_id,
actor.username,
Infraction.reason,
Infraction.created_at,
Infraction.expires_at,
]
def serialize(inf):
type_ = {i.index: i for i in Infraction.Types.attrs}[inf.type_]
return {
'id':
inf.id,
'user':
serialize_user(inf.user),
'actor':
serialize_user(inf.actor),
'type':
str(type_),
'reason':
inf.reason,
'metadata':
inf.metadata,
'expires_at':
(inf.expires_at.isoformat() if inf.expires_at else None)
if inf.active else 'Expired',
'created_at':
inf.created_at.isoformat() if inf.created_at else None
}
sort_order = []
for idx in xrange(32):
ch = 'order[{}][column]'.format(idx)
if ch not in request.values:
break
cd = 'order[{}][dir]'.format(idx)
column = columns[int(request.values.get(ch))]
order = request.values.get(cd)
if order == 'asc':
column = column.asc()
else:
column = column.desc()
sort_order.append(column)
base_q = Infraction.select(Infraction, user, actor).join(
user,
on=(Infraction.user_id == user.user_id).alias('user'),
).switch(Infraction).join(
actor,
on=(Infraction.actor_id == actor.user_id).alias('actor'),
).where(Infraction.guild_id == guild.guild_id).order_by(*sort_order)
search = request.values.get('search[value]')
opts = []
if search:
opts.append(user.username**u'%{}%'.format(search))
opts.append(actor.username**u'%{}%'.format(search))
opts.append(Infraction.reason**u'%{}%'.format(search))
if search.isdigit():
opts.append(user.user_id == int(search))
opts.append(actor.user_id == int(search))
opts.append(Infraction.id == int(search))
if opts:
filter_q = base_q.where(reduce(operator.or_, opts))
else:
filter_q = base_q
final_q = filter_q.offset(int(request.values.get('start'))).limit(
int(request.values.get('length')))
return jsonify({
'draw': int(request.values.get('draw')),
'recordsTotal': base_q.count(),
'recordsFiltered': filter_q.count(),
'data': map(serialize, final_q),
})
def info(self, event, user):
content = []
content.append(u'**\u276F User Information**')
content.append(u'ID: {}'.format(user.id))
content.append(u'Profile: <@{}>'.format(user.id))
if user.presence:
emoji, status = get_status_emoji(user.presence)
content.append('Status: {} <{}>'.format(status, emoji))
if user.presence.game and user.presence.game.name:
if user.presence.game.type == GameType.DEFAULT:
content.append(u'Game: {}'.format(user.presence.game.name))
else:
content.append(u'Stream: [{}]({})'.format(
user.presence.game.name, user.presence.game.url))
created_dt = to_datetime(user.id)
content.append('Created: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - created_dt),
created_dt.isoformat()))
member = event.guild.get_member(user.id) if event.guild else None
if member:
content.append(u'\n**\u276F Member Information**')
if member.nick:
content.append(u'Nickname: {}'.format(member.nick))
content.append('Joined: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.joined_at),
member.joined_at.isoformat(),
))
if member.roles:
content.append(u'Roles: {}'.format(', '.join(
(member.guild.roles.get(r).name for r in member.roles))))
# Execute a bunch of queries async
infractions = Infraction.select(
Infraction.guild_id, fn.COUNT('*')).where(
(Infraction.user_id == user.id)).group_by(
Infraction.guild_id).tuples(). async ()
# Wait for them all to complete (we're still going to be as slow as the
# slowest query, so no need to be smart about this.)
wait_many(infractions, timeout=10)
tags = to_tags(guild_id=event.msg.guild.id)
if infractions.value:
statsd.timing('sql.duration.infractions',
infractions.value._query_time,
tags=tags)
infractions = list(infractions.value)
total = sum(i[1] for i in infractions)
content.append(u'\n**\u276F Infractions**')
content.append('Total Infractions: {}'.format(total))
content.append('Unique Servers: {}'.format(len(infractions)))
embed = MessageEmbed()
avatar = u'https://cdn.discordapp.com/avatars/{}/{}.png'.format(
user.id,
user.avatar,
)
embed.set_author(name=u'{}#{}'.format(
user.username,
user.discriminator,
),
icon_url=avatar)
embed.set_thumbnail(url=avatar)
embed.description = '\n'.join(content)
embed.color = get_dominant_colors_user(user, avatar)
event.msg.reply('', embed=embed)
def info(self, event, user):
content = []
content.append(u'**\u276F User Information**')
if user.presence:
emoji, status = get_status_emoji(user.presence)
content.append('Status: {} <{}>'.format(status, emoji))
if user.presence.game and user.presence.game.name:
if user.presence.game.type == GameType.DEFAULT:
content.append(u'Game: {}'.format(user.presence.game.name))
else:
content.append(u'Stream: [{}]({})'.format(
user.presence.game.name, user.presence.game.url))
created_dt = to_datetime(user.id)
content.append('Created: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - created_dt),
created_dt.isoformat()))
member = event.guild.get_member(user.id) if event.guild else None
if member:
content.append(u'\n**\u276F Member Information**')
if member.nick:
content.append(u'Nickname: {}'.format(member.nick))
content.append('Joined: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.joined_at),
member.joined_at.isoformat(),
))
if member.roles:
content.append(u'Roles: {}'.format(', '.join(
(member.guild.roles.get(r).name for r in member.roles))))
try:
newest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id)
& (Message.guild_id == event.guild.id)).order_by(
Message.timestamp.desc()).get()
oldest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id)
& (Message.guild_id == event.guild.id)).order_by(
Message.timestamp.asc()).get()
content.append(u'\n **\u276F Activity**')
content.append('Last Message: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() -
newest_msg.timestamp),
newest_msg.timestamp.isoformat(),
))
content.append('First Message: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() -
oldest_msg.timestamp),
oldest_msg.timestamp.isoformat(),
))
except Message.DoesNotExist:
pass
infractions = list(
Infraction.select(Infraction.guild_id, fn.COUNT('*')).where(
(Infraction.user_id == user.id)).group_by(
Infraction.guild_id).tuples())
if infractions:
total = sum(i[1] for i in infractions)
content.append(u'\n**\u276F Infractions**')
content.append('Total Infractions: {}'.format(total))
content.append('Unique Servers: {}'.format(len(infractions)))
voice = list(
GuildVoiceSession.select(
GuildVoiceSession.user_id, fn.COUNT('*'),
fn.SUM(GuildVoiceSession.ended_at -
GuildVoiceSession.started_at)).where(
(GuildVoiceSession.user_id == user.id)
& (~(GuildVoiceSession.ended_at >> None))).group_by(
GuildVoiceSession.user_id).tuples())
if voice:
content.append(u'\n**\u276F Voice**')
content.append(u'Sessions: {}'.format(voice[0][1]))
content.append(u'Time: {}'.format(
humanize.naturaldelta(voice[0][2])))
embed = MessageEmbed()
avatar = u'https://cdn.discordapp.com/avatars/{}/{}.png'.format(
user.id,
user.avatar,
)
embed.set_author(name=u'{}#{} (<@{}>)'.format(
user.username,
user.discriminator,
user.id,
),
icon_url=avatar)
embed.set_thumbnail(url=avatar)
embed.description = '\n'.join(content)
embed.color = get_dominant_colors_user(user, avatar)
event.msg.reply('', embed=embed)
def guild_infractions(guild):
user = User.alias()
actor = User.alias()
page = int(request.values.get('page', 1))
if page < 1:
page = 1
limit = int(request.values.get('limit', 1000))
if limit < 1 or limit > 1000:
limit = 1000
q = Infraction.select(Infraction, user, actor).join(
user,
on=((Infraction.user_id == user.user_id).alias('user')
)).switch(Infraction).join(
actor,
on=((Infraction.actor_id == actor.user_id).alias('actor')))
queries = []
if 'filtered' in request.values:
filters = json.loads(request.values['filtered'])
for f in filters:
if f['id'] not in CAN_FILTER:
continue
if f['id'] == 'type':
queries.append(
Infraction.type_ == Infraction.Types.get(f['value']))
elif f['id'] == 'reason':
queries.append(
Infraction.reason**('%' +
f['value'].lower().replace('%', '') +
'%'))
else:
queries.append(getattr(Infraction, f['id']) == f['value'])
if queries:
q = q.where((Infraction.guild_id == guild.guild_id)
& reduce(operator.and_, queries))
else:
q = q.where((Infraction.guild_id == guild.guild_id))
sorted_fields = []
if 'sorted' in request.values:
sort = json.loads(request.values['sorted'])
for s in sort:
if s['id'] not in CAN_SORT:
continue
if s['desc']:
sorted_fields.append(getattr(Infraction, s['id']).desc())
else:
sorted_fields.append(getattr(Infraction, s['id']))
if sorted_fields:
q = q.order_by(*sorted_fields)
else:
q = q.order_by(Infraction.id.desc())
q = q.paginate(
page,
limit,
)
return jsonify(
[i.serialize(guild=guild, user=i.user, actor=i.actor) for i in q])
def clear_infractions(self):
expired = list(Infraction.select().where(
(Infraction.active == 1) &
(Infraction.expires_at < datetime.utcnow())
))
self.log.info('[INF] attempting to clear %s expired infractions', len(expired))
for item in expired:
guild = self.state.guilds.get(item.guild_id)
if not guild:
self.log.warning('[INF] failed to clear infraction %s, no guild exists', item.id)
continue
# TODO: hacky
type_ = {i.index: i for i in Infraction.Types.attrs}[item.type_]
if type_ == Infraction.Types.TEMPBAN:
self.call(
'ModLogPlugin.create_debounce',
guild.id,
['GuildBanRemove'],
user_id=item.user_id,
)
guild.delete_ban(item.user_id)
# TODO: perhaps join on users above and use username from db
self.call(
'ModLogPlugin.log_action_ext',
Actions.MEMBER_TEMPBAN_EXPIRE,
guild.id,
user_id=item.user_id,
user=unicode(self.state.users.get(item.user_id) or item.user_id),
inf=item
)
elif type_ == Infraction.Types.TEMPMUTE or Infraction.Types.TEMPROLE:
member = guild.get_member(item.user_id)
if member:
if item.metadata['role'] in member.roles:
self.call(
'ModLogPlugin.create_debounce',
guild.id,
['GuildMemberUpdate'],
user_id=item.user_id,
role_id=item.metadata['role'],
)
member.remove_role(item.metadata['role'])
self.call(
'ModLogPlugin.log_action_ext',
Actions.MEMBER_TEMPMUTE_EXPIRE,
guild.id,
member=member,
inf=item
)
else:
GuildMemberBackup.remove_role(
item.guild_id,
item.user_id,
item.metadata['role'])
else:
self.log.warning('[INF] failed to clear infraction %s, type is invalid %s', item.id, item.type_)
continue
# TODO: n+1
item.active = False
item.save()
# Wait a few seconds to backoff from a possible bad loop, and requeue new infractions
gevent.sleep(5)
self.queue_infractions()
def info(self, event, user: User = None):
if not user:
user = event.author
else:
if not isinstance(user, DiscoUser):
try:
user = self.state.guilds[event.guild.id].members[user].user
except KeyError:
try:
user = self.state.users[user]
except KeyError:
try:
user = self.bot.client.api.users_get(user)
except APIException:
return event.msg.reply(
':eyes: User not found').after(3).delete()
self.client.api.channels_typing(event.channel.id)
content = []
content.append('**\u276F User Information**')
content.append('Profile: <@{}>'.format(user.id))
created_dt = to_datetime(user.id)
content.append('Created: <t:{0}:R> (<t:{0}:f>)'.format(
int(created_dt.replace(tzinfo=pytz.UTC).timestamp())))
member = event.guild.get_member(user.id) if event.guild else None
if user.public_flags:
badges = ''
user_badges = list(UserFlags(user.public_flags))
for badge in user_badges:
badges += '<{}> '.format(BADGE_EMOJI[badge])
content.append('Badges: {}'.format(badges))
if member:
content.append('\n**\u276F Member Information**')
if member.nick:
content.append('Nickname: {}'.format(member.nick))
content.append('Joined: <t:{0}:R> (<t:{0}:f>)'.format(
int(member.joined_at.replace(tzinfo=pytz.UTC).timestamp())))
content.append('Messages: {}'.format(
int(
Message.select(fn.Count(
Message.id)).where((Message.author_id == user.id)
& (Message.guild_id == event.guild.
id)).tuples()[0][0])))
if member.roles:
content.append('Roles: {}'.format(', '.join(
('<@&{}>'.format(r) for r in member.roles))))
# Execute a bunch of queries
newest_msg = Message.select(fn.MAX(Message.id)).where(
(Message.author_id == user.id)
& (Message.guild_id == event.guild.id)).tuples()[0][0]
infractions = Infraction.select(Infraction.id).where(
(Infraction.user_id == user.id)
& (Infraction.guild_id == event.guild.id)).tuples()
if newest_msg:
content.append('\n **\u276F Activity**')
content.append('Last Message: <t:{0}:R> (<t:{0}:f>)'.format(
int((to_datetime(newest_msg).replace(
tzinfo=pytz.UTC)).timestamp())))
# content.append('First Message: {} ({})'.format(
# humanize.naturaltime(datetime.utcnow() - to_datetime(oldest_msg)),
# to_datetime(oldest_msg).strftime("%b %d %Y %H:%M:%S"),
# ))
if len(infractions) > 0:
content.append('\n**\u276F Infractions**')
total = len(infractions)
content.append('Total Infractions: **{:,}**'.format(total))
embed = MessageEmbed()
try:
avatar = User.with_id(user.id).get_avatar_url()
except APIException:
avatar = user.get_avatar_url(
) # This fails if the user has never been seen by speedboat.
embed.set_author(name='{} ({})'.format(
str(user),
user.id,
),
icon_url=avatar)
embed.set_thumbnail(url=avatar)
embed.description = '\n'.join(content)
embed.color = get_dominant_colors_user(user, avatar)
event.msg.reply('', embed=embed)
def info(self, event, user=None):
if not user:
user = event.author
else:
if not isinstance(user, DiscoUser):
try:
user = self.state.guilds[event.guild.id].members[user].user
except KeyError:
try:
user = self.state.users[user]
except KeyError:
try:
user = self.bot.client.api.users_get(user)
except APIException:
return event.msg.reply(
'User not found :eyes:').after(3).delete()
self.client.api.channels_typing(event.channel.id)
content = []
content.append('**\u276F User Information**')
content.append('Profile: <@{}>'.format(user.id))
created_dt = to_datetime(user.id)
content.append('Created: {} ({})'.format(
humanize.naturaltime(datetime.utcnow() - created_dt),
created_dt.strftime("%b %d %Y %H:%M:%S")))
member = event.guild.get_member(user.id) if event.guild else None
if user.presence: #I couldn't get this to work w/o it lol
emoji, status = get_status_emoji(user.presence)
content.append('Status: <{}> {}'.format(emoji, status))
if user.presence.game and user.presence.game.name:
if user.presence.game.type == ActivityTypes.DEFAULT:
content.append('{}'.format(user.presence.game.name))
if user.presence.game.type == ActivityTypes.CUSTOM:
content.append('Custom Status: {}'.format(
user.presence.game.state))
if user.presence.game.type == ActivityTypes.LISTENING:
content.append('Listening to {} on Spotify'.format(
user.presence.game.details)
) #In the embed, details is the songname.
if user.presence.game.type == ActivityTypes.STREAMING:
content.append('Streaming: [{}]({})'.format(
user.presence.game.name, user.presence.game.url))
if user.public_flags:
badges = ''
user_badges = list(UserFlags(user.public_flags))
for badge in user_badges:
badges += '<{}> '.format(BADGE_EMOJI[badge])
content.append('Badges: {}'.format(badges))
if member:
content.append('\n**\u276F Member Information**')
if member.nick:
content.append('Nickname: {}'.format(member.nick))
content.append('Joined: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.joined_at),
member.joined_at.strftime("%b %d %Y %H:%M:%S"),
))
if member.roles:
content.append('Roles: {}'.format(', '.join(
('<@&{}>'.format(member.guild.roles.get(r).id)
for r in member.roles))))
# Execute a bunch of queries
newest_msg = Message.select(fn.MAX(Message.id)).where(
(Message.author_id == user.id)
& (Message.guild_id == event.guild.id)).tuples()[0][0]
oldest_msg = Message.select(fn.MIN(Message.id)).where(
(Message.author_id == user.id)
& (Message.guild_id == event.guild.id)).tuples()[0][0] #Slow Query
voice = GuildVoiceSession.select(
fn.COUNT(GuildVoiceSession.user_id),
fn.SUM(GuildVoiceSession.ended_at - GuildVoiceSession.started_at)
).where((GuildVoiceSession.user_id == user.id)
& (~(GuildVoiceSession.ended_at >> None))
& (GuildVoiceSession.guild_id == event.guild.id)).tuples()[0]
infractions = Infraction.select(Infraction.id).where(
(Infraction.user_id == user.id)
& (Infraction.guild_id == event.guild.id)).tuples()
if newest_msg and oldest_msg:
content.append('\n **\u276F Activity**')
content.append('Last Message: {} ({})'.format(
humanize.naturaltime(datetime.utcnow() -
to_datetime(newest_msg)),
to_datetime(newest_msg).strftime("%b %d %Y %H:%M:%S"),
))
content.append('First Message: {} ({})'.format(
humanize.naturaltime(datetime.utcnow() -
to_datetime(oldest_msg)),
to_datetime(oldest_msg).strftime("%b %d %Y %H:%M:%S"),
))
if len(infractions) > 0:
content.append('\n**\u276F Infractions**')
total = len(infractions)
content.append('Total Infractions: **{:,}**'.format(total))
if voice[0]:
content.append('\n**\u276F Voice**')
content.append('Sessions: `{:,}`'.format(voice[0]))
content.append('Time: `{}`'.format(
str(humanize.naturaldelta(voice[1])).title()))
embed = MessageEmbed()
try:
avatar = User.with_id(user.id).get_avatar_url()
except:
avatar = user.get_avatar_url(
) # This fails if the user has never been seen by speedboat.
embed.set_author(name='{}#{} ({})'.format(
user.username,
user.discriminator,
user.id,
),
icon_url=avatar)
embed.set_thumbnail(url=avatar)
embed.description = '\n'.join(content)
embed.color = get_dominant_colors_user(user, avatar)
event.msg.reply('', embed=embed)
def info(self, event, user=None):
if user is None:
user = event.author
user_id = 0
if isinstance(user, (int, long)):
user_id = user
user = self.state.users.get(user)
if user and not user_id:
user = self.state.users.get(user.id)
if not user:
if user_id:
user = self.fetch_user(user_id)
User.from_disco_user(user)
else:
raise CommandFail('unknown user')
content = []
content.append(u'**\u276F User Information**')
content.append(u'ID: {}'.format(user.id))
content.append(u'Profile: <@{}>'.format(user.id))
if user.presence:
emoji, status = get_status_emoji(user.presence)
content.append('Status: {} <{}>'.format(status, emoji))
game = user.presence.game
if game and game.name:
activity = ['Playing', 'Stream'][int(game.type)] if game.type < 2 else None
if not game.type:
if game.name == 'Spotify':
activity = 'Listening to'
else:
activity = None
if activity:
content.append(u'{}: {}'.format(activity,
u'[{}]({})'.format(game.name, game.url) if game.url else game.name
))
created_dt = to_datetime(user.id)
content.append('Created: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - created_dt),
created_dt.isoformat()
))
for i in self.server_owners:
if i == str(user.id):
content.append('Server Ownership: {}'.format(self.server_owners[i]))
for i in self.server_managers:
if i == str(user.id):
content.append('Community Manager: {}'.format(self.server_managers[i]))
if user.id == self.state.me.id:
content.append('Documentation: https://aetherya.stream/')
elif rdb.sismember('global_admins', user.id):
content.append('Airplane Staff: Global Administrator')
elif rdb.sismember('server_managers', user.id):
content.append('Server Manager')
elif rdb.sismember('server_owner', user.id):
content.append('Server Owner')
member = event.guild.get_member(user.id) if event.guild else None
if member:
content.append(u'\n**\u276F Member Information**')
if member.nick:
content.append(u'Nickname: {}'.format(member.nick))
content.append('Joined: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.joined_at),
member.joined_at.isoformat(),
))
if member.roles:
roles = []
for r in member.roles:
roles.append(member.guild.roles.get(r))
roles = sorted(roles, key=lambda r: r.position, reverse=True)
total = len(member.roles)
roles = roles[:20]
content.append(u'Roles ({}): {}{}'.format(
total, ' '.join(r.mention for r in roles),
' (+{})'.format(total-20) if total > 20 else ''
))
# Execute a bunch of queries async
newest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id) &
(Message.guild_id == event.guild.id)
).order_by(Message.timestamp.desc()).limit(1).async()
# oldest_msg = Message.select(Message.timestamp).where(
# (Message.author_id == user.id) &
# (Message.guild_id == event.guild.id)
# ).order_by(Message.timestamp.asc()).limit(1).async()
infractions = Infraction.select(
Infraction.guild_id,
fn.COUNT('*')
).where(
(Infraction.user_id == user.id) &
(Infraction.type_ != 6) & # Unban
(~(Infraction.reason ** '[NOTE]%'))
).group_by(Infraction.guild_id).tuples().async()
voice = GuildVoiceSession.select(
GuildVoiceSession.user_id,
fn.COUNT('*'),
fn.SUM(GuildVoiceSession.ended_at - GuildVoiceSession.started_at)
).where(
(GuildVoiceSession.user_id == user.id) &
(~(GuildVoiceSession.ended_at >> None))
).group_by(GuildVoiceSession.user_id).tuples().async()
# Wait for them all to complete (we're still going to be as slow as the
# slowest query, so no need to be smart about this.)
try:
wait_many(newest_msg, infractions, voice, timeout=3)
except gevent.Timeout:
pass
tags = to_tags(guild_id=event.msg.guild.id)
if newest_msg.value:
content.append(u'\n **\u276F Activity**')
statsd.timing('sql.duration.newest_msg', newest_msg.value._query_time, tags=tags)
newest_msg = newest_msg.value.get()
content.append('Last Message: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - newest_msg.timestamp),
newest_msg.timestamp.isoformat(),
))
# if oldest_msg.value:
# statsd.timing('sql.duration.oldest_msg', oldest_msg.value._query_time, tags=tags)
# oldest_msg = oldest_msg.value.get()
# content.append('First Message: {} ago ({})'.format(
# humanize.naturaldelta(datetime.utcnow() - oldest_msg.timestamp),
# oldest_msg.timestamp.isoformat(),
# ))
if infractions.value:
statsd.timing('sql.duration.infractions', infractions.value._query_time, tags=tags)
infractions = list(infractions.value)
total = sum(i[1] for i in infractions)
content.append(u'\n**\u276F Infractions**')
content.append('Total Infractions: {}'.format(total))
content.append('Unique Servers: {}'.format(len(infractions)))
if voice.value:
statsd.timing('plugin.utilities.info.sql.voice', voice.value._query_time, tags=tags)
voice = list(voice.value)
content.append(u'\n**\u276F Voice**')
content.append(u'Sessions: {}'.format(voice[0][1]))
content.append(u'Time: {}'.format(humanize.naturaldelta(
voice[0][2]
)))
embed = MessageEmbed()
avatar = user.avatar
if avatar:
avatar = u'https://cdn.discordapp.com/avatars/{}/{}.{}'.format(
user.id, avatar, u'gif' if avatar.startswith('a_') else u'png'
)
else:
avatar = u'https://cdn.discordapp.com/embed/avatars/{}.png'.format(
int(user.discriminator) % 5
)
embed.set_author(name=u'{}#{}'.format(
user.username,
user.discriminator,
), icon_url=avatar)
embed.set_thumbnail(url=avatar)
embed.description = '\n'.join(content)
try:
embed.color = get_dominant_colors_user(user, avatar)
except:
pass
event.msg.reply('', embed=embed)
def info(self, event, user):
if isinstance(user, (int, long)):
try:
r = self.bot.client.api.http(Routes.USERS_GET, dict(user=user)) # hacky method cause this old version of Disco doesn't have a method for this and we're too lazy to update
data = r.json()
User = namedtuple('User', [
'avatar',
'discriminator',
'id',
'username',
'presence'
])
user = User(
avatar=data["avatar"],
discriminator=data["discriminator"],
id=int(data["id"]),
username=data["username"],
presence=None
)
except APIException as e:
raise CommandFail('invalid user')
content = []
content.append(u'**\u276F User Information**')
content.append(u'ID: {}'.format(user.id))
content.append(u'Profile: <@{}>'.format(user.id))
if user.presence:
emoji, status = get_status_emoji(user.presence)
content.append('Status: {} <{}>'.format(status, emoji))
if user.presence.game and user.presence.game.name:
if user.presence.game.type == GameType.DEFAULT:
content.append(u'Game: {}'.format(user.presence.game.name))
else:
content.append(u'Stream: [{}]({})'.format(user.presence.game.name, user.presence.game.url))
created_dt = to_datetime(user.id)
content.append('Created: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - created_dt),
created_dt.isoformat()
))
member = event.guild.get_member(user.id) if event.guild else None
if member:
content.append(u'\n**\u276F Member Information**')
if member.nick:
content.append(u'Nickname: {}'.format(member.nick))
content.append('Joined: {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.joined_at),
member.joined_at.isoformat(),
))
if member.roles:
content.append(u'Roles: {}'.format(
', '.join((member.guild.roles.get(r).name for r in member.roles))
))
# Execute a bunch of queries async
newest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id) &
(Message.guild_id == event.guild.id)
).limit(1).order_by(Message.timestamp.desc()).async()
oldest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id) &
(Message.guild_id == event.guild.id)
).limit(1).order_by(Message.timestamp.asc()).async()
infractions = Infraction.select(
Infraction.guild_id,
fn.COUNT('*')
).where(
(Infraction.user_id == user.id)
).group_by(Infraction.guild_id).tuples().async()
voice = GuildVoiceSession.select(
GuildVoiceSession.user_id,
fn.COUNT('*'),
fn.SUM(GuildVoiceSession.ended_at - GuildVoiceSession.started_at)
).where(
(GuildVoiceSession.user_id == user.id) &
(~(GuildVoiceSession.ended_at >> None))
).group_by(GuildVoiceSession.user_id).tuples().async()
# Wait for them all to complete (we're still going to be as slow as the
# slowest query, so no need to be smart about this.)
wait_many(newest_msg, oldest_msg, infractions, voice, timeout=10)
tags = to_tags(guild_id=event.msg.guild.id)
if newest_msg.value and oldest_msg.value:
statsd.timing('sql.duration.newest_msg', newest_msg.value._query_time, tags=tags)
statsd.timing('sql.duration.oldest_msg', oldest_msg.value._query_time, tags=tags)
newest_msg = newest_msg.value.get()
oldest_msg = oldest_msg.value.get()
content.append(u'\n **\u276F Activity**')
content.append('Last Message: {} ago ({})'.format(
humanize_duration(datetime.utcnow() - newest_msg.timestamp),
newest_msg.timestamp.isoformat(),
))
content.append('First Message: {} ago ({})'.format(
humanize_duration(datetime.utcnow() - oldest_msg.timestamp),
oldest_msg.timestamp.isoformat(),
))
if infractions.value:
statsd.timing('sql.duration.infractions', infractions.value._query_time, tags=tags)
infractions = list(infractions.value)
total = sum(i[1] for i in infractions)
content.append(u'\n**\u276F Infractions**')
content.append('Total Infractions: {}'.format(total))
content.append('Unique Servers: {}'.format(len(infractions)))
if voice.value:
statsd.timing('plugin.utilities.info.sql.voice', voice.value._query_time, tags=tags)
voice = list(voice.value)
content.append(u'\n**\u276F Voice**')
content.append(u'Sessions: {}'.format(voice[0][1]))
content.append(u'Time: {}'.format(humanize.naturaldelta(
voice[0][2]
)))
embed = MessageEmbed()
avatar = u'https://cdn.discordapp.com/avatars/{}/{}.png'.format(
user.id,
user.avatar,
)
embed.set_author(name=u'{}#{}'.format(
user.username,
user.discriminator,
), icon_url=avatar)
embed.set_thumbnail(url=avatar)
embed.description = '\n'.join(content)
embed.color = get_dominant_colors_user(user, avatar)
event.msg.reply('', embed=embed)
def info(self, event, user=None):
if user is None:
user = event.author
user_id = 0
if isinstance(user, (int, long)):
user_id = user
user = self.state.users.get(user)
if user and not user_id:
user = self.state.users.get(user.id)
if not user:
if user_id:
try:
user = self.client.api.users_get(user_id)
except APIException:
raise CommandFail('unknown user')
User.from_disco_user(user)
else:
raise CommandFail('unknown user')
self.client.api.channels_typing(event.channel.id)
content = []
content.append(u'**\u276F User Information**')
content.append(u'**ID:** {}'.format(user.id))
content.append(u'**Profile:** <@{}>'.format(user.id))
if user.presence:
emoji, status = get_status_emoji(user.presence)
content.append('**Status:** {} <{}>'.format(status, emoji))
game = user.presence.game
if game and game.name:
activity = ['Playing', 'Stream', 'Listening to', 'Watching', 'Custom Status'][int(game.type or 0)]
if not game.type:
activity = None
if activity:
game_name = game.state if game.type == GameType.CUSTOM_STATUS else game.name
content.append(u'**{}:** {}'.format(activity,
u'[{}]({})'.format(game_name, game.url) if game.url else game_name
))
if user.public_flags and user.public_flags != 0:
flags = []
for flag, emoji in BADGE_EMOJI.items():
if user.public_flags.check(flag):
flags.append('<{}>'.format(emoji))
if len(flags) > 0:
content.append('**Badges**: {}'.format(' '.join(flags)))
created_dt = to_datetime(user.id)
content.append('**Created:** {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - created_dt),
created_dt.isoformat()
))
member = event.guild.get_member(user.id) if event.guild else None
if member:
content.append(u'\n**\u276F Member Information**')
if member.nick:
content.append(u'**Nickname:** {}'.format(member.nick))
content.append('**Joined:** {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.joined_at),
member.joined_at.isoformat(),
))
if member.roles:
content.append(u'**Roles:** {}'.format(
' '.join((member.guild.roles.get(r).mention for r in sorted(member.roles, key=lambda r: member.guild.roles.get(r).position, reverse=True)))
))
# "is not None" does not work with Unset types for some reason
if bool(member.premium_since):
content.append('**Boosting since:** {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - member.premium_since),
member.premium_since.isoformat(),
))
# Execute a bunch of queries async
newest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id) &
(Message.guild_id == event.guild.id)
).limit(1).order_by(Message.timestamp.desc()).async()
oldest_msg = Message.select(Message.timestamp).where(
(Message.author_id == user.id) &
(Message.guild_id == event.guild.id)
).limit(1).order_by(Message.timestamp.asc()).async()
infractions = Infraction.select(
Infraction.guild_id,
fn.COUNT('*')
).where(
(Infraction.user_id == user.id)
).group_by(Infraction.guild_id).tuples().async()
voice = GuildVoiceSession.select(
GuildVoiceSession.user_id,
fn.COUNT('*'),
fn.SUM(GuildVoiceSession.ended_at - GuildVoiceSession.started_at)
).where(
(GuildVoiceSession.user_id == user.id) &
(~(GuildVoiceSession.ended_at >> None))
).group_by(GuildVoiceSession.user_id).tuples().async()
# Wait for them all to complete (we're still going to be as slow as the
# slowest query, so no need to be smart about this.)
wait_many(newest_msg, oldest_msg, infractions, voice, timeout=10)
tags = to_tags(guild_id=event.msg.guild.id)
if newest_msg.value and oldest_msg.value:
statsd.timing('sql.duration.newest_msg', newest_msg.value._query_time, tags=tags)
statsd.timing('sql.duration.oldest_msg', oldest_msg.value._query_time, tags=tags)
newest_msg = newest_msg.value.get()
oldest_msg = oldest_msg.value.get()
content.append(u'\n **\u276F Activity**')
content.append('**Last Message:** {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - newest_msg.timestamp),
newest_msg.timestamp.isoformat(),
))
content.append('**First Message:** {} ago ({})'.format(
humanize.naturaldelta(datetime.utcnow() - oldest_msg.timestamp),
oldest_msg.timestamp.isoformat(),
))
if infractions.value:
statsd.timing('sql.duration.infractions', infractions.value._query_time, tags=tags)
infractions = list(infractions.value)
total = sum(i[1] for i in infractions)
content.append(u'\n**\u276F Infractions**')
content.append('**Total Infractions:** {:,}'.format(total))
content.append('**Unique Servers:** {}'.format(len(infractions)))
if voice.value:
statsd.timing('plugin.utilities.info.sql.voice', voice.value._query_time, tags=tags)
voice = list(voice.value)
content.append(u'\n**\u276F Voice**')
content.append(u'**Sessions:** {:,}'.format(voice[0][1]))
content.append(u'**Time:** {}'.format(humanize.naturaldelta(
voice[0][2]
)))
embed = MessageEmbed()
avatar = user.avatar
if avatar:
avatar = user.avatar_url
else:
avatar = u'https://cdn.discordapp.com/embed/avatars/{}.png'.format(
int(user.discriminator) % 5
)
embed.set_author(name=u'{}#{}'.format(
user.username,
user.discriminator,
), icon_url=avatar)
embed.set_thumbnail(url=user.avatar_url if user.avatar else avatar)
embed.description = '\n'.join(content)
embed.color = get_dominant_colors_user(user, user.get_avatar_url('png') if user.avatar else avatar)
event.msg.reply('', embed=embed)
def guild_stats_self(guild):
def serialize_user(gcc):
for i in gcc:
user_raw = '''
SELECT username, discriminator
FROM users
WHERE
user_id=%s AND
bot=false;
'''
user = list(User.raw(user_raw, i[1]).tuples())
if user:
return {
'user': {
'username': user[0][0],
'discrim': str(user[0][1]),
'id': i[1]
},
'user_count': int(i[0]),
}
return {
'user': '******',
'user_count': 0,
}
def serialize_emoji(gcc):
for i in gcc:
emoji_raw = '''
SELECT emoji_id
FROM guild_emojis
WHERE
emoji_id=%s AND
guild_id=%s;
'''
emoji = list(
GuildEmoji.raw(emoji_raw, i[0], guild.guild_id).tuples())
if emoji:
return str(emoji[0][0])
return '230870076126003200'
data = json.loads(
rdb.get('web:guild:{}:stats'.format(guild.guild_id)) or '{}')
if not data:
# Totals
totals_messages = Message.select(Message.id).where(
(Message.guild_id == guild.guild_id)).count()
totals_infractions = Infraction.select(Infraction.id).where(
(Infraction.guild_id == guild.guild_id)).count()
# Peaks
## Messages
peaks_messages_raw = '''
SELECT count(id), author_id
FROM
messages
WHERE
guild_id=%s
GROUP BY author_id
ORDER BY count DESC
LIMIT 5;
'''
peaks_messages = list(
Message.raw(peaks_messages_raw, guild.guild_id).tuples())
## Infractions
peaks_infractions_raw = '''
SELECT count(id), user_id
FROM
infractions
WHERE
guild_id=%s
GROUP BY user_id
ORDER BY count DESC
LIMIT 5;
'''
peaks_infractions = list(
Infraction.raw(peaks_infractions_raw, guild.guild_id).tuples())
## Emoji
peaks_emoji_raw = '''
SELECT id, count(*)
FROM (
SELECT unnest(emojis) as id
FROM messages
WHERE guild_id=%s and
cardinality(emojis) > 0
) q
GROUP BY 1
ORDER BY 2 DESC
LIMIT 5
'''
peaks_emoji = list(
Message.raw(peaks_emoji_raw, guild.guild_id).tuples())
## Command
peaks_command_raw = '''
SELECT count(c.command), c.command
FROM
commands c
INNER JOIN messages m
ON (c.message_id = m.id)
WHERE
m.guild_id=%s
GROUP BY 2
ORDER BY 1 DESC
LIMIT 1;
'''
peaks_command = list(
Command.raw(peaks_command_raw, guild.guild_id).tuples())
if totals_messages:
totals_messages = totals_messages
else:
totals_messages = 0
if totals_infractions:
totals_infractions = totals_infractions
else:
totals_infractions = 0
if peaks_messages:
pm = serialize_user(peaks_messages)
else:
pm = {
'user': '******',
'user_count': 0,
}
if peaks_infractions:
pi = serialize_user(peaks_infractions)
else:
pi = {
'user': '******',
'user_count': 0,
}
if peaks_emoji:
anim = False
peaks_emoji_id = serialize_emoji(peaks_emoji)
url = 'https://discordapp.com/api/emojis/{}.gif'.format(
peaks_emoji_id)
r = requests.get(url)
try:
r.raise_for_status()
anim = True
except requests.HTTPError:
pass
if anim:
peaks_emoji_ext = 'gif'
else:
peaks_emoji_ext = 'png'
else:
peaks_emoji_id = '230870076126003200'
peaks_emoji_ext = 'png'
if peaks_command:
peaks_command = '{1}'.format(*peaks_command[0])
else:
peaks_command = 'N/A'
data = {
'totals': {
'messages': totals_messages,
'infractions': totals_infractions,
},
'peaks': {
'messages': pm,
'infractions': pi,
'emoji': {
'id': peaks_emoji_id,
'ext': peaks_emoji_ext,
},
'command': peaks_command,
},
}
rdb.setex('web:guild:{}:stats'.format(guild.guild_id),
json.dumps(data), 600)
return jsonify(data)
