841 lines
34 KiB
Python
841 lines
34 KiB
Python
import re
|
|
from collections import defaultdict
|
|
from datetime import datetime, timedelta
|
|
from typing import Optional
|
|
import twitchio
|
|
from twitchio import PartialUser, Scopes, eventsub
|
|
from twitchio.ext import commands as cmds
|
|
|
|
from data.queries import JOINTYPE, ORDER
|
|
from meta import Bot, Context
|
|
from meta.sockets import Channel, register_channel
|
|
from utils.lib import utc_now, strfdelta
|
|
|
|
from . import logger
|
|
from .data import SubathonData, Subathon, RunningSubathon, SubathonContribution, SubathonGoal
|
|
from .subathon import ActiveSubathon, SubathonRegistry
|
|
from .channel import SubathonPayload, prepare_subathon, TimerChannel
|
|
|
|
|
|
class SubathonComponent(cmds.Component):
|
|
"""
|
|
!subathon
|
|
!subathon setup <initial_hours> <t1score> <t2score> <t3score> <bitscore> <timescore> [cap]
|
|
!subathon stop
|
|
|
|
!subathon link
|
|
!subathon pause
|
|
!subathon resume
|
|
|
|
!subathon adjust <amount> [@user]
|
|
|
|
!subathon config
|
|
!subathon config name [new name]
|
|
!subathon config cap [new cap]
|
|
!subathon config scores [<t1score> <t2score> <t3score> <bitscore>]
|
|
!subathon config timescore [new score]
|
|
|
|
!subathon lb
|
|
|
|
!goals
|
|
!goals remaining
|
|
!goals add <points> <description>
|
|
!goals remove <points>
|
|
|
|
|
|
Command:
|
|
Permissions:
|
|
Description:
|
|
Examples:
|
|
"""
|
|
# TODO: Add explicit dependencies and version checks
|
|
# for profile and event tracker modules
|
|
|
|
def __init__(self, bot: Bot):
|
|
self.bot = bot
|
|
self.data = bot.dbconn.load_registry(SubathonData())
|
|
self.subathons = SubathonRegistry(self.data, bot.profiles.profiles)
|
|
self.channel = TimerChannel(self.bot.profiles.profiles, self.subathons)
|
|
|
|
register_channel('SubTimer', self.channel)
|
|
|
|
# ----- API -----
|
|
async def component_load(self):
|
|
await self.data.init()
|
|
await self.subathons.init()
|
|
await self.bot.version_check(*self.data.VERSION)
|
|
|
|
async def component_teardown(self):
|
|
pass
|
|
|
|
async def dispatch_update(self, subathon: ActiveSubathon):
|
|
# TODO: Fix confusion of responsibility for preparation
|
|
cid = subathon.subathondata.communityid
|
|
payload = await prepare_subathon(self.bot.profiles.profiles, subathon)
|
|
await self.channel.send_subathon_update(cid, payload)
|
|
|
|
# ----- Methods -----
|
|
async def get_active_subathon(self, *args, **kwargs):
|
|
return await self.subathons.get_active_subathon(*args, **kwargs)
|
|
|
|
async def goalcheck(self, active: ActiveSubathon, channel: PartialUser):
|
|
goals = await active.get_goals()
|
|
score = await active.get_score()
|
|
for i, goal in enumerate(goals):
|
|
if not goal.notified and goal.required_score <= score:
|
|
# Goal completed, notify channel
|
|
await channel.send_message(
|
|
f"We have reached Goal #{i+1}: {goal.description} !! Thank you everyone for your support <3",
|
|
sender=self.bot.bot_id,
|
|
)
|
|
await goal.update(notified=True)
|
|
|
|
# ----- Event Handlers -----
|
|
# Blerp handler
|
|
@cmds.Component.listener()
|
|
async def event_message(self, message: twitchio.ChatMessage):
|
|
if message.chatter.id not in ('253326823', '1361913054'):
|
|
return
|
|
if 'bits' not in message.text:
|
|
return
|
|
community = await self.bot.profiles.fetch_community(message.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None and not await active.check_finished():
|
|
# Extract count and user
|
|
match = re.match(r"(?P<name>\w+) used (?P<amount>\d+)", message.text)
|
|
if not match:
|
|
match = re.match(r"!For (?P<amount>\d+) bits, (?P<name>\w+)", message.text)
|
|
if match:
|
|
amount = int(match['amount'])
|
|
name = match['name']
|
|
# This is for giving the contribution to the calling user
|
|
# user = await self.bot.fetch_user(login=name.lower())
|
|
user = await message.chatter.user()
|
|
profile = await self.bot.profiles.fetch_profile(user)
|
|
pid = profile.profileid
|
|
|
|
score = amount * active.subathondata.bit_score
|
|
contrib = await active.add_contribution(pid, score, None)
|
|
await self.dispatch_update(active)
|
|
logger.info(f"Blerp contribution: {contrib!r} from {message!r}")
|
|
else:
|
|
logger.warning(f"Unknown blerp bit message: {message!r}")
|
|
|
|
@cmds.Component.listener()
|
|
async def event_safe_bits_use(self, payload):
|
|
event_row, detail_row, bits_payload = payload
|
|
if (active := await self.get_active_subathon(event_row['communityid'])) is not None and not await active.check_finished():
|
|
# In an active subathon
|
|
pid = event_row['profileid']
|
|
uid = event_row['user_id']
|
|
score = detail_row['bits'] * active.subathondata.bit_score
|
|
await active.add_contribution(pid, score, event_row['event_id'])
|
|
|
|
# Send message to channel
|
|
sec = active.get_score_time(score)
|
|
added_min = int(sec // 60)
|
|
if added_min > 0:
|
|
added = f"{added_min} minutes"
|
|
else:
|
|
added = f"{sec} seconds"
|
|
name = bits_payload.user.name
|
|
pl = 's' if bits_payload.bits != 1 else ''
|
|
|
|
contrib_str = f"{name} contributed {score} point{pl}"
|
|
if not await active.check_cap():
|
|
contrib_str += f" and added {added} to the timer! Thank you <3"
|
|
else:
|
|
contrib_str += " towards our subathon! Thank you <3"
|
|
|
|
await bits_payload.broadcaster.send_message(
|
|
contrib_str,
|
|
sender=self.bot.bot_id
|
|
)
|
|
await self.dispatch_update(active)
|
|
await self.goalcheck(active, bits_payload.broadcaster)
|
|
# Check goals
|
|
|
|
@cmds.Component.listener()
|
|
async def event_safe_subscription(self, payload):
|
|
event_row, detail_row, sub_payload = payload
|
|
if sub_payload.gift:
|
|
# Ignore gifted here
|
|
return
|
|
|
|
if (active := await self.get_active_subathon(event_row['communityid'])) is not None and not await active.check_finished():
|
|
data = active.subathondata
|
|
# In an active subathon
|
|
pid = event_row['profileid']
|
|
tier = int(sub_payload.tier)
|
|
|
|
if tier == 1000:
|
|
mult = data.sub1_score
|
|
elif tier == 2000:
|
|
mult = data.sub2_score
|
|
elif tier == 3000:
|
|
mult = data.sub3_score
|
|
else:
|
|
raise ValueError(f"Unknown sub tier {sub_payload.tier}")
|
|
|
|
score = mult * 1
|
|
|
|
await active.add_contribution(pid, score, event_row['event_id'])
|
|
|
|
# Send message to channel
|
|
added_min = int(active.get_score_time(score) // 60)
|
|
added = f"{added_min} minutes"
|
|
name = sub_payload.user.name
|
|
pl = 's' if score > 1 else ''
|
|
|
|
contrib_str = f"{name} contributed {score} point{pl}"
|
|
if not await active.check_cap():
|
|
contrib_str += f" and added {added} to the timer! Thank you <3"
|
|
else:
|
|
contrib_str += " towards our subathon! Thank you <3"
|
|
|
|
await sub_payload.broadcaster.send_message(
|
|
contrib_str,
|
|
sender=self.bot.bot_id
|
|
)
|
|
await self.dispatch_update(active)
|
|
# Check goals
|
|
await self.goalcheck(active, sub_payload.broadcaster)
|
|
|
|
@cmds.Component.listener()
|
|
async def event_safe_subscription_gift(self, payload):
|
|
event_row, detail_row, gift_payload = payload
|
|
|
|
if (active := await self.get_active_subathon(event_row['communityid'])) is not None and not await active.check_finished():
|
|
data = active.subathondata
|
|
# In an active subathon
|
|
pid = event_row['profileid']
|
|
|
|
tier = int(gift_payload.tier)
|
|
if tier == 1000:
|
|
mult = data.sub1_score
|
|
elif tier == 2000:
|
|
mult = data.sub2_score
|
|
elif tier == 3000:
|
|
mult = data.sub3_score
|
|
else:
|
|
raise ValueError(f"Unknown sub tier {gift_payload.tier}")
|
|
|
|
score = mult * gift_payload.total
|
|
|
|
await active.add_contribution(pid, score, event_row['event_id'])
|
|
|
|
# Send message to channel
|
|
added_min = int(active.get_score_time(score) // 60)
|
|
added = f"{added_min} minutes"
|
|
name = gift_payload.user.name if gift_payload.user else 'Anonymous'
|
|
|
|
contrib_str = f"{name} contributed {score} points"
|
|
if not await active.check_cap():
|
|
contrib_str += f" and added {added} to the timer! Thank you <3"
|
|
else:
|
|
contrib_str += " towards our subathon! Thank you <3"
|
|
|
|
await gift_payload.broadcaster.send_message(
|
|
contrib_str,
|
|
sender=self.bot.bot_id
|
|
)
|
|
await self.dispatch_update(active)
|
|
# Check goals
|
|
await self.goalcheck(active, gift_payload.broadcaster)
|
|
|
|
@cmds.Component.listener()
|
|
async def event_safe_subscription_message(self, payload):
|
|
event_row, detail_row, sub_payload = payload
|
|
|
|
if (active := await self.get_active_subathon(event_row['communityid'])) is not None and not await active.check_finished():
|
|
data = active.subathondata
|
|
# In an active subathon
|
|
pid = event_row['profileid']
|
|
tier = int(sub_payload.tier)
|
|
|
|
if tier == 1000:
|
|
mult = data.sub1_score
|
|
elif tier == 2000:
|
|
mult = data.sub2_score
|
|
elif tier == 3000:
|
|
mult = data.sub3_score
|
|
else:
|
|
raise ValueError(f"Unknown sub tier {sub_payload.tier}")
|
|
|
|
score = mult * 1
|
|
|
|
await active.add_contribution(pid, score, event_row['event_id'])
|
|
|
|
# Send message to channel
|
|
added_min = int(active.get_score_time(score) // 60)
|
|
added = f"{added_min} minutes"
|
|
name = sub_payload.user.name
|
|
pl = 's' if score > 1 else ''
|
|
|
|
contrib_str = f"{name} contributed {score} points{pl}"
|
|
if not await active.check_cap():
|
|
contrib_str += f" and added {added} to the timer! Thank you <3"
|
|
else:
|
|
contrib_str += " towards our subathon! Thank you <3"
|
|
|
|
await sub_payload.broadcaster.send_message(
|
|
contrib_str,
|
|
sender=self.bot.bot_id
|
|
)
|
|
await self.dispatch_update(active)
|
|
# Check goals
|
|
await self.goalcheck(active, sub_payload.broadcaster)
|
|
|
|
# end stream => Automatically pause the timer
|
|
@cmds.Component.listener()
|
|
async def event_stream_offline(self, payload: twitchio.StreamOffline):
|
|
community = await self.bot.profiles.fetch_community(payload.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
if active.running:
|
|
await active.pause()
|
|
if not await active.check_finished():
|
|
await payload.broadcaster.send_message(
|
|
"Paused the subathon timer because the stream went offline!",
|
|
sender=self.bot.bot_id
|
|
)
|
|
await self.dispatch_update(active)
|
|
|
|
# ----- Commands -----
|
|
|
|
@cmds.group(name='subathon', aliases=['studython'], invoke_fallback=True)
|
|
async def group_subathon(self, ctx: cmds.Context):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
score = await active.get_score()
|
|
goals = await active.get_goals()
|
|
total_goals = len(goals)
|
|
donegoals = len([goal for goal in goals if score >= goal.required_score])
|
|
goalstr = f"{donegoals}/{total_goals} goals achieved"
|
|
|
|
dursecs = await active.get_duration()
|
|
duration = strfdelta(timedelta(seconds=dursecs))
|
|
|
|
secs = await active.get_remaining()
|
|
if secs > 0:
|
|
remaining = strfdelta(timedelta(seconds=secs))
|
|
|
|
text = (
|
|
f"{active.name} running for {duration}! {score} points recieved, {goalstr}, and {remaining} left on the timer"
|
|
)
|
|
else:
|
|
text = (
|
|
f"{active.name} completed after {duration} with a total of {score} points, and {goalstr}!"
|
|
)
|
|
|
|
await ctx.reply(text)
|
|
else:
|
|
await ctx.reply("No active subathon running!")
|
|
|
|
# subathon start
|
|
# TODO: Usage line on command error
|
|
@group_subathon.command(name='setup', alias='start')
|
|
@cmds.is_broadcaster()
|
|
async def cmd_setup(self, ctx: cmds.Context, initial_hours: float, sub1: float, sub2: float, sub3: float, bit: float, timescore: int, timecap: Optional[int]=None):
|
|
"""
|
|
Creates a new subathon.
|
|
USAGE: {prefix}subathon setup <initial_hours> <sub1_points> <sub2_points> <sub3_points> <bit_points> <timepoints> [timecap]
|
|
Arguments:
|
|
initial_hours = number of hours to start the timer with
|
|
sub1_points = points per T1 sub
|
|
sub2_points = points per T2 sub
|
|
sub3_points = points per T3 sub
|
|
bit_points = points per bit
|
|
timepoints = seconds to be added to the timer per point
|
|
timecap (optional) = number of hours to cap the timer at
|
|
"""
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
await ctx.reply("There is already an active subathon running! Use !subathon stop to stop it!")
|
|
return
|
|
initial_time = initial_hours * 60 * 60
|
|
timecap_seconds = timecap * 60 * 60 if timecap else None
|
|
|
|
subdata = await Subathon.create(
|
|
name="Subathon",
|
|
communityid=cid,
|
|
initial_time=initial_time,
|
|
sub1_score=sub1,
|
|
sub2_score=sub2,
|
|
sub3_score=sub3,
|
|
bit_score=bit,
|
|
score_time=timescore,
|
|
timecap=timecap_seconds
|
|
)
|
|
base_timer_url = self.bot.config.subathon['timer_url']
|
|
timer_link = f"{base_timer_url}?community={cid}"
|
|
await ctx.reply(
|
|
f"Setup your subathon! "
|
|
f"Use {ctx.prefix}subathon resume to get the timer running. "
|
|
f"Use {ctx.prefix}subathon config to see and set options, including the name. "
|
|
f"Your timer link for OBS: {timer_link}"
|
|
)
|
|
active = ActiveSubathon(subdata, None)
|
|
await self.dispatch_update(active)
|
|
|
|
# subathon stop
|
|
@group_subathon.command(name='stop')
|
|
@cmds.is_broadcaster()
|
|
async def cmd_stop(self, ctx: cmds.Context):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
if active.running:
|
|
await active.pause()
|
|
await self.dispatch_update(active)
|
|
await active.subathondata.update(ended_at=utc_now())
|
|
total = await active.get_score()
|
|
dursecs = await active.get_duration()
|
|
dur = strfdelta(timedelta(seconds=dursecs))
|
|
|
|
await ctx.reply(
|
|
f"{active.name} ended after {dur} with a total of {total} points, congratulations!"
|
|
)
|
|
else:
|
|
await ctx.reply("No active subathon to stop.")
|
|
|
|
# subathon link
|
|
@group_subathon.command(name='link')
|
|
@cmds.is_moderator()
|
|
async def cmd_link(self, ctx: cmds.Context):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
base_timer_url = self.bot.config.subathon['timer_url']
|
|
timer_link = f"{base_timer_url}?community={cid}"
|
|
await ctx.reply(
|
|
timer_link
|
|
)
|
|
else:
|
|
await ctx.reply("No active subathon to stop.")
|
|
|
|
# subathon pause
|
|
@group_subathon.command(name='pause')
|
|
@cmds.is_moderator()
|
|
async def cmd_pause(self, ctx: cmds.Context):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
if active.running:
|
|
await active.pause()
|
|
await ctx.reply(f"{active.name} timer paused!")
|
|
await self.dispatch_update(active)
|
|
else:
|
|
await ctx.reply(f"{active.name} timer already paused!")
|
|
else:
|
|
await ctx.reply("No active subathon to pause")
|
|
|
|
# subathon resume
|
|
@group_subathon.command(name='resume')
|
|
@cmds.is_moderator()
|
|
async def cmd_resume(self, ctx: cmds.Context):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
if active.running:
|
|
await ctx.reply(f"{active.name} timer already running!")
|
|
elif await active.check_finished():
|
|
await ctx.reply(f"{active.name} has already finished!")
|
|
else:
|
|
await active.resume()
|
|
await ctx.reply(f"{active.name} timer resumed!")
|
|
await self.dispatch_update(active)
|
|
else:
|
|
await ctx.reply("No active subathon to resume")
|
|
|
|
# subathon adjust
|
|
@group_subathon.command(name='adjust')
|
|
@cmds.is_moderator()
|
|
async def cmd_subathon_adjust(self, ctx: Context, amount: int, *, user: Optional[twitchio.User] = None):
|
|
"""
|
|
Directly add or remove points from the subathon.
|
|
If a user is provided, will adjust their contributed amount.
|
|
USAGE:
|
|
{prefix}subathon adjust <amount> [@user]
|
|
Arguments:
|
|
'amount' is an integer number of points to adjust by.
|
|
It may be negative to remove points.
|
|
'@user' is an optional user name or mention to adjust for.
|
|
Examples:
|
|
'{prefix}subathon adjust 10'
|
|
'{prefix}subathon adjust -10 @machinestalkerwolfie'
|
|
"""
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
if user is not None:
|
|
profile = await self.bot.profiles.fetch_profile(user)
|
|
name = user.display_name or profile.nickname or 'Unknown'
|
|
pid = profile.profileid
|
|
else:
|
|
profile = None
|
|
name = None
|
|
pid = None
|
|
await active.add_contribution(pid, amount, None)
|
|
await self.dispatch_update(active)
|
|
|
|
# Build message
|
|
if amount > 0:
|
|
amountstr = f"Added {amount} point(s) to the timer"
|
|
elif amount < 0:
|
|
amountstr = f"Removed {-amount} point(s) from the timer"
|
|
else:
|
|
amountstr = "Did nothing to the timer"
|
|
|
|
namestr = f"on behalf of {name}" if profile else ""
|
|
message = f"{amountstr} {namestr}"
|
|
await ctx.reply(message)
|
|
else:
|
|
await ctx.reply("No active subathon to adjust")
|
|
|
|
"""
|
|
!subathon config
|
|
name="Birthday Subathon" ; cap=10 (hours) ; scores=5 10 20 0.1 (t1, t2, t3, and bit points) ; timescore=10 (seconds per point); Use !subathon config <option> [value] to see or set individual options
|
|
!subathon config name [value]
|
|
!subathon config cap [value]
|
|
!subathon config scores [value]
|
|
!subathon config timescore [value]
|
|
|
|
!subathon config name
|
|
Name of the subathon, used whenever the subathon is mentioned.
|
|
Accepts any string. Example: !subathon config name Birthday Subathon
|
|
!subathon config cap
|
|
Duration cap of the subathon, in hours, including the initial time.
|
|
The subathon may still be contributed to after this time, but contributions
|
|
will not raise the timer.
|
|
Accepts an integer, with 0 to unset. Example: !subathon config cap 10
|
|
!subathon config scores
|
|
The number of points each type of contribution (t1 sub, t2 sub, t3 sub, 1 bit)
|
|
will add to the subathon. Not retroactive. Accepts four floats.
|
|
Example: !subathon config scores 5 10 20 0.1
|
|
!subathon config timescore
|
|
The number of seconds each contributed point adds to the timer.
|
|
WARNING: This setting is retroactive and should generally not be changed.
|
|
Accepts an integer. Example: !subathon config timecap 10
|
|
"""
|
|
@group_subathon.group(name='config', aliases=('option',), invoke_fallback=True)
|
|
@cmds.is_moderator()
|
|
async def subathon_config_grp(self, ctx: Context, *, args: Optional[str] = None):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is None:
|
|
await ctx.reply("No active subathon to configure!")
|
|
return
|
|
if args:
|
|
await ctx.reply(
|
|
f"USAGE: {ctx.prefix}subathon config [option [value]]\n"
|
|
f"Use '{ctx.prefix}subathon config' to see available options and current values."
|
|
)
|
|
return
|
|
|
|
parts = []
|
|
|
|
sdata = active.subathondata
|
|
|
|
# name
|
|
parts.append(
|
|
f"name=\"{sdata.name}\""
|
|
)
|
|
|
|
# timecamp
|
|
cap = sdata.timecap or 0
|
|
caph = int(cap / 3600)
|
|
parts.append(
|
|
f"cap={caph} (hours, 0 means no cap)"
|
|
)
|
|
|
|
# scores
|
|
scores = map(float, (sdata.sub1_score, sdata.sub2_score, sdata.sub3_score, sdata.bit_score))
|
|
scorestr = ' '.join(map(str, scores))
|
|
parts.append(
|
|
f"scores={scorestr} (t1, t2, t3, and 1 bit point scores)"
|
|
)
|
|
|
|
# timescore
|
|
parts.append(
|
|
f"timescore={sdata.score_time} (seconds per point)"
|
|
)
|
|
|
|
# Combine
|
|
partstr = ' ; '.join(parts)
|
|
await ctx.reply(
|
|
f"{partstr} ; Use {ctx.prefix}subathon config <option> [value] to see or set each option!"
|
|
)
|
|
|
|
@subathon_config_grp.command(name='name')
|
|
@cmds.is_moderator()
|
|
async def subathon_config_name_cmd(self, ctx: Context, *, args: Optional[str] = None):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is None:
|
|
await ctx.reply("No active subathon to configure!")
|
|
return
|
|
|
|
if args:
|
|
# Setting path
|
|
await active.subathondata.update(name=args)
|
|
await self.dispatch_update(active)
|
|
await ctx.reply(f"Updated the subathon name to \"{args}\"")
|
|
else:
|
|
# Display path
|
|
name = active.subathondata.name
|
|
await ctx.reply(
|
|
"Name of the subathon, used whenever the subathon is mentioned. "
|
|
"Accepts any string. "
|
|
f"Currently: \"{name}\" "
|
|
f"Example: {ctx.prefix}subathon config name Birthday Subathon"
|
|
)
|
|
|
|
@subathon_config_grp.command(name='cap')
|
|
@cmds.is_moderator()
|
|
async def subathon_config_cap_cmd(self, ctx: Context, *, args: Optional[str] = None):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is None:
|
|
await ctx.reply("No active subathon to configure!")
|
|
return
|
|
|
|
if args:
|
|
# Setting path
|
|
if args.lower() in ('none',):
|
|
args = '0'
|
|
|
|
if not args.isdigit():
|
|
await ctx.reply("Provided timer cap must be an integer number of hours!")
|
|
return
|
|
|
|
new_cap = int(args)
|
|
if new_cap <= 0:
|
|
# Unset the cap
|
|
await active.subathondata.update(timecap=None)
|
|
await self.dispatch_update(active)
|
|
await ctx.reply("The timer cap has been removed! To infinity and beyond!")
|
|
else:
|
|
# Set the cap
|
|
await active.subathondata.update(timecap=int(new_cap * 3600))
|
|
await self.dispatch_update(active)
|
|
await ctx.reply(f"The subathon timer has been capped to {new_cap} hours.")
|
|
else:
|
|
# Display path
|
|
current_cap = active.subathondata.timecap or 0
|
|
caph = int(current_cap / 3600)
|
|
await ctx.reply(
|
|
"Duration cap for this subathon, in hours, including the initial time. "
|
|
"Contributions given after the cap has been reached will be accepted, "
|
|
"but will not raise the timer. "
|
|
"Accepts an integer, with 0 meaning no cap. "
|
|
f"Currently: {caph} hours. "
|
|
f"Example: {ctx.prefix}subathon config cap 24"
|
|
)
|
|
|
|
@subathon_config_grp.command(name='scores')
|
|
@cmds.is_moderator()
|
|
async def subathon_config_scores_cmd(self, ctx: Context, *, args: Optional[str] = None):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is None:
|
|
await ctx.reply("No active subathon to configure!")
|
|
return
|
|
|
|
if args:
|
|
# Setting path
|
|
# Validate
|
|
splits = args.split()
|
|
if not len(splits) == 4 and all(split.isdecimal() for split in splits):
|
|
await ctx.reply(
|
|
f"USAGE: {ctx.prefix}subathon config socres [<t1score> <t2score> <t3score> <bitscore>]"
|
|
)
|
|
return
|
|
t1score, t2score, t3score, bitscore = map(float, splits)
|
|
await active.subathondata.update(
|
|
sub1_score=t1score,
|
|
sub2_score=t2score,
|
|
sub3_score=t3score,
|
|
bit_score=bitscore,
|
|
)
|
|
await self.dispatch_update(active)
|
|
await ctx.reply("Successfully updated subathon score table.")
|
|
else:
|
|
# Display path
|
|
sdata = active.subathondata
|
|
scores = map(float, (sdata.sub1_score, sdata.sub2_score, sdata.sub3_score, sdata.bit_score))
|
|
scorestr = ' '.join(map(str, scores))
|
|
|
|
await ctx.reply(
|
|
"The number of points each type of contribution (t1 sub, t2 sub, t3 sub, and 1 bit) "
|
|
"will add to the subathon. Not retroactive. "
|
|
"Accepts four floats. "
|
|
f"Currently: {scorestr} "
|
|
f"Example: {ctx.prefix}subathon config scores 5 10 20 0.1"
|
|
)
|
|
|
|
@subathon_config_grp.command(name='timescore')
|
|
@cmds.is_moderator()
|
|
async def subathon_config_timescore_cmd(self, ctx: Context, *, args: Optional[str] = None):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is None:
|
|
await ctx.reply("No active subathon to configure!")
|
|
return
|
|
|
|
if args:
|
|
# Setting path
|
|
if not args.isdigit():
|
|
await ctx.reply("Time score (seconds per point) must be an integer.")
|
|
return
|
|
await active.subathondata.update(score_time=int(args))
|
|
await self.dispatch_update(active)
|
|
await ctx.reply("Subathon time score updated (NOTE: This is retroactive).")
|
|
else:
|
|
# Display path
|
|
await ctx.reply(
|
|
"The number of seconds each contributed point adds to the timer. "
|
|
"WARNING: This setting is retroactive and should generally not be used. "
|
|
"Accepts an integer. "
|
|
f"Currently: {active.subathondata.score_time} (seconds per point) "
|
|
f"Example: {ctx.prefix}subathon config timescore 10"
|
|
)
|
|
|
|
@group_subathon.command(name='leaderboard', aliases=('top', 'lb',))
|
|
async def cmd_subathon_lb(self, ctx: Context):
|
|
"""
|
|
Display top contributors by points contributed, up to 10.
|
|
Anonymous contributions are gathered as one user.
|
|
"""
|
|
# TODO: Might want to extend stats to select/show last subathon as well
|
|
# IDEA: We could also offer full export as csv via web
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
caller_profile = await self.bot.profiles.fetch_profile(ctx.chatter)
|
|
caller_pid = caller_profile.profileid
|
|
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
# Get totals for all contributors
|
|
query = self.data.subathon_contributions.select_where(subathon_id=active.subathondata.subathon_id)
|
|
query.join('user_profiles', using=('profileid',), join_type=JOINTYPE.LEFT)
|
|
query.select('subathon_id', 'profileid', total="SUM(score)")
|
|
query.order_by('total', direction=ORDER.DESC)
|
|
query.group_by('subathon_id', 'profileid')
|
|
query.with_no_adapter()
|
|
results = await query
|
|
|
|
parts = []
|
|
caller_idx = None
|
|
for i, row in enumerate(results):
|
|
if pid := row['profileid']:
|
|
profile = await self.bot.profiles.profiles.get_profile(pid)
|
|
name = (profile.nickname if profile else None) or 'Unknown'
|
|
if pid == caller_pid:
|
|
caller_idx = i
|
|
else:
|
|
name = 'Anonymous'
|
|
score = row['total']
|
|
part = f"{name}: {score} points"
|
|
parts.append(part)
|
|
|
|
header = ""
|
|
leaderboard = ', '.join(parts[:10])
|
|
footer = ""
|
|
if len(parts) > 10:
|
|
header = f"{active.name} top 10 leaderboard: "
|
|
leaderboard = ', '.join(parts[:10])
|
|
if caller_idx is not None and caller_idx >= 10:
|
|
caller_part = parts[caller_idx]
|
|
footer = f" ... {caller_part}"
|
|
elif parts:
|
|
header = f"{active.name} contribution leaderboard: "
|
|
else:
|
|
header = "No contributions to show yet!"
|
|
|
|
message = f"{header} {leaderboard} {footer}"
|
|
await ctx.reply(message)
|
|
else:
|
|
await ctx.reply("No active subathon to show leaderboard of!")
|
|
|
|
# Subathon goals
|
|
@cmds.group(name='goals', invoke_fallback=True)
|
|
async def group_goals(self, ctx: cmds.Context):
|
|
# List the goals
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
goals = await active.get_goals()
|
|
goalstrs = []
|
|
for i, goal in enumerate(goals, start=1):
|
|
line = f"{goal.required_score} points: {goal.description}"
|
|
goalstrs.append(line)
|
|
|
|
if goals:
|
|
text = ', '.join(goalstrs)
|
|
await ctx.reply(f"{active.name} Goals! -- {text}")
|
|
else:
|
|
await ctx.reply("No goals have been configured!")
|
|
else:
|
|
await ctx.reply("No active subathon running!")
|
|
|
|
@group_goals.command(name='remaining', aliases=('left',))
|
|
async def cmd_goals_remaining(self, ctx: cmds.Context):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
score = await active.get_score()
|
|
goals = await active.get_goals()
|
|
goalstrs = []
|
|
for i, goal in enumerate(goals, start=1):
|
|
if goal.required_score > score:
|
|
line = f"{goal.required_score} points: {goal.description}"
|
|
goalstrs.append(line)
|
|
|
|
if goalstrs:
|
|
text = ', '.join(goalstrs)
|
|
await ctx.reply(f"{active.name} Goals Remaining -- {text}")
|
|
elif goals:
|
|
await ctx.reply("All goals completed, congratulations!")
|
|
else:
|
|
await ctx.reply("No goals have been configured!")
|
|
else:
|
|
await ctx.reply("No active subathon running!")
|
|
|
|
@group_goals.command(name='add')
|
|
@cmds.is_moderator()
|
|
async def cmd_add(self, ctx: cmds.Context, required: int, *, description: str):
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
await SubathonGoal.create(
|
|
subathon_id=active.subathondata.subathon_id,
|
|
required_score=required,
|
|
description=description,
|
|
)
|
|
await ctx.reply("Goal added!")
|
|
else:
|
|
await ctx.reply("No active subathon to add goal to!")
|
|
|
|
# remove
|
|
@group_goals.command(name='remove', aliases=['del', 'delete', 'rm'])
|
|
@cmds.is_moderator()
|
|
async def cmd_goals_remove(self, ctx: cmds.Context, required: int):
|
|
"""
|
|
Description:
|
|
Remove any goal(s) set at the given score.
|
|
"""
|
|
community = await self.bot.profiles.fetch_community(ctx.broadcaster)
|
|
cid = community.communityid
|
|
if (active := await self.get_active_subathon(cid)) is not None:
|
|
results = await SubathonGoal.table.delete_where(
|
|
subathon_id=active.subathondata.subathon_id,
|
|
required_score=required,
|
|
)
|
|
if results:
|
|
await ctx.reply(f"Score {required} goal(s) removed!")
|
|
else:
|
|
await ctx.reply(f"No goal set at {required} score to remove.")
|
|
|