class Pagination_handler(Handler):
__arguments_schema__ = good.Schema({
'per_page': good.Any(
good.All(
[good.All(good.Coerce(int), good.Range(min=1))],
good.Length(max=1),
),
good.Default([constants.PER_PAGE])
),
'page': good.Any(
good.All(
[good.All(good.Coerce(int), good.Range(min=1))],
good.Length(max=1),
),
good.Default([1])
),
}, default_keys=good.Required, extra_keys=good.Allow,)
def get(self, *args, **kwargs):
args = self.validate_arguments(Pagination_handler.__arguments_schema__)
self.per_page = args.pop('per_page', [0])[0]
self.page = args.pop('page', [0])[0]
self.request.arguments.pop('per_page', None)
self.request.arguments.pop('page', None)
class Handler(Api_handler):
__schema__ = good.Schema({
'length': good.Coerce(int),
})
@Level(3)
async def post(self, channel_id):
data = self.validate()
try:
data = await twitch_channel_token_request(
self,
channel_id=channel_id,
url='https://api.twitch.tv/helix/channels/commercial',
method='POST',
json={
'broadcaster_id': channel_id,
'length': data['length'],
})
self.write({
'retry_after': data['data'][0]['retry_after'],
'message': data['data'][0]['message'],
})
except Twitch_request_error as e:
raise Api_exception(e.status_code, e.message)
class Slots_handler(Api_handler):
__schema__ = good.Schema({
'emote_pool_size':
good.All(good.Coerce(int), good.Range(min=2)),
'payout_percent':
good.All(good.Coerce(int), good.Range(min=1)),
'min_bet':
good.All(good.Coerce(int), good.Range(min=1)),
'max_bet':
good.All(good.Coerce(int), good.Range(min=0)),
'emotes': [str],
'win_message':
good.All(good.Coerce(str), good.Length(min=1, max=250)),
'allin_win_message':
good.All(good.Coerce(str), good.Length(min=1, max=250)),
'lose_message':
good.All(good.Coerce(str), good.Length(min=1, max=250)),
'allin_lose_message':
good.All(good.Coerce(str), good.Length(min=1, max=250)),
})
async def get(self, channel_id):
settings = await self.db.fetchone(
'select * from twitch_gambling_slots_settings where channel_id=%s',
(channel_id),
)
if not settings:
self.set_status(204)
else:
settings.pop('channel_id')
settings['emotes'] = json.loads(settings['emotes'])
self.write_object(settings)
@Level(3)
async def put(self, channel_id):
data = self.validate()
if 'emotes' in data:
data['emotes'] = json.dumps(data['emotes'])
fields = ','.join([f for f in data])
values = ','.join(['%s' for f in data])
dup = ','.join([f'{f}=VALUES({f})' for f in data])
await self.db.execute(
f'''
INSERT INTO
twitch_gambling_slots_settings
(channel_id, {fields})
VALUES
(%s, {values})
ON DUPLICATE KEY UPDATE {dup}
''', (
channel_id,
*data.values(),
))
self.set_status(204)
class Handler(Api_handler):
__schema__ = good.Schema({
str: [{
'message': good.All(str, good.Length(min=0, max=200)),
good.Optional('min_amount'): good.All(good.Coerce(int), good.Range(min=0, max=1000)),
}],
}, default_keys=good.Optional)
@Level(1)
async def get(self, channel_id):
alerts = await self.db.fetchall(
'SELECT type, message, min_amount FROM twitch_chat_alerts WHERE channel_id=%s',
(channel_id,)
)
grouped_alerts = {}
for a in alerts:
l = grouped_alerts.setdefault(a['type'], [])
l.append({
'message': a['message'],
'min_amount': a['min_amount'] or 0,
})
self.write_object(grouped_alerts)
@Level(1)
async def put(self, channel_id):
data = self.validate()
for key in data:
ins = []
for d in data[key]:
if d['message']:
ins.append((
channel_id,
key,
d['message'],
d.get('min_amount', 0),
))
await self.db.execute(
'DELETE FROM twitch_chat_alerts WHERE channel_id=%s AND type=%s;',
(channel_id, key,)
)
if ins:
await self.db.executemany('''
INSERT INTO twitch_chat_alerts
(channel_id, type, message, min_amount)
VALUES
(%s, %s, %s, %s)
''', ins
)
await self.get(channel_id)
class Channel_admins(Api_handler):
__schema__ = good.Schema({
'user':
good.All(str, good.Length(min=4, max=25)),
'level':
good.All(good.Coerce(int), good.Range(min=1, max=3)),
})
__update_schema__ = good.Schema({
'level':
good.All(good.Coerce(int), good.Range(min=1, max=3)),
})
@Level(3)
async def get(self, channel_id):
admins = await self.db.fetchall(
'''
SELECT user_id as id, user as name, level
FROM twitch_channel_admins
WHERE channel_id=%s
ORDER BY level DESC
''', (channel_id, ))
self.write_object(admins)
@Level(3)
async def post(self, channel_id):
data = self.validate()
url = 'https://api.twitch.tv/helix/users'
users = await twitch_request(self.ahttp, url, {
'login': data['user'],
})
if not users['data']:
raise Api_exception(400, 'User does not exist on Twitch')
user = users['data'][0]
await self.db.execute(
'''
INSERT INTO
twitch_channel_admins
(channel_id, user_id, user, level, created_at, updated_at)
VALUES
(%s, %s, %s, %s, now(), now())
ON DUPLICATE KEY UPDATE
user=VALUES(user),
level=VALUES(level),
updated_at=VALUES(updated_at)
''', (channel_id, user['id'], user['display_name'], data['level']))
self.set_status(204)
@Level(3)
async def put(self, channel_id, user_id):
data = self.validate(self.__update_schema__)
await self.db.execute(
'UPDATE twitch_channel_admins SET level=%s WHERE channel_id=%s AND user_id=%s',
(data['level'], channel_id, user_id))
@Level(3)
async def delete(self, channel_id, user_id):
await self.db.execute(
'DELETE FROM twitch_channel_admins WHERE channel_id=%s AND user_id=%s',
(channel_id, user_id))
self.set_status(204)
try:
utils.validate_cmd_response(v)
return v
except Exception as e:
raise good.Invalid(str(e))
return f
_schema = {
'cmd':
good.All(str, validate_cmd()),
'response':
good.All(str, validate_response()),
good.Optional('user_level'):
good.All(good.Coerce(int), good.Range(min=0, max=9)),
good.Optional('enabled_status'):
good.All(good.Coerce(int), good.Range(min=0, max=2)),
good.Optional('global_cooldown'):
good.All(good.Coerce(int), good.Range(min=0, max=86400)),
good.Optional('user_cooldown'):
good.All(good.Coerce(int), good.Range(min=0, max=86400)),
good.Optional('mod_cooldown'):
good.All(good.Coerce(int), good.Range(min=0, max=86400)),
good.Optional('enabled'):
good.All(good.Coerce(int), good.Range(min=0, max=1)),
good.Optional('public'):
good.All(good.Coerce(int), good.Range(min=0, max=1)),
good.Optional('group_name'):
good.Maybe(good.All(str, good.Length(min=0, max=50))),
}
import logging, good, asyncio
from ..base import Api_handler, Level, Api_exception
from tbot import config, utils
from datetime import datetime, timedelta
__schema__ = {
'name': good.All(str, good.Length(min=1, max=100)),
'messages': good.All([good.All(str, good.Length(min=1, max=500))], good.Length(min=1, max=100)),
good.Optional('enabled'): good.All(good.Coerce(int), good.Range(min=0, max=1)),
good.Optional('enabled_status'): good.All(good.Coerce(int), good.Range(min=0, max=2)),
good.Optional('interval'): good.All(good.Coerce(int), good.Range(min=1, max=10080)),
good.Optional('send_message_order'): good.All(good.Coerce(int), good.Range(min=1, max=2)),
}
class Handler(Api_handler):
__schema__ = good.Schema(__schema__, default_keys=good.Optional)
@Level(1)
async def put(self, channel_id, id_):
data = self.validate()
data['updated_at'] = datetime.utcnow()
if 'interval' in data:
data['next_run'] = datetime.utcnow()+timedelta(minutes=data['interval'])
if 'messages' in data:
data['messages'] = utils.json_dumps(data['messages'])
fields = ', '.join(['`{}`=%s'.format(k) for k in data])
values = list(data.values())
values.append(channel_id)
values.append(id_)
await self.db.execute(
def SHOW_EPISODE_TYPE(msg=None):
def f(v):
if v not in constants.SHOW_EPISODE_TYPE:
raise good.Invalid('invalid episodes type: {}'.format(v))
return v
return f
Description_schema = good.Schema({
'text': good.Maybe(str),
'title': good.Maybe(str),
'url': good.Maybe(str),
}, default_keys=good.Optional)
_Episode_schema = {
'title': good.Maybe(str),
good.Required('number'): good.All(good.Coerce(int), good.Range(min=1)),
good.Optional('season'): good.Maybe(good.All(good.Coerce(int), good.Range(min=1))),
good.Optional('episode'): good.Maybe(good.All(good.Coerce(int), good.Range(min=1))),
'air_date': good.Maybe(date_()),
'air_time': good.Maybe(time_()),
'air_datetime': good.Maybe(iso8601_to_utc()),
'description': good.Any(None, Description_schema),
'runtime': good.Maybe(good.Coerce(int)),
}
Episode_schema = good.Schema(_Episode_schema, default_keys=good.Optional)
External_schema = good.Schema({
good.All(good.Length(min=1, max=45)):good.Any(None, good.All(good.Coerce(str), good.Length(min=1, max=45)))
}, default_keys=good.Optional)
Importer_schema = good.Schema(
{key: good.Maybe(good.All(str, good.Length(min=1, max=45))) \
for key in constants.IMPORTER_TYPE_NAMES},
class Points_settings_handler(Api_handler):
__schema__ = good.Schema({
'enabled':
good.Boolean(),
'points_name':
good.All(str, good.Length(min=1, max=45)),
'points_per_min':
good.All(good.Coerce(int), good.Range(min=0)),
'points_per_min_sub_multiplier':
good.All(good.Coerce(int), good.Range(min=0)),
'points_per_sub':
good.All(good.Coerce(int), good.Range(min=0)),
'points_per_cheer':
good.All(good.Coerce(int), good.Range(min=0)),
'ignore_users': [str],
})
async def get(self, channel_id):
settings = await self.db.fetchone(
'select * from twitch_channel_point_settings where channel_id=%s',
(channel_id),
)
if not settings:
self.set_status(204)
else:
self.write_object({
'enabled':
True if settings['enabled'] == 1 else False,
'points_name':
settings['points_name'],
'points_per_min':
settings['points_per_min'],
'points_per_min_sub_multiplier':
settings['points_per_min_sub_multiplier'],
'points_per_sub':
settings['points_per_sub'],
'points_per_cheer':
settings['points_per_cheer'],
'ignore_users':
json.loads(settings['ignore_users']),
})
@Level(3)
async def put(self, channel_id):
data = self.validate()
if 'ignore_users' in data:
data['ignore_users'] = json.dumps(data['ignore_users'])
fields = ','.join([f for f in data])
values = ','.join(['%s' for f in data])
dup = ','.join([f'{f}=VALUES({f})' for f in data])
await self.db.execute(
f'''
INSERT INTO
twitch_channel_point_settings
(channel_id, {fields})
VALUES
(%s, {values})
ON DUPLICATE KEY UPDATE {dup}
''', (
channel_id,
*data.values(),
))
self.set_status(204)
def Coerce(type, msg=None):
return _wrapMsg(good.Coerce(type), msg)
class Handler(base.Handler):
__arguments_schema__ = good.Schema(
{
'days_back':
good.Any(
good.All(good.Coerce(int), good.Range(min=0, max=7)),
good.Default(2),
),
'days_ahead':
good.Any(good.All(good.Coerce(int), good.Range(min=0, max=14)),
good.Default(7)),
},
default_keys=good.Required)
async def get(self, user_id):
user_id = self.user_id_or_current(user_id)
shows_episodes = await self.get_shows_episodes(user_id)
if not shows_episodes:
self.write_object([])
return
ids = []
shows = {se[0]['id']: se[0] for se in shows_episodes}
airdates = OrderedDict()
airdate_shows = OrderedDict()
prev = None
for se in shows_episodes:
if prev == None:
prev = se[1]['air_datetime'].date()
if prev != se[1]['air_datetime'].date():
airdates[prev] = list(airdate_shows.values())
prev = se[1]['air_datetime'].date()
airdate_shows = {}
if se[1]['show_id'] not in airdate_shows:
airdate_shows[se[1]['show_id']] = copy.copy(
shows[se[1]['show_id']])
show = airdate_shows[se[1]['show_id']]
show.setdefault('episodes', [])
show['episodes'].append(self.episode_wrapper(se[1]))
if shows_episodes:
airdates[prev] = list(airdate_shows.values())
self.write_object([{'air_date': ad, 'shows': airdates[ad]}\
for ad in airdates])
@run_on_executor
def get_shows_episodes(self, user_id):
args = self.validate_arguments()
now = datetime.utcnow()
from_ = (now - timedelta(days=args['days_back'])).date()
to_ = (now + timedelta(days=args['days_ahead'])).date()
with new_session() as session:
rows = session.query(models.Episode, models.Show).filter(
models.Show_fan.user_id == user_id,
models.Show_fan.show_id == models.Show.id,
models.Episode.show_id == models.Show.id,
sa.func.date(models.Episode.air_datetime) >= from_,
sa.func.date(models.Episode.air_datetime) <= to_,
).order_by(
models.Episode.air_datetime,
models.Show.id,
).all()
return [(r.Show.serialize(), r.Episode.serialize()) for r in rows]
