add polls documentation

make polls not work when they're disabled
show polls on dashboard
2025-12-14 20:04:36 +01:00 · 2025-12-14 19:42:34 +01:00 · 2025-12-14 19:22:57 +01:00 · 2025-12-12 20:01:09 +01:00 · 2025-12-10 20:29:07 +01:00 · 2025-12-10 19:44:03 +01:00
25 changed files with 1141 additions and 324 deletions
@@ -2,9 +2,12 @@
 Tlapbot is an [Owncast](https://owncast.online/) bot that adds channel points and
 channel point redeems to your Owncast page.

-This bot is currently in-development. 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/).
+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.
+
 ## 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.
@@ -12,20 +15,58 @@ 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.
+doing, and sort them into categories that can be turned on and off.

 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.
+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!)
 ### Tlapbot bot commands
 Tlapbot has these basic commands:
 - `!help` sends a help string in the chat, explaining how tlapbot works.
 - `!points` shows a chatter how many points they have.
 - `!name_update` is a special debug command, to be used with the user's name displays wrong in the redeem dashboard. Normally, it shouldn't have to be used at all, as display names get updated automatically when the bot is running.

+(If you change the default prefix of `!` to something else, these commands will
+use the new prefix instead.)
+
 Tlapbot also automatically adds a command for each redeem in the redeems file.
