async def purge_notifications(context):
"""
Purge notify notifications of any users who aren't in ths server any more.
@return:
"""
db = Database.instance()
count = 0
notify = db.get_all('user_settings', {
'guild': context.guild.id,
'setting': 'sprint_notify',
'value': 1
})
notify_ids = [int(row['user']) for row in notify]
if notify_ids:
members = await context.guild.query_members(limit=100,
cache=False,
user_ids=notify_ids)
# Create a sub method to find a user in the members list by their id
def find_member(id):
for m in members:
if m.id == id:
return m
return None
# Go through the users who want notifications and delete any which aren't in the server now.
for row in notify:
if not find_member(int(row['user'])):
db.delete('user_settings', {'id': row['id']})
count += 1
return count
def create(params):
"""
Create a reminder in the database
@return:
"""
db = Database.instance()
return db.insert('reminders', params)
def __init__(self, id):
self.__db = Database.instance()
self.__bot = None
self.__context = None
self.id = None
self.guild = None
self.channel = None
self.title = None
self.description = None
self.img = None
self.colour = None
self.startdate = None
self.enddate = None
self.started = None
self.ended = None
record = self.__db.get('events', {'id': id})
if record:
self.id = record['id']
self.guild = record['guild']
self.channel = record['channel']
self.title = record['title']
self.description = record['description']
self.img = record['img']
self.colour = record['colour']
self.startdate = record['startdate']
self.enddate = record['enddate']
self.started = record['started']
self.ended = record['ended']
def create(guild, channel, start, end, end_reference, length, createdby, created):
# Insert the record into the database
db = Database.instance()
db.insert('sprints', {'guild': guild, 'channel': channel, 'start': start, 'end': end, 'end_reference': end_reference, 'length': length, 'createdby': createdby, 'created': created})
# Return the new object using this guild id
return Sprint(guild)
def __init__(self, guild):
# Initialise the database instance
self.__db = Database.instance()
self._guild = guild
self._id = guild.id
self._members = [member.id for member in self._guild.members]
self._settings = None
def get(user, shortname):
"""
Try to get a project with a given shortname, for a given user
:param user:
:param shortname:
:return:
"""
db = Database.instance()
record = db.get('projects', {'user': user, 'shortname': shortname})
return Project(record['id']) if record else None
def get(type, object, object_id):
"""
Check to see if a task of this type and object_id already exists
:return:
"""
db = Database.instance()
return db.get('tasks', {
'type': type,
'object': object,
'objectid': object_id
})
def __init__(self, bot):
self.bot = bot
self.__db = Database.instance()
self._arguments = [{
'key': 'option',
'prompt': 'goal:argument:option',
'required': True
}, {
'key': 'value',
'required': False
}]
def __init__(self, id):
self.__db = Database.instance()
record = self.__db.get('projects', {'id': id})
if record:
self._id = record['id']
self._user = record['user']
self._name = record['name']
self._shortname = record['shortname']
self._words = record['words']
self._completed = record['completed']
def __init__(self, bot):
self.bot = bot
self.__db = Database.instance()
self._arguments = [{
'key': 'flag',
'prompt': 'challenge:argument:flag',
'required': False,
'error': 'challenge:argument:flag'
}, {
'key': 'flag2',
'required': False
}]
def __init__(self, bot):
self.bot = bot
self.__db = Database.instance()
self._arguments = [{
'key': 'option',
'prompt': 'goal:argument:option',
'required': True
}, {
'key': 'value',
'required': False
}]
self.types = ['daily', 'weekly', 'monthly', 'yearly']
def create(user, shortname, name):
"""
Create a new project
:param name:
:return:
"""
db = Database.instance()
return db.insert('projects', {
'user': user,
'shortname': shortname,
'name': name
})
def get_lang(guild_id):
"""
Check which language file the guild is using
@param guild_id: The guild ID
@return string: The language code
"""
db = Database.instance()
result = db.get('guild_settings', {'guild': guild_id, 'setting': 'lang'})
if result and is_supported_language(result['value']):
return result['value']
else:
return 'en'
def __init__(self, bot):
self.bot = bot
self.__db = Database.instance()
self._supported_commands = ['create', 'rename', 'desc', 'description', 'img', 'image', 'delete', 'schedule', 'unschedule', 'start', 'end', 'time', 'left', 'update', 'me', 'top', 'leaderboard', 'info']
self._arguments = [
{
'key': 'cmd',
'prompt': 'event:argument:cmd',
'required': True,
'check': lambda content : content in self._supported_commands,
'error': 'event:err:argument:cmd'
}
]
def __init__(self, id=None):
self.__db = Database.instance()
self.id = None
self.user = None
self.guild = None
self.time = None
self.channel = None
self.message = None
self.intervaltime = None
record = self.__db.get('reminders', {'id': id})
if record:
self.load(record)
def __init__(self, bot):
self.bot = bot
self.__db = Database.instance()
self._arguments = [{
'key': 'amount',
'prompt': 'wrote:argument:amount',
'required': True,
'type': int,
'error': 'wrote:err:type'
}, {
'key': 'shortname',
'required': False
}]
async def execute_all(bot):
"""
Execute a pass of the scheduled tasks that are currently pending
:return:
"""
now = int(time.time())
db = Database.instance()
pending = db.get_all_sql(
'SELECT id FROM tasks WHERE time <= %s ORDER BY id ASC', [now])
for row in pending:
task = Task(row['id'])
if task.is_valid():
result = await task.run(bot)
def create(guild, channel, title):
"""
Create a new event
:param guild:
:param channel:
:param title:
:return:
"""
db = Database.instance()
return db.insert('events', {
'guild': guild,
'channel': channel,
'title': title
})
def __init__(self, id, guild, context=None, name=None, bot=None, channel=None):
# Initialise the database instance
self.__db = Database.instance()
self.__context = context
self.__bot = bot
self.__channel = channel
self._id = int(id)
self._guild = int(guild)
self._name = name
self._xp = None
self._stats = None
self._settings = None
self._records = None
def get(id):
"""
Get a sprint object by its id
:return: Sprint
"""
db = Database.instance()
record = db.get('sprints', {'id': id})
if record is not None:
sprint = Sprint(None)
sprint.set_id(id)
sprint.load('id')
return sprint
else:
return None
def all(user=None, guild=None):
"""
Get all reminders for the user/guild
@return:
"""
db = Database.instance()
reminders = []
records = db.get_all('reminders', {
'user': user,
'guild': guild
},
sort=['id ASC'])
for record in records:
reminders.append(Reminder(record['id']))
return reminders
def all(user):
"""
Get an array of Projects for a given user
:param user:
:return:
"""
db = Database.instance()
records = db.get_all('projects', {'user': user}, ['id'],
['completed', 'name', 'shortname', 'words'])
projects = []
for record in records:
projects.append(Project(record['id']))
return projects
def cancel(object, object_id, type=None):
"""
Cancel all tasks related to a specific object
:param object:
:param object_id:
:param type:
:return:
"""
db = Database.instance()
params = {'object': object, 'objectid': object_id}
if type is not None:
params['type'] = type
return db.delete('tasks', params)
def __init__(self, id):
self.__db = Database.instance()
record = self.__db.get('projects', {'id': id})
if record:
self._id = record['id']
self._user = record['user']
self._name = record['name']
self._shortname = record['shortname']
self._words = record['words']
self._status = record['status']
self._genre = record['genre']
self._description = record['description']
self._link = record['link']
self._image = record['image']
self._completed = record['completed']
def __init__(self, id):
"""
Load a Task object by its ID
:param id:
"""
self.__db = Database.instance()
self.id = None
record = self.__db.get('tasks', {'id': id})
if record:
self.id = record['id']
self.type = record['type']
self.time = record['time']
self.object = record['object']
self.object_id = record['objectid']
self.processing = record['processing']
self.recurring = record['recurring']
self.run_every_seconds = record['runeveryseconds']
def get_by_guild(guild_id, include_ended=False):
"""
Get the event currently running on the specified guild
:param guild_id:
:param ended:
:return:
"""
db = Database.instance()
# If we are including ones which have ended, just try and get the last one
if include_ended:
record = db.get('events', {'guild': guild_id}, ['id'], ['id DESC'])
else:
record = db.get('events', {'guild': guild_id, 'ended': 0})
if record:
return Event(record['id'])
else:
return None
def schedule(type, time, object, object_id):
"""
Schedule the task in the database
:return:
"""
db = Database.instance()
# If this task already exists, just update its time.
record = Task.get(type, object, object_id)
if record:
return db.update('tasks', {'time': time}, {'id': record['id']})
else:
# Otherwise, create one.
return db.insert(
'tasks', {
'type': type,
'time': time,
'object': object,
'objectid': object_id
})
def all(user, filter_by=None, filter=None):
"""
Get an array of Projects for a given user, matching any optional filter passed through
@param filter_by:
@param filter:
@return:
"""
db = Database.instance()
params = {'user': user}
if filter_by is not None and filter is not None:
params[filter_by] = filter
records = db.get_all('projects', params, ['id'],
['name', 'shortname', 'words'])
projects = []
for record in records:
projects.append(Project(record['id']))
return projects
def __init__(self, guild_id, bot=None):
# Initialise the database instance and bot (if supplied)
self.__db = Database.instance()
self.bot = bot
# Initialise the variables to match the database record
self._id = None
self._guild = guild_id
self._channel = None
self._start = None
self._end = None
self._end_reference = None
self._length = None
self._createdby = None
self._created = None
self._completed = None
# Try and load the sprint on this server, if there is one running.
if self._guild is not None:
self.load()
def __init__(self):
self.__db = Database.instance()
pass