async def _add_db_sighting_report(self, ctx, message):
channel = ctx.channel
guild = channel.guild
author = ctx.author
wild_dict = self.bot.guild_dict[guild.id]['wildreport_dict'][message.id]
created = round(message.created_at.timestamp())
__, __ = GuildTable.get_or_create(snowflake=guild.id)
__, __ = TrainerTable.get_or_create(snowflake=author.id, guild=guild.id)
report = TrainerReportRelation.create(created=created, trainer=author.id,
location=wild_dict['location_id'], message=message.id)
try:
SightingTable.create(trainer_report=report, pokemon=wild_dict['pokemon_id'])
except Exception as e:
self.bot.logger.info(f"Failed to create sighting table entry with error: {e}")
async def _add_db_research_report(self, ctx, message):
channel = ctx.channel
guild = channel.guild
author = ctx.author
quest_dict = self.bot.guild_dict[guild.id]['questreport_dict'][
message.id]
created = round(message.created_at.timestamp())
__, __ = GuildTable.get_or_create(snowflake=guild.id)
__, __ = TrainerTable.get_or_create(snowflake=author.id,
guild=guild.id)
report = TrainerReportRelation.create(
created=created,
trainer=author.id,
location=quest_dict['location_id'],
message=message.id)
try:
ResearchTable.create(trainer_report=report,
quest=quest_dict['quest_id'],
reward=quest_dict['reward'])
except Exception as e:
self.bot.logger.info(
f"Failed to create research table entry with error: {e}")
async def _sub_add(self, ctx, *, content=None):
"""Create a subscription
**Usage**: `!sub add <type> <target>`
Kyogre will send you a notification if an event is generated
matching the details of your subscription.
**Valid types**: `pokemon, raid, research, wild, gym, item, lure`
**Note**: 'pokemon' includes raid, research, and wild reports"""
message = ctx.message
channel = message.channel
guild = message.guild
trainer = message.author.id
error_list = []
if content is None:
return await self._guided_subscription(ctx, 'Add')
content = content.strip().lower()
if content == 'shiny':
candidate_list = [('shiny', 'shiny', 'shiny')]
else:
error_message = self._get_subscription_command_error(
content, self.valid_types)
if error_message:
response = await message.channel.send(error_message)
return await utils.sleep_and_cleanup([message, response], 10)
candidate_list, error_list = await self._parse_subscription_content(
content, 'add', message)
existing_list = []
sub_list = []
# don't remove. this makes sure the guild and trainer are in the db
guild_obj, __ = GuildTable.get_or_create(snowflake=guild.id)
trainer_obj, __ = TrainerTable.get_or_create(snowflake=trainer,
guild=guild.id)
if guild_obj is None or trainer_obj is None:
pass
s_type = ''
for sub in candidate_list:
s_type = sub[0]
s_target = sub[1]
s_entry = sub[2]
if len(sub) > 3:
spec = sub[3]
try:
result, __ = SubscriptionTable.get_or_create(
guild_id=ctx.guild.id,
trainer=trainer,
type=s_type,
target=s_target)
current_gym_ids = result.specific
split_ids = []
if current_gym_ids:
current_gym_ids = current_gym_ids.strip('[]')
split_id_string = current_gym_ids.split(', ')
for s in split_id_string:
try:
split_ids.append(int(s))
except ValueError:
pass
spec = [int(s) for s in spec]
new_ids = set(split_ids + spec)
result.specific = list(new_ids)
if len(result.specific) > 0:
result.save()
sub_list.append(s_entry)
except:
error_list.append(s_entry)
else:
try:
SubscriptionTable.create(guild_id=ctx.guild.id,
trainer=trainer,
type=s_type,
target=s_target)
sub_list.append(s_entry)
except IntegrityError:
existing_list.append(s_entry)
except:
error_list.append(s_entry)
sub_count = len(sub_list)
existing_count = len(existing_list)
error_count = len(error_list)
confirmation_msg = f'{ctx.author.mention}, successfully added {sub_count} new {s_type} subscriptions'
if sub_count > 0:
confirmation_msg += '\n**{sub_count} Added:** \n\t{sub_list}'.format(
sub_count=sub_count, sub_list=',\n\t'.join(sub_list))
if existing_count > 0:
confirmation_msg += '\n**{existing_count} Already Existing:** \n\t{existing_list}'\
.format(existing_count=existing_count, existing_list=', '.join(existing_list))
if error_count > 0:
confirmation_msg += '\n**{error_count} Errors:** \n\t{error_list}\n(Check the spelling and try again)'\
.format(error_count=error_count, error_list=', '.join(error_list))
await channel.send(content=confirmation_msg)
async def _sub_remove(self, ctx, *, content=None):
"""Remove a subscription
**Usage**: `!sub remove <type> <target>`
You will no longer be notified of the specified target for the given event type.
You must remove subscriptions using the same type with which they were added.
It may be helpful to do `!sub list` first to see your existing subscriptions.
You can remove all subscriptions of a type:
`!sub remove <type> all`
Or remove all subscriptions:
`!sub remove all all`
Or started a guided session with:
`!sub remove`
**Valid types**: `pokemon, raid, research, wild, gym, item, lure`
**Note**: 'pokemon' includes raid, research, and wild reports"""
message = ctx.message
channel = message.channel
guild = message.guild
trainer = message.author.id
if content is None:
return await self._guided_subscription(ctx, 'Remove')
content = content.strip().lower()
if content == 'shiny':
sub_type, target = ['shiny', 'shiny']
else:
error_message = self._get_subscription_command_error(
content, self.valid_types)
if error_message:
response = await message.channel.send(error_message)
return await utils.sleep_and_cleanup([message, response], 10)
sub_type, target = content.split(' ', 1)
candidate_list = []
error_list = []
not_found_list = []
remove_list = []
trainer_query = (TrainerTable.select(
TrainerTable.snowflake).where((TrainerTable.snowflake == trainer)
& (TrainerTable.guild == guild.id)))
# check for special cases
skip_parse = False
if sub_type == 'all':
if target == 'all':
try:
remove_count = SubscriptionTable.delete()\
.where((SubscriptionTable.trainer << trainer_query) &
(SubscriptionTable.guild_id == ctx.guild.id)).execute()
message = f'I removed your {remove_count} subscriptions!'
except:
message = 'I was unable to remove your subscriptions!'
confirmation_msg = f'{message}'
await channel.send(content=confirmation_msg)
return
else:
target = target.split(',')
if sub_type == 'pokemon':
for name in target:
pkmn = Pokemon.get_pokemon(self.bot, name)
if pkmn:
candidate_list.append(
(sub_type, pkmn.name, pkmn.name))
else:
error_list.append(name)
if sub_type != "gym":
skip_parse = True
elif target == 'all':
candidate_list.append((sub_type, target, target))
skip_parse = True
elif target == 'shiny':
candidate_list = [('shiny', 'shiny', 'shiny')]
sub_type, target = ['shiny', 'shiny']
skip_parse = True
if not skip_parse:
candidate_list, error_list = await self._parse_subscription_content(
content, 'remove', message)
remove_count = 0
s_type = ''
for sub in candidate_list:
s_type = sub[0]
s_target = sub[1]
s_entry = sub[2]
if len(sub) > 3:
spec = sub[3]
try:
result, __ = SubscriptionTable.get_or_create(
guild_id=ctx.guild.id,
trainer=trainer,
type='gym',
target=s_target)
current_gym_ids = result.specific
split_ids = []
if current_gym_ids:
current_gym_ids = current_gym_ids.strip('[]')
split_id_string = current_gym_ids.split(', ')
for s in split_id_string:
try:
split_ids.append(int(s))
except ValueError:
pass
for s in spec:
if s in split_ids:
remove_count += 1
split_ids.remove(s)
result.specific = split_ids
result.save()
remove_list.append(s_entry)
except:
error_list.append(s_entry)
else:
try:
if s_type == 'all':
remove_count += SubscriptionTable.delete().where(
(SubscriptionTable.trainer << trainer_query)
& (SubscriptionTable.target == s_target)
& (SubscriptionTable.guild_id == ctx.guild.id)
).execute()
elif s_target == 'all':
remove_count += SubscriptionTable.delete().where(
(SubscriptionTable.trainer << trainer_query)
& (SubscriptionTable.type == s_type)
& (SubscriptionTable.guild_id == ctx.guild.id)
).execute()
else:
remove_count += SubscriptionTable.delete().where(
(SubscriptionTable.trainer << trainer_query)
& (SubscriptionTable.type == s_type)
& (SubscriptionTable.target == s_target)
& (SubscriptionTable.guild_id == ctx.guild.id)
).execute()
if remove_count > 0:
remove_list.append(s_entry)
else:
not_found_list.append(s_entry)
except:
error_list.append(s_entry)
not_found_count = len(not_found_list)
error_count = len(error_list)
confirmation_msg = f'{ctx.author.mention}, successfully removed {remove_count} {s_type} subscriptions'
if remove_count > 0:
confirmation_msg += '\n**{remove_count} Removed:** \n\t{remove_list}'\
.format(remove_count=remove_count, remove_list=',\n\t'.join(remove_list))
if not_found_count > 0:
confirmation_msg += '\n**{not_found_count} Not Found:** \n\t{not_found_list}'\
.format(not_found_count=not_found_count, not_found_list=', '.join(not_found_list))
if error_count > 0:
confirmation_msg += '\n**{error_count} Errors:** \n\t{error_list}\n(Check the spelling and try again)'\
.format(error_count=error_count, error_list=', '.join(error_list))
await channel.send(content=confirmation_msg)
def _count_usage(ctx):
__, __ = GuildTable.get_or_create(snowflake=ctx.guild.id)
trainer, __ = TrainerTable.get_or_create(snowflake=ctx.author.id,
guild=ctx.guild.id)
now = round(time.time())
APIUsageTable.create(trainer=trainer, date=now)