async def aed_add(self,
ctx,
server,
searchstr,
group,
time_offset: int = 0):
"""Add a new autoeventdm"""
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
group = group.lower()
if group not in GROUPS:
await ctx.send("Unsupported group, pick one of red, blue, green")
return
if time_offset and not user_is_donor(ctx):
await ctx.send("You must be a donor to set a time offset!")
return
if time_offset < 0:
await ctx.send("Offset cannot be negative")
return
default = {
'key': datetime.datetime.now().timestamp(),
'server': server,
'group': group,
'searchstr': searchstr,
'offset': time_offset,
}
async with self.config.user(ctx.author).dmevents() as dmevents:
dmevents.append(default)
await ctx.tick()
async def testevent(self, ctx, server, seconds: int = 0):
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
dg_cog = self.bot.get_cog('Dadguide')
await dg_cog.wait_until_ready()
# TODO: Don't use this awful importing hack
dg_module = __import__('.'.join(dg_cog.__module__.split('.')[:-1]) +
".models.scheduled_event_model")
timestamp = int((datetime.datetime.now(pytz.utc) +
timedelta(seconds=seconds)).timestamp())
self.fake_uid -= 1
te = dg_module.models.scheduled_event_model.ScheduledEventModel(
event_id=self.fake_uid,
server_id=SUPPORTED_SERVERS.index(server),
event_type_id=EventType.Guerrilla.value,
start_timestamp=timestamp,
end_timestamp=timestamp + 60,
group_name='red',
dungeon_model=DummyObject(
name_en='fake_dungeon_name',
clean_name_en='fake_dungeon_name',
dungeon_type=DungeonType.Unknown7,
dungeon_id=1,
))
self.events.append(Event(te, self.bot.get_cog('Dadguide').database))
await ctx.tick()
async def aep_add(self, ctx, key, server=None, searchstr=None, red: discord.Role = None, blue: discord.Role = None,
green: discord.Role = None):
"""Add a new autoeventping"""
if green is None and server is not None:
await ctx.send("Multi-word keys must be in quotes.")
return
default = {
'roles': [None, None, None],
'channels': [None, None, None],
'server': 'NA',
'searchstr': None,
'regex': False,
'enabled': False,
'offset': 0,
}
if green is not None:
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
default.update({
'roles': [red.id, blue.id, green.id],
'channels': [ctx.channel.id] * 3,
'server': server,
'searchstr': searchstr,
'enabled': True,
})
async with self.config.guild(ctx.guild).pingroles() as pingroles:
pingroles[key] = default
await ctx.tick()
async def active(self, ctx, server):
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
msg = self.make_active_text(server)
await self.page_output(ctx, msg)
async def aep_s_server(self, ctx, key, server):
"""Sets which server to listen to events in"""
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
await self.aeps(ctx, key, 'server', server)
await ctx.tick()
async def getServer(self, ctx, user_id, server=None):
if server is None:
server = self.settings.getDefaultServer(user_id)
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send(inline('Unsupported server: ' + server))
return
return server
async def setServer(self, ctx, server):
"""Set your default server to one of [NA, EU, JP, KR]
This server is used to default the idme command if you don't provide a server.
"""
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send(inline('Unsupported server: ' + server))
return
self.settings.setDefaultServer(ctx.author.id, server)
await ctx.send(inline('Set your default server to: ' + server))
async def rmchanneldaily(self, ctx, server):
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
channel_id = ctx.channel.id
if not self.settings.check_daily_reg(channel_id, server):
await ctx.send("Channel is not active.")
return
self.settings.remove_daily_reg(channel_id, server)
await ctx.send("Channel deactivated.")
async def addchanneldaily(self, ctx, server):
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
channel_id = ctx.channel.id
if self.settings.check_daily_reg(channel_id, server):
await ctx.send("Channel already active.")
return
self.settings.add_daily_reg(channel_id, server)
await ctx.send("Channel now active.")
async def clear(self, ctx, server=None):
"""Deletes your saved profile for a server
If no server is provided then all profiles are deleted.
"""
user_id = ctx.author.id
if server is None:
self.settings.clearProfile(user_id)
await ctx.send(inline('Cleared your profile for all servers'))
else:
server = normalize_server_name(server)
self.settings.clearProfile(user_id, server)
await ctx.send(inline('Cleared your profile for ' + server))
async def do_partial(self, ctx, server):
server = normalize_server_name(server)
if server not in SUPPORTED_SERVERS:
await ctx.send("Unsupported server, pick one of NA, KR, JP")
return
events = EventList(self.events)
events = events.with_server(server)
events = events.in_dungeon_type(
[DungeonType.Etc, DungeonType.CoinDailyOther])
events = events.is_grouped()
active_events = events.active_only().items_by_open_time(reverse=True)
pending_events = events.pending_only().items_by_open_time(reverse=True)
group_to_active_event = {e.group: e for e in active_events}
group_to_pending_event = {e.group: e for e in pending_events}
# active_events = list(group_to_active_event.values())
# pending_events = list(group_to_pending_event.values())
active_events.sort(
key=lambda e: (GROUPS.index(e.group), e.open_datetime))
pending_events.sort(
key=lambda e: (GROUPS.index(e.group), e.open_datetime))
if len(active_events) == 0 and len(pending_events) == 0:
await ctx.send("No events available for " + server)
return
output = "Events for {}".format(server)
if len(active_events) > 0:
output += "\n\n" + " Remaining Dungeon"
for e in active_events:
output += "\n" + e.to_partial_event(self)
if len(pending_events) > 0:
output += "\n\n" + " PT ET ETA Dungeon"
for e in pending_events:
output += "\n" + e.to_partial_event(self)
for page in pagify(output):
await ctx.send(box(page))
def make_channel_reg(channel_id, server):
server = normalize_server_name(server)
return {"channel_id": channel_id, "server": server}
def with_server(self, server):
return self.with_func(
lambda e: e.server == normalize_server_name(server))
