async def distancegoal(self, ctx, amount=None, unit=None):
if ctx.channel.name != self.settings.get('io_channel'):
return
try:
val = x_to_km(float(amount), unit)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} <number> <{'/'.join(SUPPORTED_DST_UNITS)}>"
)
return
session = model.Session()
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if not user:
user = model.settings_factory(ctx.author.id, distance_goal=val)
else:
user.distance_goal = val if val > 0 else None
try:
session.add(user)
session.commit()
except:
log.debug(f'[WRKT] Failed to commit change, rolling back...')
log.debug(f'[WRKT] {traceback.format_exc()}')
await ctx.channel.send(f"Failed to update distance goal.")
session.rollback()
return
await ctx.channel.send(
f"Updated distance goal for {ctx.author.mention} to {dst_print(val)}."
)
async def watersize(self, ctx, amount=None, unit=None):
if ctx.channel.name != self.settings.get('io_channel'):
return
try:
val = x_to_l(float(amount), unit)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} <number> <{'/'.join(SUPPORTED_VOL_UNITS)}>"
)
return
session = model.Session()
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if not user:
user = model.settings_factory(ctx.author.id,
default_water_measure=val)
else:
user.default_water_measure = val
try:
session.add(user)
session.commit()
except:
log.debug(f'[WATR] Failed to commit change, rolling back...')
log.debug(f'[WATR] {traceback.format_exc()}')
await ctx.channel.send(f"Failed to update default water size.")
session.rollback()
return
await ctx.channel.send(
f"Updated default water size for {ctx.author.mention} to {vol_print(val)}."
)
async def jumpingjackgoal(self, ctx: commands.Context, amount=None):
if ctx.channel.name != self.settings.get('io_channel'):
return
try:
val = int(amount)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.commands} <number>")
return
session = model.Session()
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if not user:
user = model.settings_factory(ctx.author_id, jumpingjack_goal=val)
else:
user.jumpingjack_goal = val if val > 0 else None
try:
session.add(user)
session.commit()
except:
log.debug(f'[WRKT] Failed to commit change, rolling back...')
log.debug(f'[WRKT] {traceback.format_exc()}')
await ctx.channel.send(f"Failed to update jumping jack goal.")
session.rollback()
return
await ctx.channel.send(
f"Updated jumping jack goal for {ctx.author.mention} to {val}.")
async def drink(self, ctx, amount=None, unit=None):
if ctx.channel.name != self.settings.get('io_channel'):
return
session = model.Session()
val = 0
# Get value to add by
if not amount and not unit:
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if not user or not user.default_water_measure:
await ctx.channel.send(
f"No default water increment size saved for {ctx.author.mention}."
)
return
else:
val = float(user.default_water_measure)
else:
try:
val = x_to_l(float(amount), unit)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} <number> <{'/'.join(SUPPORTED_VOL_UNITS)}>"
)
return
# Get today's entry
date = datetime.date.today()
water_log = session.query(model.Water).filter_by(user_id=ctx.author.id,
date=date).first()
if not water_log:
water_log = model.water_factory(ctx.author.id, date, val)
else:
water_log.amount = val + float(water_log.amount)
try:
session.add(water_log)
session.commit()
except:
log.debug(f'[WATR] Failed to commit change, rolling back...')
log.debug(f'[WATR] {traceback.format_exc()}')
await ctx.channel.send(f"Failed to add water log.")
session.rollback()
return
msg = f"Logged {vol_print(val)} of water for {ctx.author.mention}. Today's total is now {vol_print(float(water_log.amount))}."
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if user and user.water_goal and float(user.water_goal) <= float(
water_log.amount):
msg = f"{msg}\nCongrats, you met your goal of {vol_print(float(user.water_goal))}!"
await ctx.channel.send(msg)
def get_dict_for_workout(bot, date, workout_str):
session = model.Session()
res = []
workout = session.query(model.Workout).filter_by(date=date, workout_id=model.WORKOUTS[workout_str]['id']).filter(model.Workout.amount > 0)\
.order_by(model.Workout.amount.desc())
for entry, place in zip(workout, range(1, workout.count() + 1)):
res.append({
'Place': place,
'Name': bot.get_user(entry.user_id).name,
'Amount': entry.amount
})
return res
def get_dict_for_water(bot, date):
session = model.Session()
res = []
water = session.query(model.Water).filter_by(date=date).filter(
model.Water.amount > 0).order_by(model.Water.amount.desc())
for entry, place in zip(water, range(1, water.count() + 1)):
res.append({
'Place': place,
'Name': bot.get_user(entry.user_id).name,
'Amount': Water.vol_print(float(entry.amount))
})
return res
def get_dict_for_distance(bot, date):
session = model.Session()
res = []
distance = session.query(model.Workout).filter_by(
date=date, workout_id=model.WORKOUTS['distance']['id']).filter(
model.Workout.amount > 0).order_by(model.Workout.amount.desc())
for entry, place in zip(distance, range(1, distance.count() + 1)):
res.append({
'Place': place,
'Name': bot.get_user(entry.user_id).name,
'Amount': Workout.dst_print(float(entry.amount))
})
return res
async def distance(self, ctx: commands.Context, amount=None, unit=None):
if ctx.channel.name != self.settings.get('io_channel'):
return
session = model.Session()
val = 0
try:
val = x_to_km(float(amount), unit)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} <number> <{'/'.join(SUPPORTED_DST_UNITS)}>"
)
return
date = datetime.date.today()
dst_log = session.query(model.Workout).filter_by(
user_id=ctx.author.id,
date=date,
workout_id=model.WORKOUTS['distance']['id']).first()
if not dst_log:
dst_log = model.workout_factory(ctx.author.id, date,
model.WORKOUTS['distance']['id'],
val)
else:
dst_log.amount = val + float(dst_log.amount)
try:
session.add(dst_log)
session.commit()
except:
log.debug(f'[WRKT] Failed to commit change, rolling back...')
log.debug(f'[WRKT] {traceback.format_exc()}')
await ctx.channel.send(f"Failed to log distance.")
session.rollback()
return
msg = f"Logged {dst_print(val)} for {ctx.author.mention}. Today's total is now {dst_print(float(dst_log.amount))}."
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if user and user.distance_goal and float(user.distance_goal) <= float(
dst_log.amount):
msg = f"{msg}\nCongrats, you met your goal of {dst_print(float(user.distance_goal))}!"
await ctx.channel.send(msg)
async def log_workout(self, ctx, typestr, amount):
typeid = model.WORKOUTS[typestr]['id']
try:
val = int(amount)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} <int amount>"
)
return
type_out = (typestr + "s") if val > 0 else typestr
session = model.Session()
date = datetime.date.today()
workout_log = session.query(model.Workout).filter_by(
user_id=ctx.author.id, date=date, workout_id=typeid).first()
if not workout_log:
workout_log = model.workout_factory(ctx.author.id, date, typeid,
val)
else:
workout_log.amount = workout_log.amount + val
try:
session.add(workout_log)
session.commit()
except:
log.debug(f"[WRKT] Failed to commit change, rolling back...")
log.debug(f"[WRKT] {traceback.format_exc()}")
await ctx.channel.send(f"Failed to log {type_out}")
session.rollback()
return
msg = f"Logged {val} {type_out} for {ctx.author.mention}. Today's total is now {workout_log.amount}."
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if user:
goal = get_goal_from_id(user, typestr)
if goal and goal <= workout_log.amount:
msg = f"{msg}\nCongrats, you met your goal of {goal}!"
await ctx.channel.send(msg)
async def remind(self, ctx: commands.Context, amount=None, *msg):
if ctx.channel.name != self.settings.get('io_channel'):
return
if not amount:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} [time without spaces (e.g. 1d, 3h30m, 45s, etc.)] [msg (optional)]"
)
return
else:
amount = timeparse(amount)
if len(msg) > 0:
msg = ' '.join(msg)
else:
msg = None
try:
remind_time = datetime.datetime.now() + datetime.timedelta(
seconds=amount)
except:
await ctx.channel.send(
f"Usage: {self.settings.get('prefix')}{ctx.command} [time without spaces (e.g. 1d, 3h30m, 45s, etc.)] [msg (optional)]"
)
return
session = model.Session()
reminder = model.timer_factory(ctx.author.id,
message=msg,
time=remind_time)
try:
session.add(reminder)
session.commit()
except:
log.debug(f"[TIMR] Failed to commit change, rolling back...")
log.debug(f"[TIMR] {traceback.format_exc()}")
await ctx.channel.send(f"Failed to add timer.")
session.rollback()
return
await ctx.channel.send(
f"{ctx.author.mention}, successfully added timer for {remind_time}."
)
async def getwatersize(self, ctx):
if ctx.channel.name != self.settings.get('io_channel'):
return
session = model.Session()
user = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
if not user:
await ctx.channel.send(
f"No settings information saved for {ctx.author.mention}")
return
if not user.default_water_measure:
await ctx.channel.send(
f"No default water increment size saved for {ctx.author.mention}"
)
return
val = float(user.default_water_measure)
await ctx.channel.send(
f"Default water increment size for {ctx.author.mention} is {vol_print(val)}."
)
def make_overall_leaderboard_dict(bot: commands.Bot, date):
session = model.Session()
water = session.query(model.Water).filter_by(date=date).order_by(
model.Water.amount.desc())
distance = session.query(model.Workout).filter_by(
date=date, workout_id=model.WORKOUTS['distance']['id']).order_by(
model.Workout.amount.desc())
res = {}
res['Water'] = get_dict_for_water(bot, date)[:5]
res['Distance'] = get_dict_for_distance(bot, date)[:5]
for key in model.WORKOUTS:
if key == 'distance':
continue
res[model.WORKOUTS[key]['name']] = get_dict_for_workout(
bot, date, key)[:5]
return res
async def timer_handler(self):
time = datetime.datetime.now()
session = model.Session()
query = session.query(model.Timer).filter(model.Timer.time < time)
for timer in query:
msg = f"Reminder for {self.bot.get_user(timer.user_id).mention}!"
if timer.message:
msg = f"{msg} {timer.message}"
channel = get_channel_from_name(self.bot,
self.settings.get('io_channel'))
log.debug(f'[TIMR] Responding to ID: {timer}')
try:
await channel.send(msg)
session.delete(timer)
except:
log.debug(
f"[TIMR] Failed to send timer message. Going to try again later."
)
session.rollback()
session.commit()
async def drank(self, ctx, user=None):
if ctx.channel.name != self.settings.get('io_channel'):
return
session = model.Session()
if user:
try:
target = self.bot.get_user(int(user[3:-1]))
except:
target = ctx.author
else:
target = ctx.author
water_log = session.query(model.Water).filter_by(
user_id=target.id, date=datetime.date.today()).first()
if not water_log:
msg = f"{target.mention}"
if target == ctx.author:
await ctx.channel.send(
f"{target.mention}, you have not logged any water today. Get drinking!"
)
else:
await ctx.channel.send(
f"{target.mention} has not logged water today.")
return
val = float(water_log.amount)
if target == ctx.author:
await ctx.channel.send(
f"{target.mention}, you have logged {vol_print(val)} of water today."
)
else:
await ctx.channel.send(
f"{target.mention} has logged {vol_print(val)} of water today."
)
async def daily(self, ctx: commands.Context):
if ctx.channel.name != self.settings.get('io_channel'):
return
session = model.Session()
date = datetime.date.today()
distance_log = session.query(model.Workout).filter_by(
user_id=ctx.author.id,
date=date,
workout_id=model.WORKOUTS['distance']['id']).first()
water_log = session.query(model.Water).filter_by(user_id=ctx.author.id,
date=date).first()
user_settings = session.query(
model.Settings).filter_by(user_id=ctx.author.id).first()
resp = {}
setting = user_settings and user_settings.water_goal
if water_log or setting:
resp['Water'] = {}
resp['Water']['Achieved'] = False
resp['Water']['Value'] = Water.vol_print(float(
water_log.amount)) if water_log else 0
if setting:
if water_log and water_log.amount and float(
water_log.amount) >= float(user_settings.water_goal):
resp['Water']['Achieved'] = True
resp['Water']['Goal'] = Water.vol_print(
float(user_settings.water_goal))
for key in model.WORKOUTS:
if key == 'distance':
continue
goal = Workout.get_goal_from_id(user_settings,
key) if user_settings else None
workout_log = session.query(model.Workout).filter_by(
user_id=ctx.author.id,
date=date,
workout_id=model.WORKOUTS[key]['id']).first()
if workout_log or goal:
resp[model.WORKOUTS[key]['name']] = {}
resp[model.WORKOUTS[key]['name']]['Achieved'] = False
resp[model.WORKOUTS[key]['name']][
'Value'] = workout_log.amount if workout_log else 0
if goal:
if resp[model.WORKOUTS[key]['name']]['Value'] >= goal:
resp[model.WORKOUTS[key]['name']]['Achieved'] = True
resp[model.WORKOUTS[key]['name']]['Goal'] = goal
setting = user_settings and user_settings.distance_goal
if distance_log or setting:
resp['Distance'] = {}
resp['Distance']['Achieved'] = False
resp['Distance']['Value'] = Workout.dst_print(
float(distance_log.amount)) if distance_log else 0
if setting:
if distance_log and distance_log.amount and float(
distance_log.amount) >= float(
user_settings.distance_goal):
resp['Distance']['Achieved'] = True
resp['Distance']['Goal'] = Workout.dst_print(
float(user_settings.distance_goal))
await ctx.channel.send(embed=daily_embed(ctx.author, resp))
