lili
/
Tlapbot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 6 Wiki Activity

Compare commits

base: lili:master
Branches Tags
lili:master
lili:develop
lili:auto-refresh
lili:improved-help
lili:configurable-redeems
lili:v1.2.2
lili:v1.2.1
lili:v1.2.0
lili:v1.1.0
lili:v1.0.1
lili:v1.0.0
..
compare: lili:configurable-redeems
Branches Tags
lili:develop
lili:master
lili:auto-refresh
lili:improved-help
lili:configurable-redeems
lili:v1.2.2
lili:v1.2.1
lili:v1.2.0
lili:v1.1.0
lili:v1.0.1
lili:v1.0.0

No commits in common. "master" and "configurable-redeems" have entirely different histories.
master ... configurab

19 changed files with 329 additions and 1237 deletions
Show Stats Expand all files Collapse all files

2
.gitignore vendored
View File

@ -10,3 +10,5 @@ htmlcov/
dist/
build/
*.egg-info/
config.py

336
README.md
View File

@ -1,129 +1,37 @@
# Tlapbot
Tlapbot is an [Owncast](https://owncast.online/) bot that adds channel points and
channel point redeems to your Owncast page.
Similar
to [Twitch channel points](https://help.twitch.tv/s/article/viewer-channel-point-guide), Tlapbot rewards your viewers with points for watching, and allows them to spend their points on fun gimmicks, challenges, reaction requests, or whatever else you decide.
Tlapbot makes use of [Owncast webhooks](https://owncast.online/thirdparty/webhooks/) for chat interactions and
[Owncast external actions](https://owncast.online/thirdparty/actions/) to display an informative dashboard.
Tlapbot is an [Owncast](https://owncast.online/) bot, aiming to add the feature of channel points and
channel point redeems to Owncast.
This bot is currently in-development. The goal is to have a feature set on par
with Twitch channel points, while making use of Owncast webhooks and especially
[External actions](https://owncast.online/thirdparty/actions/).
## Features
The bot gives points to everyone in chat -- 10 points every 10 minutes by
default, but the time interval and amount of points can be changed.
Currently, the bot gives points to everyone in chat -- the interval can be
configured in the config, as well as the amount of points given.
The users in chat can then use their points on redeems -- rewards like "choose my
background music", "choose what level to play next", "react to this video" etc.
You can configure redeems to fit your stream and the activities you're
doing, and sort them into categories that can be turned on and off.
The users in chat can then use their points on redeems. The bot currently
only has one hardcoded redeem, but I'd like to make this configurable,
so that every Owncast streamer can set up their own redeems that best fit
their stream.
The redeems then show on a "Redeems dashboard" that everyone can view
as an External Action on the Owncast stream, or at its standalone URL.
This allows easy browsing of active challenges and recent redeems, without quitting the stream.
**Tlapbot currently doesn't support any automated integrations (or an API). That means no 'Crowd Control' plugin, no instant effects in OBS or VTube Studio, etc. The streamer decides how they respond to redeems or how to make them take effect.** (I'd love to support more seamless, automatic redeems in the future!)
### 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 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.
Every time a chatter redeems a List redeem, the redeem gets added to the list of recent redeems with a timestamp, similar to how redeems on Twitch get added to the [Twitch redeem queue](https://help.twitch.tv/s/article/making-the-most-of-channel-points?language=en_US#manage).
Unlike the Note redeems, chatters can't write messages to send along with their List redeems, so make sure the redeem makes sense on its own, like "stop talking for one minute", or "drop your weapon", etc.
#### Note
Note redeems are like List redeems, they get added to the list of recent redeems.
Unlike the List redeems, chatters can add a message to their Note redeems, so this is the ideal type for open-ended redeems like "choose what character I play as next", "choose what song to play next", etc.
#### Counter
Counter is a unique redeem type, in that it doesn't show up in the list of recent redeems, and counters don't list the people who redeemed them. This redeem type is good for any rewards or incentives where the important thing isn't "who redeemed it?" but rather "how many people redeemed it?"
Instead, the tlapbot dashboard keeps a number for each "counter", and each redeems adds +1 to it.
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.
#### 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.
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.
Milestones show as a progress bar on the dashboard.
Milestone redeems can be used as long-term community challenges, to start streamer
challenges, decide new games to play, etc.
## 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.
I didn't make Tlapbot available under a permissive or a free software license, as Owncast is also used by some religious groups, extremist individuals, and dubious corporations to self-host their streams, and I do not want for them to use the bot.
at the flask server's URL, which can be included in Owncast
as an External action, a single button that displays information about
recent redeems.
## Setup
Tlapbot requires Python 3, probably a fairly recent version of it too. (My live instance runs on Python 3.9.2.)
The Python prerequisites for running tlapbot are the libraries `flask`,
`requests` and `apscheduler`. If you follow the installation steps below,
they should automatically be installed if you don't have them.
You can also run Tlapbot in a [Python virtual environment](https://flask.palletsprojects.com/en/2.2.x/installation/#virtual-environments).
### Install from git repo (as a folder)
`requests` and `apscheduler`.
### Dev setup (from git repository)
1. Clone the repository.
2. Run `pip install -e .` in the root folder. This will install tlapbot
as a package in editable more.
3. Set the `FLASK_APP` environment variable.
```bash
export FLASK_APP=tlapbot
```
4. Initialize the database:
as a package in editable more, along with all its prerequisites.
3. Initialize db:
```bash
python -m flask init-db
```
5. Create an `instance/config.py` file and fill it in as needed.
Default values are included in `tlapbot/default_config.py`, and values in
`config.py` overwrite them. (The database also lives in the instance folder
4. Create an `instance/config.py` file and fill it in as needed.
Default values are included in `tlapbot/default_config`, and values in
`config.py` overwrite them. (The database also lives in the `instance` folder
by default.)
Tlapbot might not work if you don't overwrite these:
@ -132,62 +40,35 @@ by default.)
OWNCAST_ACCESS_TOKEN # get one from owncast instance
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`.
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`,
## Owncast setup
In Owncast, navigate to the admin interface at `/admin`,
and then go to Integrations.
### Access Token
In the Access Tokens tab, generate an Access Token to put in
the config file in the instance folder. The bot needs both the "send chat messages" and "perform administrative actions"
In Access Tokens, generate an Access Token to put in
`instance/config.py`. The bot needs both the "send chat messages" and "perform administrative actions"
permissions, since getting the list of all connected chat users is an administrator-only
action.
### Webhook
In the webhooks tab, create a Webhook, and point it at your bot's URL with
In webhooks, create a Webhook, and point it at your bot's URL with
`/owncastWebhook` added.
In debug, this will be something like `localhost:5000/owncastWebhook`. If you're not running the debug Owncast instance and bot on the same machine,
In debug, this will be something like `localhost:5000/owncastWebhook`,
or, if you're not running the debug Owncast instance and bot on the same machine,
you can use a tool like [ngrok](https://ngrok.com/)
to redirect Owncast traffic to your `localhost`.
to redirect the Owncast traffic to your `localhost`.
### External Action
In External Actions, point the external action to your bot's URL with `/dashboard` added.
**External Actions only work with https. Your server will need to support SSL and
https connections for this part to work.**
In debug, pointing the External Action to an address like `localhost:5000/dashboard` might not work because your localhost address doesn't provide https, which owncast requires.
In development, a `localhost` address will not work with External Actions, since it doesn't provide https.
If you use [ngrok](https://ngrok.com/) to redirect Owncast traffic to localhost,
it will work because the ngrok connection is https.
**External Action config example:**
**Example:**
```
URL: MyTlapbotServer.example/dashboard
URL: MyTlapbotServer.com/dashboard
Action Title: Redeems Dashboard
```
#### Note about https and reverse proxying
Since External Actions require a secure https connection (for the tlapbot dashboard to work), you will need to set up a reverse proxy for tlapbot on your server. I'm not including much information about it here, since some knowledge of the topic is required to set up Owncast itself.
The Owncast documentation about SSL and Reverse proxying is here: https://owncast.online/docs/sslproxies/
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.example {
reverse_proxy localhost:8000
}
```
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.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:
@ -202,151 +83,14 @@ Run the app (in debug mode):
```bash
python -m flask --debug run
```
### Running in production:
Set the FLASK_APP variable:
```bash
export FLASK_APP=tlapbot
```
Using the flask debug server for running apps for non-development purposes is not recommended. Rather, you should be using a proper [Python WSGI server](https://flask.palletsprojects.com/en/2.2.x/deploying/).
On my own live owncast instance, I use gunicorn.
Install gunicorn (if you don't have it installed):
```bash
pip install gunicorn
```
Run the app (with gunicorn):
```bash
gunicorn -w 1 'tlapbot:create_app()'
```
You should also set `GUNICORN` in your `config.py` file to `True` to see Tlapbot logs in your gunicorn output. By default, gunicorn will only show `error` and `critical` warnings, but you can set the `--log-level` argument when running the app to set it to `warning`, `debug` or `info` too.
```bash
gunicorn -w 1 --log-level debug 'tlapbot:create_app()'
```
**⚠️WARNING:** Because of the way the scheduler is initialized in the project,
I recommend running tlapbot with only one gunicorn worker. (`-w 1`)
If you use multiple workers, each worker sets up its own scheduler, and then users
get given points by each worker. (So running the app with `-w 4` means users get four times as many points than listed in the config.)
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 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,
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.
```bash
python -m flask clear-queue
```
**If you've changed the config, and want new/different counters to work, you should run the `refresh-counters` command first.**
#### refresh-counters
This command deletes old counters that are no longer in the config file, and then adds all counters from the config file.
You should run this command every time you've added or removed counters from `redeems.py`.
```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, 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
```
## 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.)
#### 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.example"`
#### Optional
Including these values will overwrite their defaults from `/tlapbot/default_config.py`.
- `POINTS_CYCLE_TIME` decides how often channel points are given to users in chat,
### Running in prod:
To be added when I actually run a prod version of the bot.
## Config
Values you can include in `instance/config.py` to change how the bot behaves.
### Channel points interval and amount
`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.
#### 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.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` 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."},
"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 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.
`POINTS_AMOUNT_GIVEN` decides how many channel points users receive.
- `"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.
By default, everyone receives 10 points every 600 seconds (10 minutes).

2
setup.py
View File

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

43
tlapbot/__init__.py
View File

@ -1,9 +1,8 @@
import os
import logging
from flask import Flask
from apscheduler.schedulers.background import BackgroundScheduler
from tlapbot.db import get_db
from tlapbot.owncast_requests import is_stream_live, give_points_to_chat
from tlapbot.owncast_helpers import is_stream_live, give_points_to_chat
def create_app(test_config=None):
@ -22,50 +21,28 @@ def create_app(test_config=None):
)
app.config.from_object('tlapbot.default_config')
app.config.from_object('tlapbot.default_redeems')
app.config.from_pyfile('config.py', silent=True)
app.config.from_pyfile('redeems.py', silent=True)
# Make logging work for gunicorn-ran instances of tlapbot.
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.")
app.config.from_pyfile('config.py')
app.config.from_pyfile('redeems.py')
# prepare webhooks and redeem dashboard blueprints
from . import owncast_webhooks
from . import tlapbot_dashboard
from . import owncast_redeem_dashboard
app.register_blueprint(owncast_webhooks.bp)
app.register_blueprint(tlapbot_dashboard.bp)
app.register_blueprint(owncast_redeem_dashboard.bp)
# add db CLI commands
# add db initialization CLI command
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)
# add clear queue CLI command
from . import owncast_helpers
app.cli.add_command(owncast_helpers.clear_queue_command)
# scheduler job for giving points to users
def proxy_job():
with app.app_context():
if is_stream_live():
app.logger.info("Stream is LIVE. Giving points to chat.")
give_points_to_chat(get_db())
else:
app.logger.info("Stream is NOT LIVE. (Not giving points to chat.)")
# start scheduler that will give points to users
points_giver = BackgroundScheduler()

165
tlapbot/db.py
View File

@ -4,8 +4,6 @@ import click
from flask import current_app, g
from flask.cli import with_appcontext
from tlapbot.redeems import milestone_complete
def get_db():
if 'db' not in g:
@ -29,15 +27,13 @@ def insert_counters(db):
for redeem, redeem_info in current_app.config['REDEEMS'].items():
if redeem_info["type"] == "counter":
try:
db.execute(
cursor = db.execute(
"INSERT INTO counters(name, count) VALUES(?, 0)",
(redeem,)
)
db.commit()
except sqlite3.Error as e:
except Error as e:
print("Failed inserting counters to db:", e.args[0])
return False
return True
def init_db():
@ -46,170 +42,17 @@ def init_db():
with current_app.open_resource('schema.sql') as f:
db.executescript(f.read().decode('utf8'))
if insert_counters(db):
return True
def clear_redeem_queue():
db = get_db()
try:
cursor = db.execute(
"DELETE FROM redeem_queue"
)
cursor.execute(
"""UPDATE counters SET count = 0"""
)
db.commit()
except sqlite3.Error as e:
print("Error occured deleting redeem queue:", e.args[0])
return False
return True
def refresh_counters():
db = get_db()
try:
db.execute("DELETE FROM counters")
db.commit()
except sqlite3.Error as e:
print("Error occured deleting old counters:", e.args[0])
return False
if insert_counters(db):
return True
def refresh_milestones():
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(
"SELECT goal FROM milestones WHERE name = ?",
(redeem,)
)
result = cursor.fetchone()
if result is None:
cursor.execute(
"INSERT INTO milestones(name, progress, goal, complete) VALUES(?, 0, ?, FALSE)",
(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):
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, complete) VALUES(?, ?, ?, FALSE)",
(milestone, 0, current_app.config['REDEEMS'][milestone]['goal'])
)
db.commit()
return True
except sqlite3.Error as e:
current_app.logger.error(f"Error occured adding a milestone: {e.args[0]}")
return False
insert_counters(db)
@click.command('init-db')
@with_appcontext
def init_db_command():
"""Clear the existing data and create new tables."""
if init_db():
init_db()
click.echo('Initialized the database.')
@click.command('clear-queue')
@with_appcontext
def clear_queue_command():
"""Remove all redeems from the 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.)"""
if refresh_counters():
click.echo('Counters refreshed.')
@click.command('clear-refresh')
@with_appcontext
def refresh_and_clear_command():
"""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():
"""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):
"""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):
"""Resets any milestone back to zero."""
if reset_milestone(milestone):
click.echo(f"Hard reset milestone {milestone}.")
def init_app(app):
app.teardown_appcontext(close_db)
app.cli.add_command(init_db_command)

5
tlapbot/default_config.py
View File

@ -3,8 +3,3 @@ OWNCAST_ACCESS_TOKEN=''
OWNCAST_INSTANCE_URL='http://localhost:8080'
POINTS_CYCLE_TIME=600
POINTS_AMOUNT_GIVEN=10
PASSIVE=False
LIST_REDEEMS=False
ACTIVE_CATEGORIES=[]
GUNICORN=False
PREFIX='!'

8
tlapbot/default_redeems.py
View File

@ -1,8 +1,6 @@
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."},
"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"]}
"lurk": {"price": 1, "type": "counter"},
"react": {"price": 200, "type": "note"},
"request": {"price": 100, "type": "note"}
}

30
tlapbot/help_message.py
View File

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

152
tlapbot/owncast_helpers.py
View File

@ -1,6 +1,35 @@
from flask import current_app
import requests
from sqlite3 import Error
from re import sub
import click
from flask.cli import with_appcontext
from tlapbot.db import get_db
# # # requests stuff # # #
def is_stream_live():
url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/status'
r = requests.post(url)
print(r.json()["online"])
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()
# # # db stuff # # #
@ -13,8 +42,8 @@ def read_users_points(db, user_id):
)
return cursor.fetchone()[0]
except Error as e:
current_app.logger.error(f"Error occured reading points: {e.args[0]}")
current_app.logger.error(f"To user: {user_id}")
print("Error occured reading points:", e.args[0])
print("To user:", user_id)
def read_all_users_with_username(db, username):
@ -26,9 +55,8 @@ def read_all_users_with_username(db, username):
users = cursor.fetchall()
return users
except Error as e:
current_app.logger.error(f"Error occured reading points by username: {e.args[0]}")
current_app.logger.error(f"To everyone with username: {username}")
print("Error occured reading points from username:", e.args[0])
print("To user:", username)
def give_points_to_user(db, user_id, points):
try:
@ -38,8 +66,8 @@ def give_points_to_user(db, user_id, points):
)
db.commit()
except Error as e:
current_app.logger.error(f"Error occured giving points: {e.args[0]}")
current_app.logger.error(f"To user: {user_id} amount of points: {points}")
print("Error occured giving points:", e.args[0])
print("To user:", user_id, " amount of points:", points)
def use_points(db, user_id, points):
@ -51,8 +79,8 @@ def use_points(db, user_id, points):
db.commit()
return True
except Error as e:
current_app.logger.error(f"Error occured using points: {e.args[0]}")
current_app.logger.error(f"From user: {user_id} amount of points: {points}")
print("Error occured using points:", e.args[0])
print("From user:", user_id, " amount of points:", points)
return False
@ -66,8 +94,8 @@ def user_exists(db, user_id):
return False
return True
except Error as e:
current_app.logger.error(f"Error occured checking if user exists: {e.args[0]}")
current_app.logger.error(f"To user: {user_id}")
print("Error occured checking if user exists:", e.args[0])
print("To user:", user_id)
def add_user_to_database(db, user_id, display_name):
@ -83,7 +111,7 @@ def add_user_to_database(db, user_id, display_name):
"INSERT INTO points(id, name, points) VALUES(?, ?, 10)",
(user_id, display_name)
)
if user is not None and user[1] is None:
if user is not None and user[1] == None:
cursor.execute(
"""UPDATE points
SET name = ?
@ -92,25 +120,95 @@ def add_user_to_database(db, user_id, display_name):
)
db.commit()
except Error as e:
current_app.logger.error(f"Error occured adding user to db: {e.args[0]}")
current_app.logger.error(f"To user id: {user_id}, with display name: {display_name}")
print("Error occured adding user to db:", e.args[0])
print("To user:", user_id, display_name)
def change_display_name(db, user_id, new_name):
try:
db.execute(
cursor = db.execute(
"UPDATE points SET name = ? WHERE id = ?",
(new_name, user_id)
)
db.commit()
except Error as e:
current_app.logger.error(f"Error occured changing display name: {e.args[0]}")
current_app.logger.error(f"To user id: {user_id}, with display name: {new_name}")
print("Error occured changing display name:", e.args[0])
print("To user:", user_id, new_name)
def add_to_counter(db, counter_name):
try:
cursor = db.execute(
"UPDATE counters SET count = count + 1 WHERE name = ?",
(counter_name,)
)
db.commit()
except Error as e:
print("Error occured adding to counter:", e.args[0])
print("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:
print("Error occured adding to redeem queue:", e.args[0])
print("To user:", user_id, " with redeem:", redeem_name, "with note:", note)
def clear_redeem_queue(db):
try:
cursor = db.execute(
"DELETE FROM redeem_queue"
)
cursor.execute(
"""UPDATE counters SET count = 0"""
)
db.commit()
except Error as e:
print("Error occured deleting redeem queue:", e.args[0])
def all_counters(db):
try:
cursor = db.execute(
"""SELECT counters.name, counters.count FROM counters"""
)
return cursor.fetchall()
except Error as e:
print("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:
print("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:
print("Error occured selecting redeem queue:", e.args[0])
def remove_duplicate_usernames(db, user_id, username):
try:
db.execute(
cursor = db.execute(
"""UPDATE points
SET name = NULL
WHERE name = ? AND NOT id = ?""",
@ -118,14 +216,12 @@ def remove_duplicate_usernames(db, user_id, username):
)
db.commit()
except Error as e:
current_app.logger.error(f"Error occured removing duplicate usernames: {e.args[0]}")
print("Error occured removing duplicate usernames:", e.args[0])
# # # misc. stuff # # #
# This is now unused since rawBody attribute of the webhook now returns cleaned-up emotes.
def remove_emoji(message):
return sub(
r'<img class="emoji" alt="(:.*?:)" title=":.*?:" src="/img/emoji/.*?">',
r'\1',
message
)
@click.command('clear-queue')
@with_appcontext
def clear_queue_command():
"""Remove all redeems from the redeem queue."""
clear_redeem_queue(get_db())
click.echo('Cleared redeem queue.')

26
tlapbot/owncast_redeem_dashboard.py Normal file
View File

@ -0,0 +1,26 @@
from flask import render_template, Blueprint, request
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)
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,
username=username,
users=users,
utc_timezone=utc_timezone)

47
tlapbot/owncast_requests.py
View File

@ -1,47 +0,0 @@
import requests
from flask import current_app
from tlapbot.owncast_helpers import give_points_to_user
def is_stream_live():
url = current_app.config['OWNCAST_INSTANCE_URL'] + '/api/status'
try:
r = requests.get(url)
except requests.exceptions.RequestException as e:
current_app.logger.error(f"Error occured checking if stream is live: {e.args[0]}")
return False
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']}
try:
r = requests.get(url, headers=headers)
except requests.exceptions.RequestException as e:
current_app.logger.error(f"Error occured getting users to give points to: {e.args[0]}")
return
if r.status_code != 200:
current_app.logger.error(f"Error occured when giving points: Response code not 200.")
current_app.logger.error(f"Response code received: {r.status_code}.")
current_app.logger.error(f"Check owncast instance url and access key.")
return
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):
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 occured sending chat message: {e.args[0]}")
return
if r.status_code != 200:
current_app.logger.error(f"Error occured when sending chat: Response code not 200.")
current_app.logger.error(f"Response code received: {r.status_code}.")
current_app.logger.error(f"Check owncast instance url and access key.")
return
return r.json()

47
tlapbot/owncast_webhooks.py
View File

@ -1,12 +1,10 @@
from flask import Flask, request, json, Blueprint, current_app
from sqlite3 import Error
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,
read_users_points, remove_duplicate_usernames)
from tlapbot.help_message import send_help
user_exists, send_chat, read_users_points, remove_duplicate_usernames)
from tlapbot.redeems_handler import handle_redeem
bp = Blueprint('owncast_webhooks', __name__)
@ -14,14 +12,11 @@ bp = Blueprint('owncast_webhooks', __name__)
def owncast_webhook():
data = request.json
db = get_db()
# Make sure user is in db before doing anything else.
if data["type"] in ["CHAT", "NAME_CHANGED", "USER_JOINED"]:
if data["type"] == "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":
@ -31,27 +26,33 @@ def owncast_webhook():
if data["eventData"]["user"]["authenticated"]:
remove_duplicate_usernames(db, user_id, new_name)
elif data["type"] == "CHAT":
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"):
print(f'New chat message from {display_name}:')
print(f'{data["eventData"]["body"]}')
if "!help" in data["eventData"]["body"]:
message = """Tlapbot commands:
!help to see this help message.
!points to see your points.
!name_update to force name update if tlapbot didn't catch it.
Tlapbot redeems:\n"""
for redeem, redeem_info in current_app.config['REDEEMS'].items():
message += (f"!{redeem} for {redeem_info['price']} points.\n")
# TODO: also make this customizable
send_chat(message)
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)
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"):
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"]["rawBody"].startswith(prefix):
handle_redeem(data["eventData"]["rawBody"], user_id)
elif data["eventData"]["body"].startswith("!"): # TODO: make prefix configurable
handle_redeem(data["eventData"]["body"], user_id)
return data

227
tlapbot/redeems.py
View File

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

70
tlapbot/redeems_handler.py
View File

@ -1,9 +1,7 @@
from flask import current_app
from tlapbot.db import get_db
from tlapbot.owncast_requests import send_chat
from tlapbot.redeems import (add_to_redeem_queue, add_to_counter, add_to_milestone,
check_apply_milestone_completion, milestone_complete, is_redeem_active)
from tlapbot.owncast_helpers import use_points, read_users_points
from tlapbot.owncast_helpers import (use_points, add_to_redeem_queue,
add_to_counter, read_users_points, send_chat)
def handle_redeem(message, user_id):
@ -14,62 +12,30 @@ def handle_redeem(message, user_id):
else:
note = split_message[1]
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
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)
# 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 check_apply_milestone_completion(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 points is not None and points >= price:
if redeem_type == "counter":
if add_to_counter(db, redeem) and use_points(db, user_id, price):
add_to_counter(db, redeem)
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)):
add_to_redeem_queue(db, user_id, redeem)
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)):
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"Redeeming {redeem} failed.")
send_chat(f"Cannot redeem {redeem}, no note included.")
else:
send_chat(f"{redeem} not redeemed, type of redeem not found.")
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:
send_chat("Can't redeem, redeem not found.")

9
tlapbot/schema.sql
View File

@ -1,6 +1,5 @@
DROP TABLE IF EXISTS counters;
DROP TABLE IF EXISTS redeem_queue;
DROP TABLE IF EXISTS milestones;
CREATE TABLE IF NOT EXISTS points (
id TEXT PRIMARY KEY,
@ -8,14 +7,6 @@ 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,
complete BOOLEAN NOT NULL
);
CREATE TABLE counters (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,

23
tlapbot/static/dashboard.js
View File

@ -1,23 +0,0 @@
function openTab(event, tabName) {
var i, tabcontent, tablinks;
// Get all elements with class="tabcontent" and hide them
tabcontent = document.getElementsByClassName("tabcontent");
for (i = 0; i < tabcontent.length; i++) {
tabcontent[i].style.display = "none";
}
// Get all elements with class="tablinks" and remove the class "active"
tablinks = document.getElementsByClassName("tablinks");
for (i = 0; i < tablinks.length; i++) {
tablinks[i].className = tablinks[i].className.replace(" active", "");
}
// Show the current tab, and add an "active" class to the button that opened the tab
document.getElementById(tabName).style.display = "block";
event.currentTarget.className += " active";
}
function refreshPage() {
window.location.reload();
}

80
tlapbot/static/style.css
View File

@ -38,51 +38,6 @@ th:last-child {
padding-right: 0
}
h1,
h2,
h3,
h4,
h5,
h6 {
font-weight: 300;
letter-spacing:-.1rem;
margin-bottom:2.0rem;
margin-top:1.5rem
}
h1 {
font-size:4.6rem;
line-height:1.2
}
h2 {
font-size:3.6rem;
line-height:1.25
}
h3 {
font-size:2.8rem;
line-height:1.3
}
h4 {
font-size:2.2rem;
letter-spacing:-.08rem;
line-height:1.35
}
h5 {
font-size:1.8rem;
letter-spacing:-.05rem;
line-height:1.5
}
h6 {
font-size:1.6rem;
letter-spacing:0;
line-height:1.4
}
/* General style */
h1{font-size: 3.6rem; line-height: 1.25}
h2{font-size: 2.8rem; line-height: 1.3}
@ -102,38 +57,3 @@ pre{padding: 1em;}
select {
width: auto;
}
.tab {
overflow: hidden;
border: 1px solid #ccc;
background-color: #f1f1f1;
}
/* Style the buttons that are used to open the tab content */
.tab button {
background-color: inherit;
float: left;
border: none;
outline: none;
cursor: pointer;
padding: 14px 16px;
transition: 0.3s;
}
/* Change background color of buttons on hover */
.tab button:hover {
background-color: #ddd;
}
/* Create an active/current tablink class */
.tab button.active {
background-color: #ccc;
}
/* Style the tab content */
.tabcontent {
display: none;
padding: 6px 12px;
border: 1px solid #ccc;
border-top: none;
}

140
tlapbot/templates/dashboard.html
View File

@ -1,175 +1,63 @@
<!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>
<div class="tab">
<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>
<body>
{% if (username and users ) %}
<table>
<thead>
<tr>
<th>Your points balance</th>
<th>Points balance:</th>
</tr>
</thead>
<tbody>
{% for user in users %}
<tr>
<tbody>
<td> {{ user[0] }} </td>
<td> {{ user[1] }} </td>
</tr>
{% endfor %}
</tbody>
{% endfor %}
</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 counters %}
<table>
<thead>
<tr>
<th>Active counters</th>
<th>Counters</th>
</tr>
</thead>
<tbody>
{% for counter in counters %}
<tr>
<tbody>
<td> {{ counter[0] }} </td>
<td> {{ counter[1] }} </td>
</tr>
{% endfor %}
</tbody>
{% endfor %}
</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 colspan="2">Recent redeems</th>
</tr>
<tr>
<th>Time</th>
<th>Redeem</th>
<th>Redeemer</th>
<th>Note</th>
<th>time</th>
<th>redeem</th>
<th>redeemer</th>
<th>note</th>
</tr>
</thead>
<tbody>
{% for row in queue %}
<tr>
<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 %}
</tr>
{% endfor %}
</tbody>
{% endfor %}
</table>
{% endif %}
</body>
</div>
<div id='redeems-list' class="tabcontent">
<h3>Currently active redeems</h3>
<p>If you have enough points, you can redeem those redeems by typing the command in chat.</p>
<ul>
<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>
<thead>
<tr>
<th>Redeem</th>
<th>Price</th>
<th>Type</th>
<th>Description</th>
</tr>
</thead>
<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>
</body>
</html>

28
tlapbot/tlapbot_dashboard.py
View File

@ -1,28 +0,0 @@
from flask import render_template, Blueprint, request, current_app
from tlapbot.db import get_db
from tlapbot.redeems import all_active_counters, all_active_milestones, all_active_redeems, pretty_redeem_queue
from tlapbot.owncast_helpers import read_all_users_with_username
from datetime import timezone
bp = Blueprint('redeem_dashboard', __name__)
@bp.route('/dashboard', methods=['GET'])
def dashboard():
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),
redeems=all_active_redeems(),
prefix=current_app.config['PREFIX'],
passive=current_app.config['PASSIVE'],
username=username,
users=users,
utc_timezone=utc_timezone)