+
+### 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.
+
+Counters are at the top, followed by a list of active milestones and their progress.
+
+Tlapbot dashboard also shows the chatter's points balance when they open it as an external action.
+
+![Tlapbot dashboard](https://ak.kawen.space/media/f9e29757f02996f363f25226f04a97ac711a95831bfaba9dcfd42158e78831c4.png)
+
+*Tlapbot dashboard when viewed as an external action.*
+#### Redeem queue tab
+The redeem queue shows a chronological list of note and list redeems with timestamps, the redeemer's username, and the note sent.
+![Redeem queue tab](https://ak.kawen.space/media/a1f44cc1a4011309a08361ca7f2ce24837d5daadd045910bf33fcd40b01d0a27.png)
+
+*Redeem queue tab.*
+#### 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 three different redeem types.
+Tlapbot currently supports four 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
+or off in the config file. This means that the redeems file can list redeems
+for different types of streams, and you can turn them on or off. Examples on how
+to do that are listed later in the config file examples.
 #### List
 List redeems are basic redeems, most similar to the ones on Twitch.

@@ -43,19 +84,29 @@ Instead, the tlapbot dashboard keeps a number for each "counter", and each redee

 Counter redeems can be used to gauge interest, tally up votes, or to keep track of how many emotes should be added to an OBS scene.

-### 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.
+#### Milestone
+Milestone redeems are long-term goals that are reset separately from other redeems.
+Viewers donate variable amounts of points that add up together to fulfill the milestone goal.

-Counters are at the top, followed by a chronological list of recent List and Note redeems.
+Each milestone has a goal, a number of points required to send, and the points from
+all users add together to progress and reach the goal.

-Tlapbot dashboard also shows the chatter's points balance when they open it as an external action.
+Milestones show as a progress bar on the dashboard.

-![Tlapbot dashboard](https://ak.kawen.space/media/67c1ac6ed0d2f4efb09937c1cbfe864102182e990796853507860f50db7ff5f5.png)
+Milestone redeems can be used as long-term community challenges, to start streamer
+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.

-*Tlapbot dashboard when viewed as an external action.*
-#### 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.
 ## 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.

@@ -80,8 +131,8 @@ as a package in editable more.
    ```bash
    python -m flask init-db
    ```
-5. Create a `instance/config.py` file and fill it in as needed.
-Default values are included in `tlapbot/default_config`, and values in
+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
 `config.py` overwrite them. (The database also lives in the instance folder
 by default.)

@@ -92,12 +143,15 @@ 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/default_redeems.py`.  
+  If you don't add a redeems file, the bot will initialize the default redeems from `tlapbot/defaults/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.

 This installation is fine both for just running Tlapbot as it is, but it also works as a dev setup if you want to make changes or contribute.

 Updating should be as easy as `git pull`ing the new version.
+Sometimes, if an update adds new database tables or columns, you will also need to
+rerun the `init-db` CLI command.
 ## Owncast  configuration
 In the Owncast web interface, navigate to the admin interface at `/admin`,
 and then go to Integrations.
@@ -125,7 +179,7 @@ it will work because the ngrok connection is https.

 **External Action config example:**
 ```
-URL: MyTlapbotServer.com/dashboard
+URL: MyTlapbotServer.example/dashboard
 Action Title: Redeems Dashboard
 ```
 #### Note about https and reverse proxying
@@ -136,14 +190,14 @@ The Owncast documentation about SSL and Reverse proxying is here: https://owncas
 If your followed the [Owncast recommendation to use Caddy](https://owncast.online/docs/sslproxies/caddy/) you'd only need to include this in your caddyfile to make the tlapbot dashboard work:

 ```
-MyTlapbotServer.com {
+MyTlapbotServer.example {
        reverse_proxy localhost:8000
 }
 ```
-then MyTlapbotServer.com/owncastWebhook is the URL for webhooks,
-and MyTlapbotServer.com/dashboard is the URL for the dashboard.
+then MyTlapbotServer.example/owncastWebhook is the URL for webhooks,
+and MyTlapbotServer.example/dashboard is the URL for the dashboard.

-(And, obviously, you'd need to own the MyTlapbotServer.com domain, and have an A record pointing to your server's IP address.)
+(And, obviously, you'd need to own the MyTlapbotServer.example domain, and have an A record pointing to your server's IP address.)
 ## Running the bot
 ### Running in debug:
 Set the FLASK_APP variable:
@@ -190,13 +244,14 @@ get given points by each worker. (So running the app with `-w 4` means users get

 I'd like to fix this shortcoming of tlapbot at some point in the future (so that it can take advantage of extra workers), but for now it's broken like this.

-## CLI commands: updating config + redeems
+## CLI commands: Updating redeems, clearing the queue
 Tlapbot comes with a few Click CLI commands. The commands let you clear out counters and the redeems dashboard.

 #### init-db
 The init-db command initializes the database.

-**This command should only be run when first installing tlapbot.**
+**This command should only be run when first installing tlapbot,
+or when updating to a tlapbot version that changed the database schema.**
 #### clear-queue
 The clear-queue command clears the redeem queue and resets all active counters to zero.
 You should run this command if you're about to start a new stream, and want to start with empty counters and queue.
@@ -212,51 +267,122 @@ You should run this command every time you've added or removed counters from `re
 ```bash
 python -m flask refresh-counters
 ```
-This command only changes counters, so if you want to clear the queue with list and note redeems too, you should run `clear-queue` after it.
+This command only changes counters, so if you want to clear the queue with list and note redeems too, you should run `clear-queue` after it, or run `clear-refresh` to do both actions together.
+
+#### clear-refresh
+Does the same as `clear-queue` and `refresh-counters` together.
+```bash
+python -m flask clear-refresh
+```
+Run this if you're adding/removing counters, want to reset them to zero and want to clear all redeems as well.
+#### refresh-milestones
+Deletes old milestones and initializes new ones from the redeems file.
+```bash
+python -m flask refresh-milestones
+```
+Running this command shouldn't reset progress on milestones that are already in the database
+and are still in the redeems file.
+#### reset-milestone
+Resets progress on a milestone, but only if the milestone had been completed.
+```bash
+python -m flask reset-milestone milestone
+```
+#### hard-reset-milestone
+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.
+
+Take care not to replace `tlapbot/redeems.py` with your redeems config.
+`tlapbot/redeems.py` contains functions that handle redeems interactions with the db,
+and not the redeems config.
 ### config.py
 Values you can include in `config.py` to change how the bot behaves.

-(`config.py` should be in the instance folder: `/instance/config.py` for folder install.)
+(`config.py` should be in the instance folder: `instance/config.py` for folder install.)
 #### Mandatory
 Including these values is mandatory if you want tlapbot to work.
 - `SECRET_KEY` is your secret key. Get one from running `python -c 'import secrets; print(secrets.token_hex())'`
 - `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.com"`
+- `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/default_config.py`.
+Including these values will overwrite their defaults from `/tlapbot/defaults/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.
+- `PASSIVE` if `True`, sets Tlapbot into passive mode, where no redeems are available. The bot will still track username changes and give out points.
 - `LIST_REDEEMS` if `True`, all redeems will be listed after the `!help` command in chat.
 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
 SECRET_KEY= # string with secret key would be here.
 OWNCAST_ACCESS_TOKEN="5AT0gbe9ZuzDunsBG0rcwfalQNTi3fvV70NPvvQHk3I="
-OWNCAST_INSTANCE_URL="http://MyTlapbotServer.com"
+OWNCAST_INSTANCE_URL="http://MyTlapbotServer.example"
 POINTS_CYCLE_TIME=300
 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/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/defaults/default_redeems.py`.

-(`redeems.py` should be in the instance folder: `/instance/redeems.py` for folder install.)
-#### Default `redeems.py`:
+(`redeems.py` should be in the instance folder: `instance/redeems.py` for folder install.)
+#### `default_redeems.py`:
 ```python
 REDEEMS={
    "hydrate": {"price": 60, "type": "list"},
    "lurk": {"price": 1, "type": "counter", "info": "Let us know you're going to lurk."},
    "react": {"price": 200, "type": "note", "info": "Attach link to a video for me to react to."},
-    "request": {"price": 100, "type": "note", "info": "Request a level, gamemode, skin, etc."}
+    "request": {"price": 100, "type": "note", "info": "Request a level, gamemode, skin, etc."},
+    "go_nap": {"goal": 1000, "type": "milestone", "info": "Streamer will go nap when the goal is reached."},
+    "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 decides the chat command for the redeem. The value is another dictionary that needs to have entries for `"price"`, `"type"` and optionally `"info"`.
+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.
+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.

- `"price"` value should be an integer that decides how many points the redeem will cost.
- `"type"` value should be either `"list"`, `"counter"` or `"note"`. This decided the redeem's type, and whether it will show up as a counter at the top of the dashboard or as an entry in the "recent redeems" chart.
- `"info"` value should be a string that describes what the command does. It's optional, but I recommend writing one for all `"list"` and `"note"` redeems (so that chatters know that they should write a note).
+- `"price"` value should be an integer that decides how many points the redeem will cost. Milestone redeems don't use the `"price"` value, they instead need to have a `"goal"`.
+- `"goal"` is a required field for milestone goals. It should be an integer, deciding the amount of points required to complete the milestone.
+- `"type"` value should be either `"list"`, `"counter"`, `"note"` or `"milestone"`. This decided the redeem's type, and whether it will show up as a counter at the top of the dashboard or as an entry in the "recent redeems" chart.
+- `"info"` value should be a string that describes what the command does. It's optional, but I recommend writing one for all `"list"`, `"note"` and `"milestone"` redeems (so that chatters know what they're redeeming and whether they should leave a note).
+- `"category"` is an optional list of strings, the categories the redeem is in.
+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"]}
+}
+```
@@ -2,7 +2,7 @@ from setuptools import find_packages, setup

 setup(
    name='tlapbot',
-    version='1.0.0',
+    version='1.2.2',
    packages=find_packages(),
    include_package_data=True,
    install_requires=[
@@ -3,12 +3,12 @@ import logging
 from flask import Flask
 from apscheduler.schedulers.background import BackgroundScheduler
 from tlapbot.db import get_db
-from tlapbot.owncast_helpers import is_stream_live, give_points_to_chat
+from tlapbot.owncast_requests import is_stream_live, give_points_to_chat


-def create_app(test_config=None):
+def create_app(test_config: None = None) -> Flask:
    app = Flask(__name__, instance_relative_config=True)
-    
+
    # ensure the instance folder exists
    try:
        os.makedirs(app.instance_path)
@@ -20,31 +20,58 @@ def create_app(test_config=None):
    app.config.from_mapping(
        DATABASE=os.path.join(app.instance_path, "tlapbot.sqlite")
    )
-    app.config.from_object('tlapbot.default_config')
-    app.config.from_object('tlapbot.default_redeems')
+    app.config.from_object('tlapbot.defaults.default_config')
+    app.config.from_object('tlapbot.defaults.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'] is True:
+    if app.config['GUNICORN']:
        gunicorn_logger = logging.getLogger('gunicorn.error')
        app.logger.handlers = gunicorn_logger.handlers
        app.logger.setLevel(gunicorn_logger.level)

+    # Check for wrong config that would break Tlapbot
+    if len(app.config['PREFIX']) != 1:
+        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 owncast_redeem_dashboard
+    from . import tlapbot_dashboard
    app.register_blueprint(owncast_webhooks.bp)
-    app.register_blueprint(owncast_redeem_dashboard.bp)
+    app.register_blueprint(tlapbot_dashboard.bp)

    # add db CLI commands
    from . import db
    db.init_app(app)
    app.cli.add_command(db.clear_queue_command)
    app.cli.add_command(db.refresh_counters_command)
-    
+    app.cli.add_command(db.refresh_and_clear_command)
+    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():
+    def proxy_job() -> None:
        with app.app_context():
            if is_stream_live():
                app.logger.info("Stream is LIVE. Giving points to chat.")
@@ -1,11 +1,13 @@
 import sqlite3

 import click
-from flask import current_app, g
+from flask import current_app, g, Flask
 from flask.cli import with_appcontext

+from tlapbot.redeems.milestones import milestone_complete

-def get_db():
+
+def get_db() -> sqlite3.Connection:
    if 'db' not in g:
        g.db = sqlite3.connect(
            current_app.config['DATABASE'],
@@ -16,14 +18,14 @@ def get_db():
    return g.db


-def close_db(e=None):
-    db = g.pop('db', None)
+def close_db(*_args) -> None:
+    db: sqlite3.Connection = g.pop('db', None)

    if db is not None:
        db.close()


-def insert_counters(db):
+def insert_counters(db: sqlite3.Connection) -> bool:
    for redeem, redeem_info in current_app.config['REDEEMS'].items():
        if redeem_info["type"] == "counter":
            try:
@@ -32,20 +34,36 @@ def insert_counters(db):
                    (redeem,)
                )
                db.commit()
-            except Error as e:
+            except sqlite3.Error as e:
                print("Failed inserting counters to db:", e.args[0])
+                return False
+    return True


-def init_db():
+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:
    db = get_db()

    with current_app.open_resource('schema.sql') as f:
        db.executescript(f.read().decode('utf8'))

-    insert_counters(db)
+    return insert_counters(db)


-def clear_redeem_queue():
+def clear_redeem_queue() -> bool:
    db = get_db()

    try:
@@ -56,55 +74,214 @@ def clear_redeem_queue():
            """UPDATE counters SET count = 0"""
        )
        db.commit()
-    except Error as e:
-        print("Error occured deleting redeem queue:", e.args[0])
+    except sqlite3.Error as e:
+        print("Error occurred deleting redeem queue:", e.args[0])
+        return False
+    return True


-def refresh_counters():
+def refresh_counters() -> bool:
    db = get_db()

    try:
        db.execute("DELETE FROM counters")
        db.commit()
-    except Error as e:
-        print("Error occured deleting old counters:", e.args[0])
+    except sqlite3.Error as e:
+        print("Error occurred deleting old counters:", e.args[0])
+        return False
+    return insert_counters(db)

-    for redeem, redeem_info in current_app.config['REDEEMS'].items():
-        if redeem_info["type"] == "counter":
-            try:
+
+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()
+    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:
+    db = get_db()
+    # delete old milestones
+    try:
+        cursor = db.execute("SELECT name FROM milestones")
+        milestones = cursor.fetchall()
+        to_delete = []
+        for milestone in milestones:
+            milestone = milestone[0]
+            if milestone not in current_app.config['REDEEMS'].keys():
+                to_delete.append(milestone)
+            elif current_app.config['REDEEMS'][milestone]['type'] != "milestone":
+                to_delete.append(milestone)
+        for milestone in to_delete:
+            cursor.execute("DELETE FROM milestones WHERE name = ?", (milestone,))
+        db.commit()
+    except sqlite3.Error as e:
+        print("Failed deleting old milestones from db:", e.args[0])
+        return False
+
+    # add new milestones
+    try:
+        for redeem, redeem_info in current_app.config['REDEEMS'].items():
+            if redeem_info["type"] == "milestone":
                cursor = db.execute(
-                    "INSERT INTO counters(name, count) VALUES(?, 0)",
+                    "SELECT goal FROM milestones WHERE name = ?",
                    (redeem,)
                )
-                db.commit()
-            except Error as e:
-                print("Failed inserting counters to db:", e.args[0])
+                result = cursor.fetchone()
+                if result is None:
+                    cursor.execute(
+                        "INSERT INTO milestones(name, progress, goal) VALUES(?, 0, ?)",
+                        (redeem, redeem_info['goal'])
+                    )
+                # update existing milestone to new goal
+                elif result != redeem_info["goal"]:
+                    cursor.execute(
+                        "UPDATE milestones SET goal = ? WHERE name = ?",
+                        (redeem_info["goal"], redeem)
+                    )
+        db.commit()
+    except sqlite3.Error as e:
+        print("Failed inserting milestones to db:", e.args[0])
+        return False
+    return True
+
+
+def reset_milestone(milestone: str) -> bool:
+    if milestone not in current_app.config['REDEEMS']:
+        print(f"Failed resetting milestone, {milestone} not in redeems file.")
+        return False
+    try:
+        db = get_db()
+        db.execute(
+            "DELETE FROM milestones WHERE name = ?",
+            (milestone,)
+        )
+        db.execute(
+            "INSERT INTO milestones(name, progress, goal) VALUES(?, ?, ?)",
+            (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]}")
+        return False


@click.command('init-db')
@with_appcontext
-def init_db_command():
+def init_db_command() -> None:
    """Clear the existing data and create new tables."""
-    init_db()
-    click.echo('Initialized the database.')
+    if init_db():
+        click.echo('Initialized the database.')


@click.command('clear-queue')
@with_appcontext
-def clear_queue_command():
+def clear_queue_command() -> None:
    """Remove all redeems from the redeem queue."""
-    clear_redeem_queue()
-    click.echo('Cleared redeem queue.')
+    if clear_redeem_queue():
+        click.echo('Cleared redeem queue.')


@click.command('refresh-counters')
@with_appcontext
-def refresh_counters_command():
-    """Refresh counters from current config file. (Remove old ones, add new ones.)"""
-    refresh_counters()
-    click.echo('Counters refreshed.')
+def refresh_counters_command() -> None:
+    """Refresh counters from current config file.
+    (Remove old ones, add new ones.)"""
+    if refresh_counters():
+        click.echo('Counters refreshed.')


-def init_app(app):
+@click.command('clear-refresh')
+@with_appcontext
+def refresh_and_clear_command() -> None:
+    """Refresh counters and clear queue."""
+    if refresh_counters() and clear_redeem_queue():
+        click.echo('Counters refreshed and queue cleared.')
+
+
+@click.command('refresh-milestones')
+@with_appcontext
+def refresh_milestones_command() -> None:
+    """Initialize all milestones from the redeems file,
+    delete milestones not in redeem file."""
+    if refresh_milestones():
+        click.echo('Refreshed milestones.')
+
+
+@click.command('reset-milestone')
+@click.argument('milestone')
+def reset_milestone_command(milestone: str) -> None:
+    """Resets a completed milestone back to zero."""
+    if milestone_complete(get_db(), milestone):
+        if reset_milestone(milestone):
+            click.echo(f"Reset milestone {milestone}.")
+    else:
+        click.echo(f"Could not reset milestone {milestone}, milestone not completed.")
+        click.echo("(You can hard-reset-milestone if you really want to reset it.)")
+
+
+@click.command('hard-reset-milestone')
+@click.argument('milestone')
+def hard_reset_milestone_command(milestone: str) -> None:
+    """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:
    app.teardown_appcontext(close_db)
    app.cli.add_command(init_db_command)
@@ -3,5 +3,9 @@ OWNCAST_ACCESS_TOKEN=''
 OWNCAST_INSTANCE_URL='http://localhost:8080'
 POINTS_CYCLE_TIME=600
 POINTS_AMOUNT_GIVEN=10
+PASSIVE=False
 LIST_REDEEMS=False
-GUNICORN=False
+ACTIVE_CATEGORIES=[]
+GUNICORN=False
+PREFIX='!'
+POLLS_ENABLED=True
@@ -0,0 +1,3 @@
+POLLS={
+    "favourite_food": {"info": "Vote for your favourite food.", "options": ["pizza", "soup", "curry", "schnitzel"]}
+}
@@ -2,5 +2,7 @@ REDEEMS={
    "hydrate": {"price": 60, "type": "list"},
    "lurk": {"price": 1, "type": "counter", "info": "Let us know you're going to lurk."},
    "react": {"price": 200, "type": "note", "info": "Attach link to a video for me to react to."},
-    "request": {"price": 100, "type": "note", "info": "Request a level, gamemode, skin, etc."}
+    "request": {"price": 100, "type": "note", "info": "Request a level, gamemode, skin, etc."},
+    "go_nap": {"goal": 1000, "type": "milestone", "info": "Streamer will go nap when the goal is reached."},
+    "inactive": {"price": 100, "type": "note", "info": "Example redeem that is inactive by default", "category": ["inactive"]}
 }
@@ -1,23 +1,30 @@
 from flask import current_app
-from tlapbot.owncast_helpers import send_chat
+from tlapbot.owncast_requests import send_chat


-def send_help():
+def send_help() -> None:
    message = []
-    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"""
+    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>"""
    )
    if current_app.config['LIST_REDEEMS']:
-        message.append("Active redeems:\n")
+        message.append("Active redeems: <br>")
        for redeem, redeem_info in current_app.config['REDEEMS'].items():
-            if 'info' in redeem_info:
-                message.append(f"!{redeem} for {redeem_info['price']} points. {redeem_info['info']}\n")
+            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.\n")
+                message.append(f"!{redeem} for {redeem_info['price']} points.")
+            if 'info' in redeem_info:
+                message.append(f" {redeem_info['info']} <br>")
+            else:
+                message.append("<br>")
    else:
        message.append("Check the dashboard for a list of currently active redeems.")
    send_chat(''.join(message))
@@ -1,36 +1,12 @@
 from flask import current_app
-import requests
-from sqlite3 import Error
-
-
-# # # requests stuff # # #
-def is_stream_live():
-    url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/status'
-    r = requests.post(url)
-    return r.json()["online"]
-
-
-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']}
-    r = requests.post(url, headers=headers)
-    unique_users = list(set(map(lambda user_object: user_object["user"]["id"], r.json())))
-    for user_id in unique_users:
-        give_points_to_user(db,
-                            user_id,
-                            current_app.config['POINTS_AMOUNT_GIVEN'])
-
-
-def send_chat(message):
-    url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/integrations/chat/send'
-    headers = {"Authorization": "Bearer " + current_app.config['OWNCAST_ACCESS_TOKEN']}
-    r = requests.post(url, headers=headers, json={"body": message})
-    return r.json()
+from sqlite3 import Error, Connection
+from re import sub
+from typing import Tuple


 # # # db stuff # # #
-def read_users_points(db, user_id):
-    """Errors out if user doesn't exist."""
+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."""
    try:
        cursor = db.execute(
            "SELECT points FROM points WHERE id = ?",
@@ -38,11 +14,12 @@ def read_users_points(db, user_id):
        )
        return cursor.fetchone()[0]
    except Error as e:
-        current_app.logger.error("Error occured reading points:", e.args[0])
-        current_app.logger.error("To user:", user_id)
+        current_app.logger.error(f"Error occurred reading points: {e.args[0]}")
+        current_app.logger.error(f"Of user: {user_id}")


-def read_all_users_with_username(db, username):
+def read_all_users_with_username(db: Connection, username: str) -> list[Tuple[str, int]] | None:
+    """Returns None only if Error was logged."""
    try:
        cursor = db.execute(
            "SELECT name, points FROM points WHERE name = ?",
@@ -51,11 +28,11 @@ def read_all_users_with_username(db, username):
        users = cursor.fetchall()
        return users
    except Error as e:
-        current_app.logger.error("Error occured reading points from username:", e.args[0])
-        current_app.logger.error("To user:", username)
+        current_app.logger.error(f"Error occurred reading points by username: {e.args[0]}")
+        current_app.logger.error(f"Of everyone with username: {username}")


-def give_points_to_user(db, user_id, points):
+def give_points_to_user(db: Connection, user_id: str, points: int) -> None:
    try:
        db.execute(
            "UPDATE points SET points = points + ? WHERE id = ?",
@@ -63,11 +40,11 @@ def give_points_to_user(db, user_id, points):
        )
        db.commit()
    except Error as e:
-        current_app.logger.error("Error occured giving points:", e.args[0])
-        current_app.logger.error("To user:", user_id, "  amount of points:", points)
+        current_app.logger.error(f"Error occurred giving points: {e.args[0]}")
+        current_app.logger.error(f"To user: {user_id} amount of points: {points}")


-def use_points(db, user_id, points):
+def use_points(db: Connection, user_id: str, points: int) -> bool:
    try:
        db.execute(
            "UPDATE points SET points = points - ? WHERE id = ?",
@@ -76,12 +53,13 @@ def use_points(db, user_id, points):
        db.commit()
        return True
    except Error as e:
-        current_app.logger.error("Error occured using points:", e.args[0])
-        current_app.logger.error("From user:", user_id, "  amount of points:", points)
+        current_app.logger.error(f"Error occurred using points: {e.args[0]}")
+        current_app.logger.error(f"From user: {user_id} amount of points: {points}")
        return False


-def user_exists(db, user_id):
+def user_exists(db: Connection, user_id: str) -> bool | None:
+    """Returns None only if an error was logged."""
    try:
        cursor = db.execute(
            "SELECT points FROM points WHERE id = ?",
@@ -91,11 +69,11 @@ def user_exists(db, user_id):
            return False
        return True
    except Error as e:
-        current_app.logger.error("Error occured checking if user exists:", e.args[0])
-        current_app.logger.error("To user:", user_id)
+        current_app.logger.error(f"Error occurred checking if user exists: {e.args[0]}")
+        current_app.logger.error(f"To user: {user_id}")


-def add_user_to_database(db, user_id, display_name):
+def add_user_to_database(db: Connection, user_id: str, display_name: str) -> None:
    """ Adds a new user to the database. Does nothing if user is already in."""
    try:
        cursor = db.execute(
@@ -117,82 +95,25 @@ def add_user_to_database(db, user_id, display_name):
            )
        db.commit()
    except Error as e:
-        current_app.logger.error("Error occured adding user to db:", e.args[0])
-        current_app.logger.error("To user:", user_id, display_name)
+        current_app.logger.error(f"Error occurred 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, user_id, new_name):
+def change_display_name(db: Connection, user_id: str, new_name: str) -> None:
    try:
-        cursor = db.execute(
+        db.execute(
            "UPDATE points SET name = ? WHERE id = ?",
            (new_name, user_id)
        )
        db.commit()
    except Error as e:
-        current_app.logger.error("Error occured changing display name:", e.args[0])
-        current_app.logger.error("To user:", user_id, new_name)
+        current_app.logger.error(f"Error occurred changing display name: {e.args[0]}")
+        current_app.logger.error(f"To user id: {user_id}, with display name: {new_name}")


-def add_to_counter(db, counter_name):
+def remove_duplicate_usernames(db: Connection, user_id: str, username: str) -> None:
    try:
-        cursor = db.execute(
-            "UPDATE counters SET count = count + 1 WHERE name = ?",
-            (counter_name,)
-        )
-        db.commit()
-    except Error as e:
-        current_app.logger.error("Error occured adding to counter:", e.args[0])
-        current_app.logger.error("To counter:", counter_name)
-
-
-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()
-    except Error as e:
-        current_app.logger.error("Error occured adding to redeem queue:", e.args[0])
-        current_app.logger.error("To user:", user_id, " with redeem:", redeem_name, "with note:", note)
-
-
-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("Error occured selecting all counters:", e.args[0])
-
-
-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("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("Error occured selecting redeem queue:", e.args[0])
-
-
-def remove_duplicate_usernames(db, user_id, username):
-    try:
-        cursor = db.execute(
+        db.execute(
            """UPDATE points
            SET name = NULL
            WHERE name = ? AND NOT id = ?""",
@@ -200,4 +121,14 @@ def remove_duplicate_usernames(db, user_id, username):
        )
        db.commit()
    except Error as e:
-        current_app.logger.error("Error occured removing duplicate usernames:", e.args[0])
+        current_app.logger.error(f"Error occurred 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:
+    return sub(
+        r'<img class="emoji" alt="(:.*?:)" title=":.*?:" src="/img/emoji/.*?">',
+        r'\1',
+        message
+    )
@@ -1,28 +0,0 @@
-from flask import render_template, Blueprint, request, current_app
-from tlapbot.db import get_db
-from tlapbot.owncast_helpers import (pretty_redeem_queue, all_counters,
-        read_all_users_with_username)
-from datetime import datetime, timezone
-
-bp = Blueprint('redeem_dashboard', __name__)
-
-
-@bp.route('/dashboard', methods=['GET'])
-def dashboard():
-    db = get_db()
-    queue = pretty_redeem_queue(db)
-    counters = all_counters(db)
-    redeems = current_app.config['REDEEMS']
-    username = request.args.get("username")
-    if username is not None:
-        users = read_all_users_with_username(db, username)
-    else:
-        users = []
-    utc_timezone = timezone.utc
-    return render_template('dashboard.html',
-                           queue=queue,
-                           counters=counters,
-                           redeems=redeems,
-                           username=username,
-                           users=users,
-                           utc_timezone=utc_timezone)
@@ -0,0 +1,49 @@
+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:
+    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]}")
+        return False
+    return r.json()["online"]
+
+
+def give_points_to_chat(db: Connection) -> None:
+    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]}")
+        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"Response code received: {r.status_code}.")
+        current_app.logger.error(f"Check owncast instance url and access key.")
+        return
+    unique_users = set(map(lambda user_object: user_object["user"]["id"], r.json()))
+    for user_id in unique_users:
+        give_points_to_user(db, user_id, current_app.config['POINTS_AMOUNT_GIVEN'])
+
+
+def send_chat(message: str) -> Any:
+    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]}")
+        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"Response code received: {r.status_code}.")
+        current_app.logger.error(f"Check owncast instance url and access key.")
+        return
+    return r.json()
@@ -1,23 +1,33 @@
 from flask import Flask, request, json, Blueprint, current_app
+from sqlite3 import Connection
+from typing import Any
 from tlapbot.db import get_db
+from tlapbot.owncast_requests import send_chat
 from tlapbot.owncast_helpers import (add_user_to_database, change_display_name,
-        user_exists, send_chat, read_users_points, remove_duplicate_usernames)
+        read_users_points, remove_duplicate_usernames)
 from tlapbot.help_message import send_help
 from tlapbot.redeems_handler import handle_redeem
+from tlapbot.poll_handler import handle_poll_vote


 bp = Blueprint('owncast_webhooks', __name__)


@bp.route('/owncastWebhook', methods=['POST'])
-def owncast_webhook():
-    data = request.json
-    db = get_db()
-    if data["type"] == "USER_JOINED":
+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()
+
+    # Make sure user is in db before doing anything else.
+    if data["type"] in ["CHAT", "NAME_CHANGED", "USER_JOINED"]:
        user_id = data["eventData"]["user"]["id"]
        display_name = data["eventData"]["user"]["displayName"]
-        # CONSIDER: join points for joining stream
        add_user_to_database(db, user_id, display_name)
+
+    if data["type"] == "USER_JOINED":
        if data["eventData"]["user"]["authenticated"]:
            remove_duplicate_usernames(db, user_id, display_name)
    elif data["type"] == "NAME_CHANGE":
@@ -27,25 +37,30 @@ def owncast_webhook():
        if data["eventData"]["user"]["authenticated"]:
            remove_duplicate_usernames(db, user_id, new_name)
    elif data["type"] == "CHAT":
-        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"]["body"]}')
-        if "!help" in data["eventData"]["body"]:
-            send_help()
-        elif "!points" in data["eventData"]["body"]:
-            if not user_exists(db, user_id):
-                add_user_to_database(db, user_id, display_name)
-            points = read_users_points(db, user_id)
-            message = f"{display_name}'s points: {points}"
-            send_chat(message)
-        elif "!name_update" in data["eventData"]["body"]:
-            # 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"]["body"].startswith("!"):  # TODO: make prefix configurable
-            handle_redeem(data["eventData"]["body"], user_id)
+        if not current_app.config['PASSIVE']:
+            prefix = current_app.config['PREFIX']
+            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"):
+                send_help()
+            elif data["eventData"]["rawBody"].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"):
+                # 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)
    return data
@@ -0,0 +1,34 @@
+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}")
@@ -0,0 +1,63 @@
+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
+
@@ -0,0 +1,80 @@
+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
+
@@ -0,0 +1,75 @@
+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
@@ -0,0 +1,74 @@
+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
@@ -1,10 +1,13 @@
 from flask import current_app
 from tlapbot.db import get_db
-from tlapbot.owncast_helpers import (use_points, add_to_redeem_queue,
-        add_to_counter, read_users_points, send_chat)
+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


-def handle_redeem(message, user_id):
+def handle_redeem(message: str, user_id: str) -> None:
    split_message = message[1:].split(maxsplit=1)
    redeem = split_message[0]
    if len(split_message) == 1:
@@ -12,30 +15,67 @@ def handle_redeem(message, user_id):
    else:
        note = split_message[1]

-    if redeem in current_app.config['REDEEMS']:
-        db = get_db()
-        price = current_app.config['REDEEMS'][redeem]["price"]
-        redeem_type = current_app.config['REDEEMS'][redeem]["type"]
-        points = read_users_points(db, user_id)
-        if points is not None and points >= price:
-            if redeem_type == "counter":
-                add_to_counter(db, redeem)
-                use_points(db, user_id, price)
-                send_chat(f"{redeem} redeemed for {price} points.")
-            elif redeem_type == "list":
-                add_to_redeem_queue(db, user_id, redeem)
-                use_points(db, user_id, price)
-                send_chat(f"{redeem} redeemed for {price} points.")
-            elif redeem_type == "note":
-                if note is not None:
-                    add_to_redeem_queue(db, user_id, redeem, note)
-                    use_points(db, user_id, price)
-                    send_chat(f"{redeem} redeemed for {price} points.")
-                else:
-                    send_chat(f"Cannot redeem {redeem}, no note included.")
-            else:
-                send_chat(f"{redeem} not redeemed because of an error.")
-        else:
-            send_chat(f"Can't redeem {redeem}, you don't have enough points.")
-    else:
+    if redeem not in current_app.config['REDEEMS']:
        send_chat("Can't redeem, redeem not found.")
+        return
+    if not is_redeem_active(redeem):
+        send_chat("Can't redeem, redeem is currently not active.")
+        return
+
+    db = get_db()
+    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):
+            send_chat(f"Can't redeem {redeem}, that milestone was already completed!")
+        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.")
+        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):
+                send_chat(f"Milestone goal {redeem} complete!")
+        else:
+            send_chat(f"Redeeming milestone {redeem} failed.")
+        return
+
+    # handle redeems with price argument
+    price = current_app.config['REDEEMS'][redeem]["price"]
+    if not points or points < price:
+        send_chat(f"Can't redeem {redeem}, you don't have enough points.")
+        return
+
+    if redeem_type == "counter":
+        if add_to_counter(db, redeem) and use_points(db, user_id, price):
+            send_chat(f"{redeem} redeemed for {price} points.")
+        else:
+            send_chat(f"Redeeming {redeem} failed.")
+    elif redeem_type == "list":
+        if (add_to_redeem_queue(db, user_id, redeem) and
+                use_points(db, user_id, price)):
+            send_chat(f"{redeem} redeemed for {price} points.")
+        else:
+            send_chat(f"Redeeming {redeem} failed.")
+    elif redeem_type == "note":
+        if not note:
+            send_chat(f"Cannot redeem {redeem}, no note included.")
+            return
+        if (add_to_redeem_queue(db, user_id, redeem, note) and
+                use_points(db, user_id, price)):
+            send_chat(f"{redeem} redeemed for {price} points.")
+        else:
+            send_chat(f"Redeeming {redeem} failed.")
+    else:
+        send_chat(f"{redeem} not redeemed, type of redeem not found.")
@@ -1,5 +1,7 @@
 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,
@@ -7,6 +9,13 @@ CREATE TABLE IF NOT EXISTS points (
  points INTEGER
 );

+CREATE TABLE milestones (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  progress INTEGER NOT NULL,
+  goal INTEGER NOT NULL
+);
+
 CREATE TABLE counters (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
@@ -20,4 +29,11 @@ CREATE TABLE redeem_queue (
  redeemer_id TEXT NOT NULL,
  note TEXT,
  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
 );
@@ -15,5 +15,9 @@ function openTab(event, tabName) {
  
    // Show the current tab, and add an "active" class to the button that opened the tab
    document.getElementById(tabName).style.display = "block";
-    evt.currentTarget.className += " active";
-  }
+    event.currentTarget.className += " active";
+  }
+
+function refreshPage() {
+    window.location.reload();
+}
@@ -1,37 +1,77 @@
 <!DOCTYPE html>
 <html lang="en">
 <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+
 <head>
    <title>Redeems Dashboard</title>
 </head>
 <div id="script">

-<script src="/static/dashboard.js"></script>
+    <script src="/static/dashboard.js"></script>

    <div class="tab">
-        <button class="tablinks" onclick="openTab(event, 'dashboard')", id="defaultOpen">Tlapbot dashboard</button>
+        <button class="tablinks" onclick="openTab(event, 'dashboard')" , id="defaultOpen">Tlapbot dashboard</button>
+        {% if not passive %}
+        {% if queue %}
+        <button class="tablinks" onclick="openTab(event, 'redeem-queue')">Redeem queue</button>
+        {% endif %}
        <button class="tablinks" onclick="openTab(event, 'redeems-list')">Redeems help</button>
+        {% endif %}
    </div>

    <div id='dashboard' class="tabcontent">
+
        <body>
            <h3>Redeems Dashboard</h3>
-            {% if (username and users ) %}
+            {% if (username and users) %}
            <table>
                <thead>
                    <tr>
                        <th>Your points balance</th>
                    </tr>
                </thead>
-                {% for user in users %}
                <tbody>
-                    <td> {{ user[0] }} </td>
-                    <td> {{ user[1] }} </td>   
-                </tbody>
+                {% for user in users %}
+                    <tr>
+                        <td> {{ user[0] }} </td>
+                        <td> {{ user[1] }} </td>
+                    </tr>
                {% endfor %}
+                </tbody>
            </table>
            {% endif %}

+            {% if passive %}
+            <h3>Tlapbot is currently in passive mode.</h3>
+            <p>You can't make any redeems, but you will receive points for watching.</p>
+            {% 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>
@@ -39,20 +79,49 @@
                        <th>Active counters</th>
                    </tr>
                </thead>
-                {% for counter in counters %}
                <tbody>
-                    <td> {{ counter[0] }} </td>
-                    <td> {{ counter[1] }} </td>   
-                </tbody>
+                {% for counter in counters %}
+                    <tr>
+                        <td> {{ counter[0] }} </td>
+                        <td> {{ counter[1] }} </td>
+                    </tr>
                {% endfor %}
+                </tbody>
            </table>
            {% endif %}
+            {% if milestones %}
+            <table>
+                <thead>
+                    <tr>
+                        <th colspan="2">Active milestones</th>
+                        <th>Progress</th>
+                    </tr>
+                </thead>
+                <tbody>
+                {% for milestone in milestones %}
+                    <tr>
+                        <td> {{ milestone[0] }} </td>
+                        <td> <progress id="file" max={{ milestone[2] }} value={{ milestone[1] }}></progress></td>
+                        <td> {{ milestone[1] }} / {{ milestone[2] }}</td>
+                    </tr>
+                {% endfor %}
+                </tbody>
+            </table>
+            {% endif %}
+            {% endif %}
+        </body>
+    </div>

+    <div id='redeem-queue' class="tabcontent">
+
+        <body>
+            <h3>Redeems Queue</h3>
+            <p>Past redeemed redeems with timestamps and notes.</p>
            {% if queue %}
            <table>
                <thead>
                    <tr>
-                        <th>Recent redeems</th>
+                        <th colspan="2">Recent redeems</th>
                    </tr>
                    <tr>
                        <th>Time</th>
@@ -61,16 +130,18 @@
                        <th>Note</th>
                    </tr>
                </thead>
+                <tbody>
                {% for row in queue %}
-            <tbody>
-                    <td>{{ row[0].replace(tzinfo=utc_timezone).astimezone().strftime("%H:%M") }}</td>
-                    <td>{{ row[1] }}</td>
-                    <td>{{ row[3] }}</td>
-                    {% if row[2] %}
-                    <td>{{ row[2] }}</td>
-                    {% endif %}
-                </tbody>
+                    <tr>
+                        <td>{{ row[0].replace(tzinfo=utc_timezone).astimezone().strftime("%H:%M") }}</td>
+                        <td>{{ row[1] }}</td>
+                        <td>{{ row[3] }}</td>
+                        {% if row[2] %}
+                        <td>{{ row[2] }}</td>
+                        {% endif %}
+                    </tr>
                {% endfor %}
+                </tbody>
            </table>
            {% endif %}
        </body>
@@ -83,7 +154,10 @@
            <li><strong>Counter</strong> redeems add +1 to their counter.</li>
            <li><strong>List</strong> redeems get added to the list of recent redeems (without a note).</li>
            <li><strong>Note</strong> redeems require you to send a message together with the redeem.</li>
+            <li><strong>Milestone</strong> redeems are long-term goals to which you can donate any amount of points you
+                want. They will be completed once the amount of points donated reaches the goal.</li>
        </ul>
+
        <body>
            {% if redeems %}
            <table>
@@ -95,25 +169,32 @@
                        <th>Description</th>
                    </tr>
                </thead>
-                {% for redeem, redeem_info in redeems.items() %}
                <tbody>
-                    <td>!{{ redeem }}</td>
-                    <td>{{ redeem_info["price"] }}</td>
-                    <td>{{ redeem_info["type"] }}</td>
-                    {% if redeem_info["info"] %}
-                    <td>{{ redeem_info["info"] }}</td>
-                    {% endif %}
-                </tbody>
+                {% for redeem, redeem_info in redeems.items() %}
+                    <tr>
+                        <td>{{ prefix }}{{ redeem }}</td>
+                        {% if redeem_info["type"] == "milestone" %}
+                        <td></td>
+                        {% else %}
+                        <td>{{ redeem_info["price"] }}</td>
+                        {% endif %}
+                        <td>{{ redeem_info["type"] }}</td>
+                        {% if redeem_info["info"] %}
+                        <td>{{ redeem_info["info"] }}</td>
+                        {% endif %}
+                    </tr>
                {% endfor %}
+                </tbody>
            </table>
            {% endif %}
        </body>
    </div>

+    <script>
+        document.getElementById("defaultOpen").click();
+        setTimeout(refreshPage, 30 * 1000);
+    </script>
+
 </div>

-<script>
-    document.getElementById("defaultOpen").click();
-</script>
-
-</html>
+</html>
@@ -0,0 +1,33 @@
+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.owncast_helpers import read_all_users_with_username
+from datetime import timezone
+
+bp = Blueprint('redeem_dashboard', __name__)
+
+
+@bp.route('/dashboard', methods=['GET'])
+def dashboard() -> str:
+    db = get_db()
+    username = request.args.get("username")
+    if username is not None:
+        users = read_all_users_with_username(db, username)
+    else:
+        users = []
+    utc_timezone = timezone.utc
+    return render_template('dashboard.html',
+                           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,
+                           prefix=current_app.config['PREFIX'],
+                           passive=current_app.config['PASSIVE'],
+                           username=username,
+                           users=users,
+                           utc_timezone=utc_timezone)
@@ -0,0 +1,4 @@
+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]
Author	SHA1	Message	Date
lili	0bae46e852	add polls documentation	2025-12-14 20:04:36 +01:00
lili	a52db9f6ae	make polls not work when they're disabled	2025-12-14 19:42:34 +01:00
lili	924c4c547f	show polls on dashboard	2025-12-14 19:22:57 +01:00
lili	d7fdc1e183	functioning polls	2025-12-12 20:01:09 +01:00
lili	bd6f94a976	poll handler fixes: better split, early return	2025-12-10 20:29:07 +01:00
lili	32596ab4e5	add poll db commands to init, fix db poll commands	2025-12-10 19:44:03 +01:00
lili	6f4c6b33f2	argument fix (teardown passes arguments to the function)	2025-12-10 19:01:15 +01:00
lili	ecdd399e27	sql fix	2025-12-10 19:01:01 +01:00
lili	3bbfc140ef	import fix	2025-12-10 19:00:45 +01:00
lili	b8fb30a2ae	add TODO	2025-03-10 21:08:05 +01:00
lili	70285958d1	WIP: add polls	2025-03-10 21:06:40 +01:00
lili	9592e2daf0	move defaults to defaults folder	2025-03-10 19:52:55 +01:00
lili	d0ff884dec	split redeems.py into a folder	2025-03-10 19:36:15 +01:00
lili	56cb94e1a0	remove the complete column from milestones table	2025-03-07 23:11:42 +01:00
lili	4e363876e7	add None points handling to redeems_handler	2024-10-06 15:23:48 +02:00
lili	20e3d6d4b2	add types to dashboard	2024-10-06 15:23:38 +02:00
lili	b3cbe42450	add types to owncast_webhooks	2024-10-06 15:23:30 +02:00
lili	68c585405d	expand types and comments in helpers	2024-10-06 15:23:18 +02:00
lili	e8d8c265a7	add types to db	2024-10-06 15:23:02 +02:00
lili	a274ddb89f	add types to init	2024-10-06 15:22:34 +02:00
lili	22fcea8a96	add types to requests	2024-10-06 15:22:25 +02:00
lili	0d5d82a23b	fix type alias, remove unused functions	2024-10-06 15:21:57 +02:00
lili	50403381e0	fix is_redeem_from_config_active type hints	2024-10-06 11:18:43 +02:00
lili	6758829634	typo fix	2024-10-06 11:08:50 +02:00
lili	9f89a2a892	rename tlapbot types :(	2024-10-06 11:08:17 +02:00
lili	c8d2865383	redeems.py type signatures, add_to_redeem_queue improvement, redeem alias need to test slight change	2024-10-06 11:03:56 +02:00
lili	09de99234c	add type signature to handle_redeem	2024-10-06 11:02:05 +02:00
lili	fe75fb7acc	type signature for send_help	2024-10-05 22:09:13 +02:00
lili	477151f423	typo fix	2024-10-05 22:08:47 +02:00
lili	c22af69b2a	type signatures in owncast_helpers + typo fix	2024-10-05 22:08:19 +02:00
lili	afd0a0d0a3	another readme update because im nervous	2024-03-10 18:04:19 +01:00
lili	2a6aa58ced	readme updates -- better description of what tlapbot does some small fixes	2024-02-26 17:36:06 +01:00
lili	2284fb3a00	1.2.2 release	2024-02-11 20:17:17 +01:00
lili	3fe454d35c	promote to alpha 2	2024-02-10 15:00:35 +01:00
lili	f1a57c16e4	style corrections	2024-02-10 13:38:26 +01:00
lili	7da002eb00	remove unused imports, variables	2024-02-10 13:33:09 +01:00
lili	5e7810eb9f	another list_redeems fix dont use list_redeems	2024-02-10 12:21:29 +01:00
lili	61d318f418	fix and improve LIST_REDEEMS	2024-02-10 11:57:57 +01:00
lili	ba30c96c01	warning improvement	2024-02-10 11:49:09 +01:00
lili	6d3a4671cc	fix dictionary iteration in redeems	2024-02-10 11:31:51 +01:00
lili	384ca03e23	rewrite space warning	2024-02-06 20:16:54 +01:00
lili	7722bdf608	add redeem name warning to init	2024-02-06 20:15:58 +01:00
lili	7dfc8faae7	add warning about spaces	2024-02-06 20:12:12 +01:00
lili	8e4d21c02f	clarify positivity of integer	2024-02-06 19:11:53 +01:00
lili	571aa47aab	make zero points not redeemable	2024-02-06 19:10:37 +01:00
lili	433564bddf	only one debug log for terminal needed	2024-02-06 19:06:00 +01:00
lili	1abab80da4	promote to 1.2.2a1	2024-02-06 18:21:38 +01:00
lili	894ff175a6	remove redundant line ends	2024-02-06 18:18:15 +01:00
lili	6641121ca3	add <br>s to help message construction	2024-02-04 18:09:47 +01:00
lili	7ffb1a15b0	change webhook to use rawBody instead of body when reading msg remove_emoji function is now unused, as shortcodes get scrubbed in rawBody now	2024-02-04 18:09:36 +01:00
lili	e5e88bf520	Merge branch 'master' of github.com:SleepyLili/tlapbot into develop	2024-02-04 11:28:51 +01:00
lili	b4a6c4e41c	html/jinja formatting improvements thanks chat	2024-02-03 18:47:42 +01:00
lili	8c19088640	readme: reword milestone "goal" and "price" should hopefully suggest more clearly that milestones need goal and everything else needs price also changed the example to list goal first	2023-07-13 12:44:15 +02:00
lili	5316f7e205	improve default_redeems list milestone "goal" first in the redeems dictionary	2023-07-13 12:42:46 +02:00
lili	31426fd851	promote to 1.2.1	2023-07-10 11:16:44 +02:00
lili	8d5a3cda42	update readme for 1.2.1	2023-07-10 11:13:31 +02:00
lili	e237e7f885	declare alpha version 1.2.1a1	2023-07-03 12:56:03 +02:00
lili	80037593a9	fix redeem handler for redeems with no price milestone needs to be handled first	2023-07-03 12:27:45 +02:00
lili	d484a0a363	fix reset_milestone	2023-07-03 12:18:29 +02:00
lili	348e674f74	make price tab in dashboard blank for milestones	2023-07-03 11:02:09 +02:00
lili	ca9aa6d79d	add reset and hard-reset command to init	2023-07-03 10:46:35 +02:00
lili	ae42a052de	add true/false fail checks to click commands previously click would print stuff like "X done succesfully" after error now it'll be more clear that a failure has occured	2023-06-26 13:40:26 +02:00
lili	d1416d3706	add reset-milestone and hard-reset-milestone commands to click	2023-06-26 13:28:34 +02:00
lili	f66b125ac3	remove unused start_milestone function	2023-06-26 13:12:28 +02:00
lili	6f6fc10d0f	remove minimum bid for #15	2023-06-20 14:39:19 +02:00
lili	bf68f518da	add error handling and response check to requests	2023-06-20 13:41:22 +02:00
lili	8e74da1f26	release time?	2023-03-28 14:51:53 +02:00
lili	b08371838f	fix redeeming inactive redeem	2023-03-28 13:05:35 +02:00
lili	739438f28b	move active category check from __init__.py to being done runtime in functions	2023-03-28 13:02:50 +02:00
lili	d372ed6e6b	bugfix: check_apply_milestone was []ing None	2023-03-27 16:38:05 +02:00
lili	1b02624dea	bugfix: milestone_complete was trying to [] None	2023-03-27 16:30:39 +02:00
lili	265a6cc9b4	fix check for more than have, add error chat	2023-03-27 16:30:24 +02:00
lili	021737ad16	check if user has all the points they're sending	2023-03-27 14:24:35 +02:00
lili	6c2eb41ec3	update initial setup with counters/milestones	2023-03-27 14:21:31 +02:00
lili	c68a3924fc	simplify refresh_counters	2023-03-27 14:19:26 +02:00
lili	6e500c962d	fix import	2023-03-27 13:34:31 +02:00
lili	0b84e06c52	hide inactive milestones/counters, change fn name function is is_redeem_active	2023-03-27 13:34:13 +02:00
lili	b985a58b8f	update beta version -- release candidate?	2023-03-27 11:00:42 +02:00
lili	19f8e28780	fix typo in readme	2023-03-26 14:08:26 +02:00
lili	99e014b2d1	fix the instance folder references in readme	2023-03-26 14:06:40 +02:00
lili	5f0aa468c7	readme updates: correct instance folder location also add a disclaimer about redeems.py	2023-03-26 13:31:00 +02:00
lili	1937c5d660	add negative bid protection to add_to_milestone	2023-03-26 13:11:31 +02:00
lili	3858a14f1a	add goal changing to refresh_milestones()	2023-03-26 12:22:54 +02:00
lili	ea1fc6e051	add example milestone to README.md	2023-03-22 14:53:48 +01:00
lili	0176b6e84c	fix minimum bid bug	2023-03-21 12:32:19 +01:00
lili	7b31dbcb31	move redeem types summary after dashboard images	2023-03-21 12:16:36 +01:00
lili	6248a2c546	update readme images to nice ones	2023-03-21 12:09:39 +01:00
lili	44eb0be6e2	fix typos in default_redeems.py	2023-03-21 11:47:32 +01:00
lili	abbc099661	add new default milestone update wording on "price" to mention milestone minimum bid	2023-03-21 11:46:28 +01:00
lili	7a37f8afcf	change reference to tlapbot dashboard in init py	2023-03-21 11:40:55 +01:00
lili	f8a174b94f	readme update passive mode, milestone goals, goal in redeems dict also changed wording on init-db function also removed the in-development line for being confusing	2023-03-21 10:03:26 +01:00
lili	b8e465e50c	rename owncast_redeem_dashboard->tlapbot_dashboard	2023-03-20 17:41:56 +01:00
lili	26c94a65a9	update version to beta 1 for tomorrow's stream	2023-03-20 17:29:16 +01:00
lili	10e84d4aab	split redeem operations into redeems.py owncast_helpers.py is now smaller and only contains smaller, generic fns so no direct redeem manipulations, but reading points, users, etc.	2023-03-20 17:28:54 +01:00
lili	7235340a39	split out requests to owncast_requests.py	2023-03-20 17:16:17 +01:00
lili	d6297c537f	fix completeness function	2023-03-20 17:10:33 +01:00
lili	e1ef0c4619	add needed imports	2023-03-20 14:28:50 +01:00
lili	49053ee4f4	add completeness to milestones	2023-03-20 13:23:20 +01:00
lili	9d910e58ce	bump version for stream	2023-03-16 16:29:03 +01:00
lili	583aeedf64	fix typo	2023-03-15 14:21:15 +01:00
lili	423f12ed34	fix milestone deletion	2023-03-15 14:19:38 +01:00
lili	7e408c1b74	remove number of donated points from message it's not always true.	2023-03-15 14:11:34 +01:00
lili	cf8376eebc	add refresh-milestones to cli. fix cli errors	2023-03-15 14:11:11 +01:00
lili	c203ce132f	add refresh milestones command	2023-03-15 13:37:21 +01:00
lili	22501c80c0	milestone upgrade subtract pts, rename count to progress, send a chat message on success	2023-03-15 13:13:14 +01:00
lili	54ea10a43c	change alpha version for livestream	2023-03-14 16:46:29 +01:00
lili	9019f98031	prettier milestone, redeem queue tab	2023-03-14 16:43:26 +01:00
lili	e8b9ca3cda	Remove extra line from milestone explanation	2023-03-14 16:31:28 +01:00
lili	9323b58ed6	FIXED milestones dashboard	2023-03-14 16:28:45 +01:00
lili	cb574618a6	working milestones prototype in dashboard	2023-03-14 16:26:04 +01:00
lili	68b8588c76	dashboard milestones stub	2023-03-14 15:42:14 +01:00
lili	2732967e26	fix error catching in add_to_milestone	2023-03-14 15:14:52 +01:00
lili	07c701de71	milestone stub + helpers name change lets hope milestones work	2023-03-14 14:15:18 +01:00
lili	90615ce7c6	add colspan to "recent redeems" no longer makes an extra line	2023-03-13 15:29:34 +01:00
lili	82d9088c18	first version of passive mode seems to work fine	2023-03-13 15:22:40 +01:00
lili	189ffcc1a8	add error check to is_stream_live()	2023-03-13 14:59:20 +01:00
lili	0d56521602	add prefix info to readme	2023-01-18 17:08:56 +01:00
lili	a5b38865eb	promote beta build to full release	2023-01-18 16:44:36 +01:00
lili	fd66271a4c	more readme updates	2023-01-18 14:30:16 +01:00
lili	af66b9f839	more readme updates	2023-01-18 14:27:27 +01:00
lili	2f13ffabe9	readme: more domain changes to .example, wording	2023-01-18 10:57:05 +01:00
lili	2d0976f441	readme update: change example domain to .example	2023-01-18 10:54:23 +01:00
lili	c6542515aa	readme update: add more about categories	2023-01-18 10:53:35 +01:00
lili	ddaa111c84	promote build to beta 1 all features are about done, let's goooooooooooooooooooo	2023-01-16 13:31:52 +01:00
lili	c047ec94ac	add auto-refresh to dashboard + fix bug selected "tab"/"button" is now properly highlighted dashboard refreshes every 30 seconds	2023-01-16 13:30:43 +01:00
lili	0c678d8988	add a safeguard for empty list categories redeems remove warnings in readme about it as well	2023-01-16 13:30:15 +01:00
lili	dc68887c82	change redeem categories to list format	2023-01-13 18:51:44 +01:00
lili	02bf3223c4	draft of updated readme currently it says that categories are a list but they are not. i hope to make them a list before release lol	2023-01-13 15:12:56 +01:00
lili	f3d088d6fb	change types to categories to avoid confusion with actual types of redeems like list	2023-01-13 12:57:43 +01:00
lili	ae792192e8	add a category example to default redeems	2023-01-13 11:04:30 +01:00
lili	ef2f6910e6	add a refresh+clear command	2023-01-13 11:04:01 +01:00
lili	625d37209c	promote build to alpha 2	2023-01-12 14:40:19 +01:00
lili	10c4f6f514	split long line	2023-01-12 14:40:05 +01:00
lili	27812b9480	add first implementation of redeem categories	2023-01-12 14:23:32 +01:00
lili	2138650f91	reorganize helpers file	2023-01-12 13:20:28 +01:00
lili	d3763d51c3	fix regex to be non-greedy	2023-01-11 10:25:48 +01:00
lili	05f28b71bd	promote develop build to 1.1.0a1 very early alpha, still missing 2 things from the checklist	2023-01-10 12:23:59 +01:00
lili	6283a8f948	split long line in db.py	2023-01-09 15:21:20 +01:00
lili	537fa01aef	split long lines in redeems_handler.py	2023-01-09 15:17:45 +01:00
lili	25589ff69e	add emoji html junk removing function emoji in redeem notes now show up as their shortcodes	2023-01-09 15:08:33 +01:00
lili	85c4df9250	add an error message to points read too	2023-01-05 14:32:53 +01:00
lili	543dc3e5b9	change logger logs to f-strings I read on a webpage the way it used to be would work but the webpage lied and I got not all arguments converted error	2023-01-05 14:26:18 +01:00
lili	b666211142	better handling of errors in redeems situations short circuit execution that doesnt take away points + better message	2023-01-05 11:27:10 +01:00
lili	c978b27799	remove unnecessary import	2023-01-05 11:01:54 +01:00
lili	efd773e2e8	fix typo that broke check_counter_exists	2023-01-04 13:53:46 +01:00
lili	7625d9b959	check if counter exists before incrementing nonexistant counter prints warning + recommends running refresh-counters	2023-01-04 13:22:47 +01:00
lili	f1dfb79f2c	remove prefix comment	2023-01-04 12:41:12 +01:00
lili	6a3e74cdec	add prefix sanity check to init tlapbot will throw runtime error if prefix isn't a single character longer prefixes would break the bot bc of how redeems_handler.py works	2023-01-04 12:38:58 +01:00
lili	92a2a77c80	add customized prefix to dashboard	2023-01-04 12:37:56 +01:00
lili	3caaed4b35	add customizable prefix	2023-01-04 12:37:45 +01:00
lili	a5463c09ee	simplify dashboard file removed redundant assignments to variables	2023-01-04 12:30:38 +01:00
lili	3282072b42	split long line was over 100 characters	2023-01-03 13:38:15 +01:00
lili	b34524334c	rewrite error message make it clear that read_all_users_with_username reads multiple values	2023-01-03 13:34:06 +01:00
lili	8e461c5076	remove redundant list conversion unique_users is only used to iterate over and set is an iterable so i do not need to convert it to list	2023-01-03 13:32:07 +01:00
lili	e65ffae8ce	promote 1.0.1alpha to 1.0.1	2022-12-07 11:14:33 +01:00
lili	c6d94f9d5f	version 1.0.1alpha for my next stream	2022-12-05 16:06:39 +01:00
lili	bafa1eca16	fix behavior with 2 commands + new user crashes issue #5 crash i discovered when testing (users joining when bot is resetting)	2022-12-05 11:36:25 +01:00
Lili (Lin) Pavelů	9c0e709c63	Merge pull request #8 from trwnh/patch-3 Fix: Change POST to GET for certain API calls	2022-12-05 11:23:12 +01:00
Lili (Lin) Pavelů	99bdcc16cc	Merge pull request #7 from trwnh/patch-2 Fix: Remove strict "is True" check	2022-12-05 11:22:58 +01:00
Lili (Lin) Pavelů	89c9d5945a	Merge pull request #6 from trwnh/patch-1 Refactor: reduce nesting	2022-12-05 11:22:45 +01:00
trwnh	65b68f886e	Fix: Change POST to GET for certain API calls I'm not sure why Owncast responds to a POST when it should be a GET, but this is probably not reliable behaviour	2022-11-30 11:29:00 -06:00
trwnh	fe57550de2	Fix: Remove strict "is True" check `is True` checks that the value points to the same memory. To check for truthiness, use `== True` or simply `if condition`	2022-11-30 11:00:30 -06:00
trwnh	420d954568	Refactor: reduce nesting We can reduce cyclomatic complexity (how far we indented) by checking for a negative condition and exiting early, instead of checking for a positive condition and continuing	2022-11-30 10:45:52 -06:00