auto-refresh base

untested

README.md

@@ -2,12 +2,9 @@
 Tlapbot is an [Owncast](https://owncast.online/) bot that adds channel points and
 channel point redeems to your Owncast page.
 
-Similar
-to [Twitch channel points](https://help.twitch.tv/s/article/viewer-channel-point-guide), Tlapbot rewards your viewers with points for watching, and allows them to spend their points on fun gimmicks, challenges, reaction requests, or whatever else you decide.
-
-Tlapbot makes use of [Owncast webhooks](https://owncast.online/thirdparty/webhooks/) for chat interactions and 
-[Owncast external actions](https://owncast.online/thirdparty/actions/) to display an informative dashboard.
-
+The goal is to have an experience similar
+to [Twitch channel points](https://help.twitch.tv/s/article/viewer-channel-point-guide) by making use of [Owncast webhooks](https://owncast.online/thirdparty/webhooks/) and 
+[External actions](https://owncast.online/thirdparty/actions/).
 ## Features
 The bot gives points to everyone in chat -- 10 points every 10 minutes by
 default, but the time interval and amount of points can be changed.
@@ -15,13 +12,11 @@ default, but the time interval and amount of points can be changed.
 The users in chat can then use their points on redeems -- rewards like "choose my
 background music", "choose what level to play next", "react to this video" etc.
 You can configure redeems to fit your stream and the activities you're
-doing, and sort them into categories that can be turned on and off.
+doing.
 
 The redeems then show on a "Redeems dashboard" that everyone can view
 as an External Action on the Owncast stream, or at its standalone URL.
-This allows easy browsing of active challenges and recent redeems, without quitting the stream.
-
-**Tlapbot currently doesn't support any automated integrations (or an API). That means no 'Crowd Control' plugin, no instant effects in OBS or VTube Studio, etc. The streamer decides how they respond to redeems or how to make them take effect.** (I'd love to support more seamless, automatic redeems in the future!)
+This allows easy browsing of active challenges and recent redeems.
 ### Tlapbot bot commands
 Tlapbot has these basic commands:
 - `!help` sends a help string in the chat, explaining how tlapbot works.
@@ -32,6 +27,12 @@ Tlapbot has these basic commands:
 use the new prefix instead.)
 
 Tlapbot also automatically adds a command for each redeem in the redeems file.
+### Passive mode
+Tlapbot can also be run in passive mode. In passive mode, no redeems will be available, and Tlapbot will not send any messages.
+
+However, it will still give points to viewers, and track username changes.
+
+The Tlapbot dashboard will display a passive mode disclaimer instead of redeems.
 
 ### Tlapbot dashboard
 Tlapbot dashboard is a standalone page available at `/dashboard`, made to be easily viewable as an owncast external action. The Tlapbot dashboard shows all redeems and active counters.
@@ -51,16 +52,8 @@ The redeem queue shows a chronological list of note and list redeems with timest
 #### Redeems help tab
 The dashboard also has a "Redeems help" tab. It shows an explanation of redeem types,
 and lists all active redeems, along with their price, type and description.
-
-### Passive mode
-Tlapbot can also be run in passive mode. In passive mode, no redeems will be available, and Tlapbot will not send any messages.
-
-However, it will still give points to viewers, and track username changes.
-
-The Tlapbot dashboard will display a passive mode disclaimer instead of redeems.
-
 ### Tlapbot redeems types
-Tlapbot currently supports four different redeem types. Each type of a redeem
+Tlapbot currently supports three different redeem types. Each type of a redeem
 works slightly differently, and displays differently on the redeems dashboard.
 
 Redeems can also optionally be sorted into "categories" that can be turned on
@@ -97,16 +90,6 @@ Milestone redeems can be used as long-term community challenges, to start stream
 challenges, decide new games to play, etc.
 
 
-#### Polls
-Poll redeems are viewer votes, choices or answers. A poll can have multiple options,
-and viewers choose which option they're voting for. The dashboard then shows all options, their number of points (=number of votes), and a progress bar indicating which poll option is leading.
-
-Poll redeems can be used to decide what to do next, what game to play, or just a fun viewer interaction where people vote if they like pineapple on pizza.
-
-There is no "limit" or official closure of poll redeems.
-
-Polls only work if `POLLS_ENABLED` is `True` in the config.
-
 ## License & Contributions
 Tlapbot as it currently is does not come with a license. If you're a content creator, streamer, vtuber, etc. I'll be happy to give you permission to use Tlapbot, or make changes that'd fit your stream.
 
@@ -132,7 +115,7 @@ as a package in editable more.
     python -m flask init-db
     ```
 5. Create an `instance/config.py` file and fill it in as needed.
-Default values are included in `tlapbot/defaults/default_config.py`, and values in
+Default values are included in `tlapbot/default_config.py`, and values in
 `config.py` overwrite them. (The database also lives in the instance folder
 by default.)
 
@@ -143,7 +126,7 @@ by default.)
     OWNCAST_INSTANCE_URL # default points to localhost owncast on default port
     ```
 6. OPTIONAL: Create an `instance/redeems.py` file and add your custom redeems.  
-  If you don't add a redeems file, the bot will initialize the default redeems from `tlapbot/defaults/default_redeems.py`.  
+  If you don't add a redeems file, the bot will initialize the default redeems from `tlapbot/default_redeems.py`.  
   More details on how to write the config and redeems files are written later in the readme.
 7. If you've added any new counters or milestones, run `refresh-counters` or `refresh-milestones` commands to initialize them into the database.
 
@@ -292,19 +275,6 @@ Resets progress on a milestone, regardless of completion status.
 ```bash
 python -m flask hard-reset-milestone milestone
 ```
-
-#### refresh-polls
-Resets progress on all polls, removes old polls not in config, adds new polls from config.
-```bash
-python -m flask refresh-polls
-```
-
-#### reset-poll
-Resets progress on a single poll. (Can be used to add a single poll from config while not resetting the other polls.)
-```bash
-python -m flask reset-poll poll-name
-```
-
 ## Configuration files
 Configuration files should be in the instance folder. For folder installation of tlapbot,
 that's `instance/` from the root of the Github repository.
@@ -322,7 +292,7 @@ Including these values is mandatory if you want tlapbot to work.
 - `OWNCAST_ACCESS_TOKEN` is the owncast access token that owncast will use to get list of users in chat. Generate one in your owncast instance.
 - `OWNCAST_INSTANCE_URL` is the full URL of your owncast instance, like `"http://MyTlapbotServer.example"`
 #### Optional
-Including these values will overwrite their defaults from `/tlapbot/defaults/default_config.py`.
+Including these values will overwrite their defaults from `/tlapbot/default_config.py`.
 - `POINTS_CYCLE_TIME` decides how often channel points are given to users in chat,
 in seconds. 
 - `POINTS_AMOUNT_GIVEN` decides how many channel points users receive.
@@ -332,7 +302,6 @@ This makes the !help output quite long, so it's `False` by default.
 - `GUNICORN` if `True`, sets logging to use gunicorn's logger. Only set this to True if you're using Gunicorn to run tlapbot.
 - `ACTIVE_CATEGORIES` can be an empty list `[]`, or a list of strings of activated categories (i.e. `["chatting", "singing"]`). Redeems with a category included in the list will be active, redeems from other categories will not be active. Redeems with no category are always active.
 - `PREFIX` is a *single character string* that decides what character gets used as a prefix for tlapbot commands. (i.e. you can use `?` instead of `!`). Symbols are recommended. Prefix cannot be longer than one character.
-- `POLLS_ENABLED` decides if polls are enabled. `True` by default. You can disable polls by setting it to `False`.
 #### Example config:
 An example to show what your config like could look like
 ```python
@@ -344,7 +313,7 @@ LIST_REDEEMS=True
 ACTIVE_CATEGORIES=["gaming"]
 ```
 ### redeems.py
-`redeems.py` is a file where you define all your custom redeems. Tlapbot will work without it, but it will load a few default, generic redeems from `tlapbot/defaults/default_redeems.py`.
+`redeems.py` is a file where you define all your custom redeems. Tlapbot will work without it, but it will load a few default, generic redeems from `tlapbot/default_redeems.py`.
 
 (`redeems.py` should be in the instance folder: `instance/redeems.py` for folder install.)
 #### `default_redeems.py`:
@@ -358,11 +327,9 @@ REDEEMS={
     "inactive": {"price": 100, "type": "note", "info": "Example redeem that is inactive by default", "category": ["inactive"]}
 }
 ```
-
 #### File format
 `redeems.py` is a config file with just a `REDEEMS` key, that assigns a dictionary of redeems to it.
-Each dictionary entry is a redeem, and the dictionary keys are strings that decide the chat command for the redeem.
-The redeem names shouldn't have spaces in them.
+Each dictionary entry is a redeem, and the dictionary keys are strings that decides the chat command for the redeem.
 The value is another dictionary that needs to have an entry for `"type"` and
 an entry for `"price"` for non-milestones or `"goal"` for milestones.
 Optionally, each redeem can also have `"info"` and `"category"` entries.
@@ -375,14 +342,3 @@ Optionally, each redeem can also have `"info"` and `"category"` entries.
 If a category from the list is in `ACTIVE_CATEGORIES` from `config.py`,
 then the redeem will be active. It will not be active if none of the categories
 are in `ACTIVE_CATEGORIES`. Redeems with no category are always active.
-
-### polls.py
-`polls.py` is where you define your custom polls. Tlapbot will work without it, and you don't need to supply your file if you turned off polls.
-
-(`polls.py` should be in the instance folder: `instance/polls.py` for folder install.)
-```python
-POLLS={
-    "favourite_food2": {"info": "Vote for your favourite food.", "options": ["pizza", "soup", "curry", "schnitzel"]},
-    "test_other_thing": {"info": "thing", "options": ["no", "yes"]}
-}
-```

setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name='tlapbot',
-    version='1.2.2',
+    version='1.2.1',
     packages=find_packages(),
     include_package_data=True,
     install_requires=[

tlapbot/__init__.py

@@ -2,11 +2,14 @@ import os
 import logging
 from flask import Flask
 from apscheduler.schedulers.background import BackgroundScheduler
+from datetime import datetime
 from tlapbot.db import get_db
 from tlapbot.owncast_requests import is_stream_live, give_points_to_chat
+from tlapbot.redeems import remove_inactive_redeems 
+from tlapbot.helpers import (get_last_online_time, delete_last_online_time,
+        save_last_online_time)
 
-
-def create_app(test_config: None = None) -> Flask:
+def create_app(test_config=None):
     app = Flask(__name__, instance_relative_config=True)
     
     # ensure the instance folder exists
@@ -20,21 +23,11 @@ def create_app(test_config: None = None) -> Flask:
     app.config.from_mapping(
         DATABASE=os.path.join(app.instance_path, "tlapbot.sqlite")
     )
-    app.config.from_object('tlapbot.defaults.default_config')
-    app.config.from_object('tlapbot.defaults.default_redeems')
+    app.config.from_object('tlapbot.default_config')
+    app.config.from_object('tlapbot.default_redeems')
     app.config.from_pyfile('config.py', silent=True)
     app.config.from_pyfile('redeems.py', silent=True)
 
-    # set up polls if they're enabled
-    if app.config['POLLS_ENABLED']:
-        app.config.from_object('tlapbot.defaults.default_polls')
-        app.config.from_pyfile('polls.py', silent=True)
-
-        for poll in app.config['POLLS']:
-            if ' ' in poll:
-                app.logger.warning(f"Poll '{poll}' has spaces in its name.")
-                app.logger.warning("Poll with spaces are impossible to redeem.")
-
     # Make logging work for gunicorn-ran instances of tlapbot.
     if app.config['GUNICORN']:
         gunicorn_logger = logging.getLogger('gunicorn.error')
@@ -46,12 +39,6 @@ def create_app(test_config: None = None) -> Flask:
         raise RuntimeError("Prefix is >1 character. "
                            "Change your config to set 1-character prefix.")
 
-    # Check for spaces in redeems (they won't work)
-    for redeem in app.config['REDEEMS']:
-        if ' ' in redeem:
-            app.logger.warning(f"Redeem '{redeem}' has spaces in its name.")
-            app.logger.warning("Redeems with spaces are impossible to redeem.")
-
     # prepare webhooks and redeem dashboard blueprints
     from . import owncast_webhooks
     from . import tlapbot_dashboard
@@ -67,16 +54,19 @@ def create_app(test_config: None = None) -> Flask:
     app.cli.add_command(db.refresh_milestones_command)
     app.cli.add_command(db.reset_milestone_command)
     app.cli.add_command(db.hard_reset_milestone_command)
-    app.cli.add_command(db.refresh_polls_command)
-    app.cli.add_command(db.reset_poll_command)
     
     # scheduler job for giving points to users
-    def proxy_job() -> None:
+    def proxy_job():
         with app.app_context():
             if is_stream_live():
+                if get_last_online_time:
+                    delete_last_online_time()
                 app.logger.info("Stream is LIVE. Giving points to chat.")
                 give_points_to_chat(get_db())
             else:
+                if not get_last_online_time:
+                    # TODO: error state
+                    save_last_online_time(get_db(), datetime.now(), False)
                 app.logger.info("Stream is NOT LIVE. (Not giving points to chat.)")
 
     # start scheduler that will give points to users

tlapbot/db.py

@@ -1,13 +1,12 @@
 import sqlite3
 
 import click
-from flask import current_app, g, Flask
+from flask import current_app, g
 from flask.cli import with_appcontext
 
-from tlapbot.redeems.milestones import milestone_complete
+from tlapbot.redeems import milestone_complete
 
-
-def get_db() -> sqlite3.Connection:
+def get_db():
     if 'db' not in g:
         g.db = sqlite3.connect(
             current_app.config['DATABASE'],
@@ -18,14 +17,14 @@ def get_db() -> sqlite3.Connection:
     return g.db
 
 
-def close_db(*_args) -> None:
-    db: sqlite3.Connection = g.pop('db', None)
+def close_db(e=None):
+    db = g.pop('db', None)
 
     if db is not None:
         db.close()
 
 
-def insert_counters(db: sqlite3.Connection) -> bool:
+def insert_counters(db):
     for redeem, redeem_info in current_app.config['REDEEMS'].items():
         if redeem_info["type"] == "counter":
             try:
@@ -40,30 +39,17 @@ def insert_counters(db: sqlite3.Connection) -> bool:
     return True
 
 
-def insert_polls(db: sqlite3.Connection) -> bool:
-    for poll, poll_info in current_app.config['POLLS'].items():
-        for option in poll_info["options"]:
-            try:
-                db.execute(
-                    "INSERT INTO polls(poll_name, option, points) VALUES(?, ?, 0)",
-                    (poll, option)
-                )
-            except sqlite3.Error as e:
-                print(f"Failed inserting poll option {poll} {option} to db: {e.args[0]}")
-                return False
-    return True
-
-
-def init_db() -> bool:
+def init_db():
     db = get_db()
 
     with current_app.open_resource('schema.sql') as f:
         db.executescript(f.read().decode('utf8'))
 
-    return insert_counters(db)
+    if insert_counters(db):
+        return True
 
 
-def clear_redeem_queue() -> bool:
+def clear_redeem_queue():
     db = get_db()
 
     try:
@@ -75,65 +61,25 @@ def clear_redeem_queue() -> bool:
         )
         db.commit()
     except sqlite3.Error as e:
-        print("Error occurred deleting redeem queue:", e.args[0])
+        print("Error occured deleting redeem queue:", e.args[0])
         return False
     return True
 
 
-def refresh_counters() -> bool:
+def refresh_counters():
     db = get_db()
 
     try:
         db.execute("DELETE FROM counters")
         db.commit()
     except sqlite3.Error as e:
-        print("Error occurred deleting old counters:", e.args[0])
+        print("Error occured deleting old counters:", e.args[0])
         return False
-    return insert_counters(db)
-
-
-def populate_poll_options(db: sqlite3.Connection, poll: str) -> bool:
-    for option in current_app.config['POLLS'][poll]['options']:
-        db.execute(
-            "INSERT INTO polls(poll_name, points, option) VALUES(?, ?, ?)",
-            (poll, 0, option)
-        )
-    db.commit()
+    if insert_counters(db):
         return True
 
 
-def refresh_polls() -> bool:
-    db = get_db()
-    try:
-        db.execute("DELETE FROM polls")
-        db.commit()
-        for poll in current_app.config['POLLS']:
-            populate_poll_options(db, poll)
-        db.commit()
-    except sqlite3.Error as e:
-        print("Error occurred deleting old counters:", e.args[0])
-        return False
-    return insert_polls(db)
-
-
-def reset_poll(poll: str) -> bool:
-    if poll not in current_app.config['POLLS']:
-        print(f"Failed resetting poll, {poll} not in polls file.")
-        return False
-    try:
-        db = get_db()
-        db.execute(
-            "DELETE FROM polls WHERE poll_name = ?",
-            (poll,)
-        )
-        populate_poll_options(db, poll)
-        return True
-    except sqlite3.Error as e:
-        current_app.logger.error(f"Error occurred resetting poll: {e.args[0]}")
-        return False
-
-
-def refresh_milestones() -> bool:
+def refresh_milestones():
     db = get_db()
     # delete old milestones
     try:
@@ -164,7 +110,7 @@ def refresh_milestones() -> bool:
                 result = cursor.fetchone()
                 if result is None:
                     cursor.execute(
-                        "INSERT INTO milestones(name, progress, goal) VALUES(?, 0, ?)",
+                        "INSERT INTO milestones(name, progress, goal, complete) VALUES(?, 0, ?, FALSE)",
                         (redeem, redeem_info['goal'])
                     )
                 # update existing milestone to new goal
@@ -180,8 +126,8 @@ def refresh_milestones() -> bool:
     return True
 
 
-def reset_milestone(milestone: str) -> bool:
-    if milestone not in current_app.config['REDEEMS']:
+def reset_milestone(milestone):
+    if not milestone in current_app.config['REDEEMS']:
         print(f"Failed resetting milestone, {milestone} not in redeems file.")
         return False
     try:
@@ -191,19 +137,20 @@ def reset_milestone(milestone: str) -> bool:
             (milestone,)
         )
         db.execute(
-            "INSERT INTO milestones(name, progress, goal) VALUES(?, ?, ?)",
+            "INSERT INTO milestones(name, progress, goal, complete) VALUES(?, ?, ?, FALSE)",
             (milestone, 0, current_app.config['REDEEMS'][milestone]['goal'])
         )
         db.commit()
         return True
     except sqlite3.Error as e:
-        current_app.logger.error(f"Error occurred adding a milestone: {e.args[0]}")
+        current_app.logger.error(f"Error occured adding a milestone: {e.args[0]}")
         return False
 
 
+
 @click.command('init-db')
 @with_appcontext
-def init_db_command() -> None:
+def init_db_command():
     """Clear the existing data and create new tables."""
     if init_db():
         click.echo('Initialized the database.')
@@ -211,7 +158,7 @@ def init_db_command() -> None:
 
 @click.command('clear-queue')
 @with_appcontext
-def clear_queue_command() -> None:
+def clear_queue_command():
     """Remove all redeems from the redeem queue."""
     if clear_redeem_queue():
         click.echo('Cleared redeem queue.')
@@ -219,7 +166,7 @@ def clear_queue_command() -> None:
 
 @click.command('refresh-counters')
 @with_appcontext
-def refresh_counters_command() -> None:
+def refresh_counters_command():
     """Refresh counters from current config file.
     (Remove old ones, add new ones.)"""
     if refresh_counters():
@@ -228,7 +175,7 @@ def refresh_counters_command() -> None:
 
 @click.command('clear-refresh')
 @with_appcontext
-def refresh_and_clear_command() -> None:
+def refresh_and_clear_command():
     """Refresh counters and clear queue."""
     if refresh_counters() and clear_redeem_queue():
         click.echo('Counters refreshed and queue cleared.')
@@ -236,7 +183,7 @@ def refresh_and_clear_command() -> None:
 
 @click.command('refresh-milestones')
 @with_appcontext
-def refresh_milestones_command() -> None:
+def refresh_milestones_command():
     """Initialize all milestones from the redeems file, 
     delete milestones not in redeem file."""
     if refresh_milestones():
@@ -245,7 +192,7 @@ def refresh_milestones_command() -> None:
 
 @click.command('reset-milestone')
 @click.argument('milestone')
-def reset_milestone_command(milestone: str) -> None:
+def reset_milestone_command(milestone):
     """Resets a completed milestone back to zero."""
     if milestone_complete(get_db(), milestone):
         if reset_milestone(milestone):
@@ -257,31 +204,12 @@ def reset_milestone_command(milestone: str) -> None:
 
 @click.command('hard-reset-milestone')
 @click.argument('milestone')
-def hard_reset_milestone_command(milestone: str) -> None:
+def hard_reset_milestone_command(milestone):
     """Resets any milestone back to zero."""
     if reset_milestone(milestone):
         click.echo(f"Hard reset milestone {milestone}.")
 
 
-@click.command('refresh-polls')
-@with_appcontext
-def refresh_polls_command() -> None:
-    """Initialize all polls from the polls file,
-    delete polls not in polls file."""
-    if refresh_polls():
-        click.echo('Refreshed polls.')
-
-
-@click.command('reset-poll')
-@click.argument('poll')
-def reset_poll_command(poll: str) -> None:
-    """Resets polls progress back to zero."""
-    if reset_poll(poll):
-        click.echo(f"Reset poll {poll}.")
-    else:
-        click.echo(f"Could not reset poll {poll}.")
-
-
-def init_app(app: Flask) -> None:
+def init_app(app):
     app.teardown_appcontext(close_db)
     app.cli.add_command(init_db_command)

tlapbot/default_config.py

@@ -8,4 +8,3 @@ LIST_REDEEMS=False
 ACTIVE_CATEGORIES=[]
 GUNICORN=False
 PREFIX='!'
-POLLS_ENABLED=True

tlapbot/defaults/default_polls.py

@@ -1,3 +0,0 @@
-POLLS={
-    "favourite_food": {"info": "Vote for your favourite food.", "options": ["pizza", "soup", "curry", "schnitzel"]}
-}

tlapbot/help_message.py

@@ -2,29 +2,22 @@ from flask import current_app
 from tlapbot.owncast_requests import send_chat
 
 
-def send_help() -> None:
+def send_help():
     message = []
-    message.append("Tlapbot gives you points for being in chat, and then allows you to spend those points. <br>")
-    message.append(f"People connected to chat receive {current_app.config['POINTS_AMOUNT_GIVEN']} points every {current_app.config['POINTS_CYCLE_TIME']} seconds. <br>")
-    message.append("You can see your points and recent redeems in the Tlapbot dashboard. Look for a button to click under the stream window. <br>")
-    message.append("""Tlapbot commands: <br>
-        !help to see this help message. <br>
-        !points to see your points. <br>"""
+    message.append("Tlapbot gives you points for being in chat, and then allows you to spend those points.\n")
+    message.append(f"People connected to chat receive {current_app.config['POINTS_AMOUNT_GIVEN']} points every {current_app.config['POINTS_CYCLE_TIME']} seconds.\n")
+    message.append("You can see your points and recent redeems in the Tlapbot dashboard. Look for a button to click under the stream window.\n")
+    message.append("""Tlapbot commands:
+        !help to see this help message.
+        !points to see your points.\n"""
     )
     if current_app.config['LIST_REDEEMS']:
-        message.append("Active redeems: <br>")
+        message.append("Active redeems:\n")
         for redeem, redeem_info in current_app.config['REDEEMS'].items():
-            if redeem_info.get('category', None):
-                if not set(redeem_info['category']).intersection(set(current_app.config['ACTIVE_CATEGORIES'])):
-                    continue
-            if 'type' in redeem_info and redeem_info['type'] == 'milestone':
-                message.append(f"!{redeem} milestone with goal of {redeem_info['goal']}.")
-            else:
-                message.append(f"!{redeem} for {redeem_info['price']} points.")
             if 'info' in redeem_info:
-                message.append(f" {redeem_info['info']} <br>")
+                message.append(f"!{redeem} for {redeem_info['price']} points. {redeem_info['info']}\n")
             else:
-                message.append("<br>")
+                message.append(f"!{redeem} for {redeem_info['price']} points.\n")
     else:
         message.append("Check the dashboard for a list of currently active redeems.")
     send_chat(''.join(message))

tlapbot/owncast_helpers.py

@@ -1,12 +1,10 @@
 from flask import current_app
-from sqlite3 import Error, Connection
+from sqlite3 import Error
 from re import sub
-from typing import Tuple
-
 
 # # # db stuff # # #
-def read_users_points(db: Connection, user_id: str) -> int | None:
-    """Returns None and logs error in case of error, or if user doesn't exist."""
+def read_users_points(db, user_id):
+    """Errors out if user doesn't exist."""
     try:
         cursor = db.execute(
             "SELECT points FROM points WHERE id = ?",
@@ -14,12 +12,11 @@ def read_users_points(db: Connection, user_id: str) -> int | None:
         )
         return cursor.fetchone()[0]
     except Error as e:
-        current_app.logger.error(f"Error occurred reading points: {e.args[0]}")
-        current_app.logger.error(f"Of user: {user_id}")
+        current_app.logger.error(f"Error occured reading points: {e.args[0]}")
+        current_app.logger.error(f"To user: {user_id}")
 
 
-def read_all_users_with_username(db: Connection, username: str) -> list[Tuple[str, int]] | None:
-    """Returns None only if Error was logged."""
+def read_all_users_with_username(db, username):
     try:
         cursor = db.execute(
             "SELECT name, points FROM points WHERE name = ?",
@@ -28,11 +25,11 @@ def read_all_users_with_username(db: Connection, username: str) -> list[Tuple[st
         users = cursor.fetchall()
         return users
     except Error as e:
-        current_app.logger.error(f"Error occurred reading points by username: {e.args[0]}")
-        current_app.logger.error(f"Of everyone with username: {username}")
+        current_app.logger.error(f"Error occured reading points by username: {e.args[0]}")
+        current_app.logger.error(f"To everyone with username: {username}")
 
 
-def give_points_to_user(db: Connection, user_id: str, points: int) -> None:
+def give_points_to_user(db, user_id, points):
     try:
         db.execute(
             "UPDATE points SET points = points + ? WHERE id = ?",
@@ -40,11 +37,11 @@ def give_points_to_user(db: Connection, user_id: str, points: int) -> None:
         )
         db.commit()
     except Error as e:
-        current_app.logger.error(f"Error occurred giving points: {e.args[0]}")
+        current_app.logger.error(f"Error occured giving points: {e.args[0]}")
         current_app.logger.error(f"To user: {user_id} amount of points: {points}")
 
 
-def use_points(db: Connection, user_id: str, points: int) -> bool:
+def use_points(db, user_id, points):
     try:
         db.execute(
             "UPDATE points SET points = points - ? WHERE id = ?",
@@ -53,13 +50,12 @@ def use_points(db: Connection, user_id: str, points: int) -> bool:
         db.commit()
         return True
     except Error as e:
-        current_app.logger.error(f"Error occurred using points: {e.args[0]}")
+        current_app.logger.error(f"Error occured using points: {e.args[0]}")
         current_app.logger.error(f"From user: {user_id} amount of points: {points}")
         return False
 
 
-def user_exists(db: Connection, user_id: str) -> bool | None:
-    """Returns None only if an error was logged."""
+def user_exists(db, user_id):
     try:
         cursor = db.execute(
             "SELECT points FROM points WHERE id = ?",
@@ -69,11 +65,11 @@ def user_exists(db: Connection, user_id: str) -> bool | None:
             return False
         return True
     except Error as e:
-        current_app.logger.error(f"Error occurred checking if user exists: {e.args[0]}")
+        current_app.logger.error(f"Error occured checking if user exists: {e.args[0]}")
         current_app.logger.error(f"To user: {user_id}")
 
 
-def add_user_to_database(db: Connection, user_id: str, display_name: str) -> None:
+def add_user_to_database(db, user_id, display_name):
     """ Adds a new user to the database. Does nothing if user is already in."""
     try:
         cursor = db.execute(
@@ -95,25 +91,56 @@ def add_user_to_database(db: Connection, user_id: str, display_name: str) -> Non
             )
         db.commit()
     except Error as e:
-        current_app.logger.error(f"Error occurred adding user to db: {e.args[0]}")
+        current_app.logger.error(f"Error occured adding user to db: {e.args[0]}")
         current_app.logger.error(f"To user id: {user_id}, with display name: {display_name}")
 
 
-def change_display_name(db: Connection, user_id: str, new_name: str) -> None:
+def save_last_online_time(db, timestamp, from_owncast):
     try:
         db.execute(
+            "INSERT OVERWRITE last_online_time(id, last_online_time, from_owncast)",
+            (1, timestamp, from_owncast)
+        )
+        db.commit()
+    except Error as e:
+        current_app.logger.error(f"Error occured saving last online time: {e.args[0]}")
+        current_app.logger.error(f"Timestamp: {timestamp}, from_owncast: {from_owncast}")
+
+
+def get_last_online_time(db):
+    try:
+        cursor = db.execute(
+            "SELECT last_online_time FROM last_online_time WHERE id = 1"
+        )
+        last_online_time = cursor.fetchone()
+        return last_online_time
+    except Error as e:
+        current_app.logger.error(f"Error occured reading last online time: {e.args[0]}")
+
+
+def delete_last_online_time(db):
+    try:
+        db.execute("DELETE FROM last_online_time")
+        db.commit()
+    except Error as e:
+        current_app.logger.error(f"Error occured deleting last online time: {e.args[0]}")
+
+
+def change_display_name(db, user_id, new_name):
+    try:
+        cursor = db.execute(
             "UPDATE points SET name = ? WHERE id = ?",
             (new_name, user_id)
         )
         db.commit()
     except Error as e:
-        current_app.logger.error(f"Error occurred changing display name: {e.args[0]}")
+        current_app.logger.error(f"Error occured changing display name: {e.args[0]}")
         current_app.logger.error(f"To user id: {user_id}, with display name: {new_name}")
 
 
-def remove_duplicate_usernames(db: Connection, user_id: str, username: str) -> None:
+def remove_duplicate_usernames(db, user_id, username):
     try:
-        db.execute(
+        cursor = db.execute(
             """UPDATE points
             SET name = NULL
             WHERE name = ? AND NOT id = ?""",
@@ -121,12 +148,11 @@ def remove_duplicate_usernames(db: Connection, user_id: str, username: str) -> N
         )
         db.commit()
     except Error as e:
-        current_app.logger.error(f"Error occurred removing duplicate usernames: {e.args[0]}")
+        current_app.logger.error(f"Error occured removing duplicate usernames: {e.args[0]}")
 
 
 # # # misc. stuff # # #
-# This is now unused since rawBody attribute of the webhook now returns cleaned-up emotes.
-def remove_emoji(message: str) -> str:
+def remove_emoji(message):
     return sub(
         r'<img class="emoji" alt="(:.*?:)" title=":.*?:" src="/img/emoji/.*?">',
         r'\1',

tlapbot/owncast_requests.py

@@ -1,30 +1,28 @@
 import requests
 from flask import current_app
 from tlapbot.owncast_helpers import give_points_to_user
-from sqlite3 import Connection
-from typing import Any
 
 
-def is_stream_live() -> bool:
+def is_stream_live():
     url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/status'
     try:
         r = requests.get(url)
     except requests.exceptions.RequestException as e:
-        current_app.logger.error(f"Error occurred checking if stream is live: {e.args[0]}")
+        current_app.logger.error(f"Error occured checking if stream is live: {e.args[0]}")
         return False
     return r.json()["online"]
 
 
-def give_points_to_chat(db: Connection) -> None:
+def give_points_to_chat(db):
     url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/integrations/clients'
     headers = {"Authorization": "Bearer " + current_app.config['OWNCAST_ACCESS_TOKEN']}
     try:
         r = requests.get(url, headers=headers)
     except requests.exceptions.RequestException as e:
-        current_app.logger.error(f"Error occurred getting users to give points to: {e.args[0]}")
+        current_app.logger.error(f"Error occured getting users to give points to: {e.args[0]}")
         return
     if r.status_code != 200:
-        current_app.logger.error(f"Error occurred when giving points: Response code not 200.")
+        current_app.logger.error(f"Error occured when giving points: Response code not 200.")
         current_app.logger.error(f"Response code received: {r.status_code}.")
         current_app.logger.error(f"Check owncast instance url and access key.")
         return
@@ -33,17 +31,18 @@ def give_points_to_chat(db: Connection) -> None:
         give_points_to_user(db, user_id, current_app.config['POINTS_AMOUNT_GIVEN'])
 
 
-def send_chat(message: str) -> Any:
+def send_chat(message):
     url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/integrations/chat/send'
     headers = {"Authorization": "Bearer " + current_app.config['OWNCAST_ACCESS_TOKEN']}
     try:
         r = requests.post(url, headers=headers, json={"body": message})
     except requests.exceptions.RequestException as e:
-        current_app.logger.error(f"Error occurred sending chat message: {e.args[0]}")
+        current_app.logger.error(f"Error occured sending chat message: {e.args[0]}")
         return
     if r.status_code != 200:
-        current_app.logger.error(f"Error occurred when sending chat: Response code not 200.")
+        current_app.logger.error(f"Error occured when sending chat: Response code not 200.")
         current_app.logger.error(f"Response code received: {r.status_code}.")
         current_app.logger.error(f"Check owncast instance url and access key.")
         return
     return r.json()
+

tlapbot/owncast_webhooks.py

@@ -1,25 +1,37 @@
 from flask import Flask, request, json, Blueprint, current_app
-from sqlite3 import Connection
-from typing import Any
-from tlapbot.db import get_db
+from datetime import datetime
+from tlapbot.db import get_db, refresh_counters, clear_redeem_queue
 from tlapbot.owncast_requests import send_chat
 from tlapbot.owncast_helpers import (add_user_to_database, change_display_name,
-        read_users_points, remove_duplicate_usernames)
+        read_users_points, remove_duplicate_usernames, get_last_online_time, delete_last_online_time)
 from tlapbot.help_message import send_help
 from tlapbot.redeems_handler import handle_redeem
-from tlapbot.poll_handler import handle_poll_vote
 
+# might need datetime timestamp
 
 bp = Blueprint('owncast_webhooks', __name__)
 
 
 @bp.route('/owncastWebhook', methods=['POST'])
-def owncast_webhook() -> Any | None:
-    """Reads webhook json -- adds new users, removes duplicate usernames,
-    handles name changes and chat messages with commands.
-    Returns the 'data' json from the request."""
-    data: Any | None = request.json
-    db: Connection = get_db()
+def owncast_webhook():
+    data = request.json
+    db = get_db()
+
+    if data["type"] == "STREAM_STARTED":
+        # TODO: make this a function, import here and in init
+        delete_last_online_time(db)
+        last_online = get_last_online_time(db)
+        if last_online and current_app.config['AUTO_REFRESH']:
+            time_difference = datetime.now() - last_online
+            if time_difference.seconds//60 > current_app.config['RECONNECT_TIME']:
+                if refresh_counters() and clear_redeem_queue():
+                    current_app.logger.debug(f'Counters refreshed, redeem queue cleared.')
+                else:
+                    current_app.logger.error(
+                        f'Error occured when automatically clearing queue and resetting counters.'
+                    )
+    elif data["type"] == "STREAM_STOPPED":
+        save_last_online_time(db, datetime.now(), True)
 
     # Make sure user is in db before doing anything else.
     if data["type"] in ["CHAT", "NAME_CHANGED", "USER_JOINED"]:
@@ -42,25 +54,22 @@ def owncast_webhook() -> Any | None:
             user_id = data["eventData"]["user"]["id"]
             display_name = data["eventData"]["user"]["displayName"]
             current_app.logger.debug(f'New chat message from {display_name}:')
-            current_app.logger.debug(f'{data["eventData"]["rawBody"]}')
-            if data["eventData"]["rawBody"].startswith(f"{prefix}help"):
+            current_app.logger.debug(f'{data["eventData"]["body"]}')
+            if data["eventData"]["body"].startswith(f"{prefix}help"):
                 send_help()
-            elif data["eventData"]["rawBody"].startswith(f"{prefix}points"):
+            elif data["eventData"]["body"].startswith(f"{prefix}points"):
                 points = read_users_points(db, user_id)
                 if points is None:
                     send_chat("Error reading points.")
                 else:
                     send_chat(f"{display_name}'s points: {points}")
-            elif data["eventData"]["rawBody"].startswith(f"{prefix}name_update"):
+            elif data["eventData"]["body"].startswith(f"{prefix}name_update"):
                 # Forces name update in case bot didn't catch the NAME_CHANGE
                 # event. Also removes saved usernames from users with same name
                 # if user is authenticated.
                 change_display_name(db, user_id, display_name)
                 if data["eventData"]["user"]["authenticated"]:
                     remove_duplicate_usernames(db, user_id, display_name)
-            elif data["eventData"]["rawBody"].startswith(f"{prefix}vote"):
-                if current_app.config['POLLS_ENABLED']:
-                    handle_poll_vote(data["eventData"]["rawBody"], user_id)
-            elif data["eventData"]["rawBody"].startswith(prefix):
-                handle_redeem(data["eventData"]["rawBody"], user_id)
+            elif data["eventData"]["body"].startswith(prefix):
+                handle_redeem(data["eventData"]["body"], user_id)
     return data

tlapbot/poll_handler.py

@@ -1,34 +0,0 @@
-from sqlite3 import Connection
-from tlapbot.db import get_db
-from tlapbot.owncast_requests import send_chat
-from tlapbot.owncast_helpers import read_users_points, use_points
-from tlapbot.redeems.polls import poll_option_exists, vote_in_poll
-
-
-def handle_poll_vote(message: str, user_id: str) -> None:
-    split_message = message[5:].split(maxsplit=2)
-    if len(split_message) < 3:
-        send_chat("Can't vote for poll, not enough arguments in message.")
-        return
-    poll_name = split_message[0]
-    option = split_message[1]
-    poll_points = split_message[2]
-
-    db: Connection = get_db()
-    if not poll_option_exists(db, poll_name, option):
-        send_chat("Can't vote for poll, poll and option combination not found.")
-        return
-    if not poll_points.isdigit():
-        send_chat(f"Can't vote in {poll_name} poll, donation amount is not a number.")
-        return
-    user_points = read_users_points(db, user_id)
-    if not user_points:
-        send_chat(f"Can't vote in {poll_name} poll, failed to read users' points.")
-        return
-    poll_points = int(poll_points)
-    if user_points < poll_points:
-        send_chat(f"Can't vote in {poll_name} poll, you're voting with more points than you have.")
-        return
-    if (vote_in_poll(db, poll_name, option, poll_points) and 
-            use_points(db, user_id, poll_points)):
-        send_chat(f"{poll_points} points donated to {option} in poll {poll_name}")

tlapbot/redeems.py

@@ -0,0 +1,227 @@
+from flask import current_app
+from sqlite3 import Error
+from tlapbot.owncast_helpers import use_points
+
+def counter_exists(db, counter_name):
+    try:
+        cursor = db.execute(
+            "SELECT count FROM counters WHERE name = ?",
+            (counter_name,)
+        )
+        counter = cursor.fetchone()
+        if counter is None:
+            current_app.logger.warning("Counter not found in database.")
+            current_app.logger.warning("Maybe you forgot to run the refresh-counters CLI command "
+                                       "after you added a new counter to the config?")
+            return False
+        return True
+    except Error as e:
+        current_app.logger.error(f"Error occured checking if counter exists: {e.args[0]}")
+        current_app.logger.error(f"For counter: {counter_name}")
+
+
+def add_to_counter(db, counter_name):
+    if counter_exists(db, counter_name):
+        try:
+            cursor = db.execute(
+                "UPDATE counters SET count = count + 1 WHERE name = ?",
+                (counter_name,)
+            )
+            db.commit()
+            return True
+        except Error as e:
+            current_app.logger.error(f"Error occured adding to counter: {e.args[0]}")
+            current_app.logger.error(f"To counter: {counter_name}")
+    return False
+
+
+def add_to_redeem_queue(db, user_id, redeem_name, note=None):
+    try:
+        cursor = db.execute(
+            "INSERT INTO redeem_queue(redeem, redeemer_id, note) VALUES(?, ?, ?)",
+            (redeem_name, user_id, note)
+            )
+        db.commit()
+        return True
+    except Error as e:
+        current_app.logger.error(f"Error occured adding to redeem queue: {e.args[0]}")
+        current_app.logger.error(f"To user: {user_id} with redeem: {redeem_name} with note: {note}")
+    return False
+
+
+def add_to_milestone(db, user_id, redeem_name, points_donated):
+    try:
+        cursor = db.execute(
+            "SELECT progress, goal FROM milestones WHERE name = ?",
+            (redeem_name,)
+        )
+        row = cursor.fetchone()
+        if row is None:
+            current_app.logger.warning("Milestone not found in database.")
+            current_app.logger.warning("Maybe you forgot to run the refresh-milestones CLI command "
+                                       "after you added a new milestone to the config?")
+            return False
+        progress, goal = row
+        if progress + points_donated > goal:
+            points_donated = goal - progress
+            if points_donated < 0:
+                points_donated = 0
+        if use_points(db, user_id, points_donated):
+            cursor = db.execute(
+                "UPDATE milestones SET progress = ? WHERE name = ?",
+                (progress + points_donated, redeem_name)
+            )
+            db.commit()
+            return True
+    except Error as e:
+        current_app.logger.error(f"Error occured updating milestone: {e.args[0]}")
+    return False
+
+
+def milestone_complete(db, redeem_name):
+    try:
+        cursor = db.execute(
+            "SELECT complete FROM milestones WHERE name = ?",
+            (redeem_name,)
+        )
+        row = cursor.fetchone()
+        if row is None:
+            current_app.logger.warning("Milestone not found in database.")
+            current_app.logger.warning("Maybe you forgot to run the refresh-milestones CLI command "
+                                       "after you added a new milestone to the config?")
+        else:
+            return row[0]
+    except Error as e:
+        current_app.logger.error(f"Error occured checking if milestone is complete: {e.args[0]}")
+
+
+def check_apply_milestone_completion(db, redeem_name):
+    try:
+        cursor = db.execute(
+            "SELECT progress, goal FROM milestones WHERE name = ?",
+            (redeem_name,)
+        )
+        row = cursor.fetchone()
+        if row is None:
+            current_app.logger.warning("Milestone not found in database.")
+            current_app.logger.warning("Maybe you forgot to run the refresh-milestones CLI command "
+                                       "after you added a new milestone to the config?")
+        else:
+            progress, goal = row
+            if progress == goal:
+                cursor = db.execute(
+                    "UPDATE milestones SET complete = TRUE WHERE name = ?",
+                    (redeem_name,)
+                )
+                db.commit()
+                return True
+        return False
+    except Error as e:
+        current_app.logger.error(f"Error occured applying milestone completion: {e.args[0]}")
+        return False
+
+
+def all_milestones(db):
+    try:
+        cursor = db.execute(
+            """SELECT name, progress, goal FROM milestones"""
+        )
+        return cursor.fetchall()
+    except Error as e:
+        current_app.logger.error(f"Error occured selecting all milestones: {e.args[0]}")
+
+
+def all_counters(db):
+    try:
+        cursor = db.execute(
+            """SELECT counters.name, counters.count FROM counters"""
+        )
+        return cursor.fetchall()
+    except Error as e:
+        current_app.logger.error(f"Error occured selecting all counters: {e.args[0]}")
+
+
+def all_active_counters(db):
+    counters = all_counters(db)
+    all_active_counters = []
+    for name, count in counters:
+        if is_redeem_active(name):
+            all_active_counters.append((name, count))
+    return all_active_counters
+
+
+def all_active_milestones(db):
+    milestones = all_milestones(db)
+    all_active_milestones = []
+    for name, progress, goal in milestones:
+        if is_redeem_active(name):
+            all_active_milestones.append((name, progress, goal))
+    return all_active_milestones
+
+
+def all_active_redeems(db):
+    redeems = current_app.config['REDEEMS']
+    all_active_redeems = {}
+    for redeem_name, redeem_dict in redeems.items():
+        if redeem_dict.get('category', None):
+            for category in redeem_dict['category']:
+                if category in current_app.config['ACTIVE_CATEGORIES']:
+                    all_active_redeems[redeem_name] = redeem_dict
+                    break
+        else:
+            all_active_redeems[redeem_name] = redeem_dict
+    return all_active_redeems
+
+
+def pretty_redeem_queue(db):
+    try:
+        cursor = db.execute(
+            """SELECT redeem_queue.created, redeem_queue.redeem, redeem_queue.note, points.name
+            FROM redeem_queue
+            INNER JOIN points
+            on redeem_queue.redeemer_id = points.id"""
+        )
+        return cursor.fetchall()
+    except Error as e:
+        current_app.logger.error(f"Error occured selecting pretty redeem queue: {e.args[0]}")
+
+
+def whole_redeem_queue(db):
+    try:
+        cursor = db.execute(
+            "SELECT * from redeem_queue"
+        )
+        return cursor.fetchall()
+    except Error as e:
+        current_app.logger.error(f"Error occured selecting redeem queue: {e.args[0]}")
+
+
+def is_redeem_active(redeem_name):
+    """Checks if redeem is active. Pulls the redeem by name from config."""
+    active_categories = current_app.config['ACTIVE_CATEGORIES']
+    redeem_dict = current_app.config['REDEEMS'].get(redeem_name, None)
+    if redeem_dict:
+        if "category" in redeem_dict:
+            for category in redeem_dict["category"]:
+                if category in active_categories:
+                    return True
+            return False
+        else:
+            return True
+    return None # redeem does not exist, unknown active state
+
+
+
+def is_redeem_from_config_active(redeem, active_categories):
+    """Checks if redeem is active. `redeem` is a whole key:value pair from redeems config."""
+    if "category" in redeem[1] and redeem[1]["category"]:
+        for category in redeem[1]["category"]:
+            if category in active_categories:
+                return True
+        return False
+    return True
+
+
+def remove_inactive_redeems(redeems, active_categories):
+    return dict(filter(lambda redeem: is_redeem_from_config_active(redeem, active_categories),
+                       redeems.items()))

tlapbot/redeems/counters.py

@@ -1,63 +0,0 @@
-from flask import current_app
-from sqlite3 import Error, Connection
-from typing import Tuple
-from tlapbot.redeems.redeems import is_redeem_active
-
-
-def counter_exists(db: Connection, counter_name: str) -> bool | None:
-    """Returns None only if error was logged."""
-    try:
-        cursor = db.execute(
-            "SELECT count FROM counters WHERE name = ?",
-            (counter_name,)
-        )
-        counter = cursor.fetchone()
-        if counter is None:
-            current_app.logger.warning("Counter not found in database.")
-            current_app.logger.warning("Maybe you forgot to run the refresh-counters CLI command "
-                                       "after you added a new counter to the config?")
-            return False
-        return True
-    except Error as e:
-        current_app.logger.error(f"Error occurred checking if counter exists: {e.args[0]}")
-        current_app.logger.error(f"For counter: {counter_name}")
-
-
-def add_to_counter(db: Connection, counter_name: str) -> bool:
-    if counter_exists(db, counter_name):
-        try:
-            db.execute(
-                "UPDATE counters SET count = count + 1 WHERE name = ?",
-                (counter_name,)
-            )
-            db.commit()
-            return True
-        except Error as e:
-            current_app.logger.error(f"Error occurred adding to counter: {e.args[0]}")
-            current_app.logger.error(f"To counter: {counter_name}")
-    return False
-
-
-def all_counters(db: Connection) -> list[Tuple[str, int]] | None:
-    """Returns list of all (even inactive) counters and their current value.
-    Returns None only if error was logged."""
-    try:
-        cursor = db.execute(
-            """SELECT name, count FROM counters"""
-        )
-        return cursor.fetchall()
-    except Error as e:
-        current_app.logger.error(f"Error occurred selecting all counters: {e.args[0]}")
-
-
-def all_active_counters(db: Connection) -> list[Tuple[str, int]] | None:
-    """Returns list of all active counters, and their current value.
-    Returns None if error was logged."""
-    counters = all_counters(db)
-    if counters is not None:
-        all_active_counters = []
-        for name, count in counters:
-            if is_redeem_active(name):
-                all_active_counters.append((name, count))
-        return all_active_counters
-

tlapbot/redeems/milestones.py

@@ -1,80 +0,0 @@
-from flask import current_app
-from sqlite3 import Error, Connection
-from typing import Tuple, Any
-from tlapbot.owncast_helpers import use_points
-from tlapbot.redeems.redeems import is_redeem_active
-
-
-# TODO: add a milestone_exists check?
-def add_to_milestone(db: Connection, user_id: str, redeem_name: str, points_donated: int) -> bool:
-    try:
-        cursor = db.execute(
-            "SELECT progress, goal FROM milestones WHERE name = ?",
-            (redeem_name,)
-        )
-        row = cursor.fetchone()
-        if row is None:
-            current_app.logger.warning("Milestone not found in database.")
-            current_app.logger.warning("Maybe you forgot to run the refresh-milestones CLI command "
-                                       "after you added a new milestone to the config?")
-            return False
-        progress, goal = row
-        if progress + points_donated > goal:
-            points_donated = goal - progress
-            if points_donated < 0:
-                points_donated = 0
-        if use_points(db, user_id, points_donated):
-            cursor = db.execute(
-                "UPDATE milestones SET progress = ? WHERE name = ?",
-                (progress + points_donated, redeem_name)
-            )
-            db.commit()
-            return True
-    except Error as e:
-        current_app.logger.error(f"Error occurred updating milestone: {e.args[0]}")
-    return False
-
-def milestone_complete(db: Connection, redeem_name: str) -> bool | None:
-    """Returns None only if error was logged."""
-    try:
-        cursor = db.execute(
-            "SELECT progress, goal FROM milestones WHERE name = ?",
-            (redeem_name,)
-        )
-        row = cursor.fetchone()
-        if row is None:
-            current_app.logger.warning("Milestone not found in database.")
-            current_app.logger.warning("Maybe you forgot to run the refresh-milestones CLI command "
-                                       "after you added a new milestone to the config?")
-        else:
-            progress, goal = row
-            if progress == goal:
-                return True
-            return False
-    except Error as e:
-        current_app.logger.error(f"Error occurred checking if milestone is complete: {e.args[0]}")
-
-
-def all_milestones(db: Connection) -> list[Tuple[str, int, int]] | None:
-    """Returns list of all (even inactive) milestones, their progress and their goal.
-    Returns None only if error was logged."""
-    try:
-        cursor = db.execute(
-            """SELECT name, progress, goal FROM milestones"""
-        )
-        return cursor.fetchall()
-    except Error as e:
-        current_app.logger.error(f"Error occurred selecting all milestones: {e.args[0]}")
-
-
-def all_active_milestones(db: Connection) -> list[Tuple[str, int, int]] | None:
-    """Returns list of all active milestones, their progress and their goal.
-    Returns None only if error was logged."""
-    milestones = all_milestones(db)
-    if milestones is not None:
-        all_active_milestones = []
-        for name, progress, goal in milestones:
-            if is_redeem_active(name):
-                all_active_milestones.append((name, progress, goal))
-        return all_active_milestones
-

tlapbot/redeems/polls.py

@@ -1,75 +0,0 @@
-from flask import current_app
-from sqlite3 import Error, Connection
-
-
-def get_poll_votes(db: Connection, poll_name: str) -> dict[str, int] | None:
-    """Get all poll votes and point values for a given `poll_name`"""
-    try:
-        options = {}
-        cursor = db.execute(
-            "SELECT option, points from polls WHERE poll_name = ?",
-            (poll_name,)
-        )
-        for row in cursor:
-            options[row[0]] = row[1]
-        return options
-    except Error as e:
-        current_app.logger.error(f"Error occurred getting poll votes: {e.args[0]}")
-        current_app.logger.error(f"For poll {poll_name}")
-
-
-def all_active_polls(db: Connection) -> dict[str, dict[str, int]] | None:
-    """Returns a dict where the keys are poll names, values is a dict of options and points.
-    Returns None if polls aren't enabled."""
-    if not current_app.config['POLLS_ENABLED']:
-        return None
-    polls = current_app.config['POLLS']
-    poll_votes = {}
-    for poll_name in polls.keys():
-        poll_votes[poll_name] = get_poll_votes(db, poll_name)
-    return poll_votes
-
-
-def max_poll_votes(poll_dict: dict[str, int]) -> int:
-    """Returns the maximum number of poll votes/points. Input is the output of `get_poll_votes`"""
-    highest_points = 0
-    for _, points in poll_dict.items():
-        if points > highest_points:
-            highest_points = points
-    return highest_points
-
-
-def poll_option_exists(db: Connection, poll_name: str, option: str) -> bool | None:
-    """Returns None only if error was logged."""
-    try:
-        cursor = db.execute(
-            "SELECT poll_name, option FROM polls WHERE poll_name = ? and option = ?",
-            (poll_name, option)
-        )
-        counter = cursor.fetchone()
-        if counter is None:
-            current_app.logger.warning("Poll and option combination not found in database.")
-            current_app.logger.warning("Maybe you forgot to run the refresh-polls CLI command "
-                                       "after you added a new poll to the config?")
-            return False
-        return True
-    except Error as e:
-        current_app.logger.error(f"Error occurred checking if poll exists: {e.args[0]}")
-        current_app.logger.error(f"For poll&option: {poll_name}:{option}")
-
-
-def vote_in_poll(db: Connection, poll_name: str, option: str, points: int) -> bool | None:
-    if points <= 0:
-        current_app.logger.warning(f"Vote for {poll_name}:{option} was not a positive integer.")
-        return
-    if poll_option_exists(db, poll_name, option):
-        try:
-            cursor = db.execute(
-                "UPDATE polls SET points = points + ? WHERE poll_name = ? and option = ?",
-                (points, poll_name, option)
-                )
-            db.commit()
-            return True
-        except Error as e:
-            current_app.logger.error(f"Error occurred updating poll: {e.args[0]}")
-        return False

tlapbot/redeems/redeems.py

@@ -1,74 +0,0 @@
-from flask import current_app
-from sqlite3 import Error, Connection
-from typing import Tuple, Any
-from tlapbot.tlapbot_types import Redeems
-
-# TODO: test if the new default works
-def add_to_redeem_queue(db: Connection, user_id: str, redeem_name: str, note: str="") -> bool:
-    try:
-        db.execute(
-            "INSERT INTO redeem_queue(redeem, redeemer_id, note) VALUES(?, ?, ?)",
-            (redeem_name, user_id, note)
-            )
-        db.commit()
-        return True
-    except Error as e:
-        current_app.logger.error(f"Error occurred adding to redeem queue: {e.args[0]}")
-        current_app.logger.error(f"To user: {user_id} with redeem: {redeem_name} with note: {note}")
-    return False
-
-def all_active_redeems() -> Redeems:
-    """Returns list of all active redeems."""
-    redeems = current_app.config['REDEEMS']
-    all_active_redeems = {}
-    for redeem_name, redeem_dict in redeems.items():
-        if redeem_dict.get('category', None):
-            for category in redeem_dict['category']:
-                if category in current_app.config['ACTIVE_CATEGORIES']:
-                    all_active_redeems[redeem_name] = redeem_dict
-                    break
-        else:
-            all_active_redeems[redeem_name] = redeem_dict
-    return all_active_redeems
-
-
-def pretty_redeem_queue(db: Connection) -> list[Tuple[str, str, str, str]] | None:
-    """Returns a 'pretty' redeem queue, with name of the redeemer joined instead of ID.
-    Returns None only if error was logged."""
-    try:
-        cursor = db.execute(
-            """SELECT redeem_queue.created, redeem_queue.redeem, redeem_queue.note, points.name
-            FROM redeem_queue
-            INNER JOIN points
-            on redeem_queue.redeemer_id = points.id"""
-        )
-        return cursor.fetchall()
-    except Error as e:
-        current_app.logger.error(f"Error occurred selecting pretty redeem queue: {e.args[0]}")
-
-
-def whole_redeem_queue(db: Connection) -> list[Any] | None:
-    """Returns None if error was logged."""
-    try:
-        cursor = db.execute(
-            "SELECT * from redeem_queue" #TODO: specify columns to fetch
-        )
-        return cursor.fetchall()
-    except Error as e:
-        current_app.logger.error(f"Error occurred selecting redeem queue: {e.args[0]}")
-
-
-def is_redeem_active(redeem_name: str) -> bool | None:
-    """Checks if redeem is active. Pulls the redeem by name from config.
-    Returns None if the redeem doesn't exist."""
-    active_categories = current_app.config['ACTIVE_CATEGORIES']
-    redeem_dict = current_app.config['REDEEMS'].get(redeem_name, None)
-    if redeem_dict:
-        if redeem_dict.get('category', None):
-            for category in redeem_dict["category"]:
-                if category in active_categories:
-                    return True
-            return False
-        else:
-            return True
-    return None # redeem does not exist, unknown active state

tlapbot/redeems_handler.py

@@ -1,13 +1,12 @@
 from flask import current_app
 from tlapbot.db import get_db
 from tlapbot.owncast_requests import send_chat
-from tlapbot.redeems.redeems import add_to_redeem_queue, is_redeem_active
-from tlapbot.redeems.counters import add_to_counter
-from tlapbot.redeems.milestones import  add_to_milestone, milestone_complete
-from tlapbot.owncast_helpers import use_points, read_users_points
+from tlapbot.redeems import (add_to_redeem_queue, add_to_counter, add_to_milestone, 
+        check_apply_milestone_completion, milestone_complete, is_redeem_active)
+from tlapbot.owncast_helpers import use_points, read_users_points, remove_emoji
 
 
-def handle_redeem(message: str, user_id: str) -> None:
+def handle_redeem(message, user_id):
     split_message = message[1:].split(maxsplit=1)
     redeem = split_message[0]
     if len(split_message) == 1:
@@ -26,11 +25,6 @@ def handle_redeem(message: str, user_id: str) -> None:
     redeem_type = current_app.config['REDEEMS'][redeem]["type"]
     points = read_users_points(db, user_id)
 
-    if points is None:
-        send_chat(f"Can't redeem {redeem}, failed to read users' points.")
-        return
-
-
     # handle milestone first because it doesn't have a price
     if redeem_type == "milestone":
         if milestone_complete(db, redeem):
@@ -38,14 +32,12 @@ def handle_redeem(message: str, user_id: str) -> None:
         elif not note:
             send_chat(f"Cannot redeem {redeem}, no amount of points specified.")
         elif not note.isdigit():
-            send_chat(f"Cannot redeem {redeem}, amount of points is not a positive integer.")
+            send_chat(f"Cannot redeem {redeem}, amount of points is not an integer.")
         elif int(note) > points:
             send_chat(f"Can't redeem {redeem}, you're donating more points than you have.")
-        elif int(note) == 0:
-            send_chat(f"Can't donate zero points.")
         elif add_to_milestone(db, user_id, redeem, int(note)):
             send_chat(f"Succesfully donated to {redeem} milestone!")
-            if milestone_complete(db, redeem):
+            if check_apply_milestone_completion(db, redeem):
                 send_chat(f"Milestone goal {redeem} complete!")
         else:
             send_chat(f"Redeeming milestone {redeem} failed.")
@@ -72,7 +64,7 @@ def handle_redeem(message: str, user_id: str) -> None:
         if not note:
             send_chat(f"Cannot redeem {redeem}, no note included.")
             return
-        if (add_to_redeem_queue(db, user_id, redeem, note) and
+        if (add_to_redeem_queue(db, user_id, redeem, remove_emoji(note)) and
                 use_points(db, user_id, price)):
             send_chat(f"{redeem} redeemed for {price} points.")
         else:

tlapbot/schema.sql

@@ -1,7 +1,6 @@
 DROP TABLE IF EXISTS counters;
 DROP TABLE IF EXISTS redeem_queue;
 DROP TABLE IF EXISTS milestones;
-DROP TABLE IF EXISTS polls;
 
 CREATE TABLE IF NOT EXISTS points (
   id TEXT PRIMARY KEY,
@@ -13,7 +12,8 @@ CREATE TABLE milestones (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   name TEXT NOT NULL,
   progress INTEGER NOT NULL,
-  goal INTEGER NOT NULL
+  goal INTEGER NOT NULL,
+  complete BOOLEAN NOT NULL
 );
 
 CREATE TABLE counters (
@@ -31,9 +31,7 @@ CREATE TABLE redeem_queue (
   FOREIGN KEY (redeemer_id) REFERENCES points (id)
 );
 
-CREATE TABLE polls (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  points INTEGER NOT NULL,
-  option TEXT NOT NULL,
-  poll_name TEXT NOT NULL
+CREATE TABLE online_time(
+  id INTEGER PRIMARY KEY,
+  online_time TIMESTAMP NOT NULL
 );

tlapbot/templates/dashboard.html

@@ -23,7 +23,7 @@
 
         <body>
             <h3>Redeems Dashboard</h3>
-            {% if (username and users) %}
+            {% if (username and users ) %}
             <table>
                 <thead>
                     <tr>
@@ -47,31 +47,6 @@
             {% endif %}
 
             {% if not passive %}
-            {% if polls %}
-
-            <table>
-                <thead>
-                    <tr>
-                        <th colspan="2">Active polls</th>
-                        <th colspan="2">Points</th>
-                    </tr>
-                </thead>
-                <tbody>
-                {% for poll_name, poll_dict in polls.items() %}
-                {% for option in poll_dict.keys() %}
-                {% set max_vote = max_poll_votes(poll_dict) %}
-                    <tr>
-                        <td> {{ poll_name }} </td>
-                        <td> {{ option }} </td>
-                        <td> {{ poll_dict[option] }} </td>
-                        <td> <progress id="file" max={{ max_vote }} value={{ poll_dict[option] }}></progress></td>
-                    </tr>
-                {% endfor %}
-                {% endfor %}
-                </tbody>
-            </table>
-
-            {% endif %}
             {% if counters %}
             <table>
                 <thead>

tlapbot/tlapbot_dashboard.py

@@ -1,17 +1,14 @@
 from flask import render_template, Blueprint, request, current_app
 from tlapbot.db import get_db
-from tlapbot.redeems.redeems import all_active_redeems, pretty_redeem_queue
-from tlapbot.redeems.counters import all_active_counters
-from tlapbot.redeems.milestones import all_active_milestones
-from tlapbot.redeems.polls import all_active_polls, max_poll_votes
+from tlapbot.redeems import all_active_counters, all_active_milestones, all_active_redeems, pretty_redeem_queue
 from tlapbot.owncast_helpers import  read_all_users_with_username
-from datetime import timezone
+from datetime import datetime, timezone
 
 bp = Blueprint('redeem_dashboard', __name__)
 
 
 @bp.route('/dashboard', methods=['GET'])
-def dashboard() -> str:
+def dashboard():
     db = get_db()
     username = request.args.get("username")
     if username is not None:
@@ -23,9 +20,7 @@ def dashboard() -> str:
                            queue=pretty_redeem_queue(db),
                            counters=all_active_counters(db),
                            milestones=all_active_milestones(db),
-                           polls=all_active_polls(db),
-                           redeems=all_active_redeems(),
-                           max_poll_votes=max_poll_votes,
+                           redeems=all_active_redeems(db),
                            prefix=current_app.config['PREFIX'],
                            passive=current_app.config['PASSIVE'],
                            username=username,

tlapbot/tlapbot_types.py

@@ -1,4 +0,0 @@
-from typing import Any, TypeAlias
-
-Redeems: TypeAlias = dict[str, dict[str, Any]]
-# at the moment the Any could be specialized to str | int | list[str]