301 lines
10 KiB
Python
301 lines
10 KiB
Python
from sqlalchemy import Table, Column, UniqueConstraint # type: ignore
|
|
from sqlalchemy.types import String, Integer, Text, JSON # type: ignore
|
|
from sqlalchemy.dialects.mysql import BIGINT as BigInteger # type: ignore
|
|
from typing import Optional, Dict, List, Tuple, Any
|
|
|
|
from bemani.common import Time
|
|
from bemani.data.mysql.base import BaseData, metadata
|
|
from bemani.data.types import News, Event, UserID, ArcadeID
|
|
|
|
"""
|
|
Table for storing network news, as edited by an admin. This is displayed
|
|
on the front page of the frontend of the network.
|
|
"""
|
|
news = Table( # type: ignore
|
|
'news',
|
|
metadata,
|
|
Column('id', Integer, nullable=False, primary_key=True),
|
|
Column('timestamp', Integer, nullable=False, index=True),
|
|
Column('title', String(255), nullable=False),
|
|
Column('body', Text, nullable=False),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing scheduled work history, so that individual game code
|
|
can determine if it should run scheduled work or not.
|
|
"""
|
|
scheduled_work = Table( # type: ignore
|
|
'scheduled_work',
|
|
metadata,
|
|
Column('game', String(32), nullable=False),
|
|
Column('version', Integer, nullable=False),
|
|
Column('name', String(32), nullable=False),
|
|
Column('schedule', String(32), nullable=False),
|
|
Column('year', Integer),
|
|
Column('day', Integer),
|
|
UniqueConstraint('game', 'version', 'name', 'schedule', name='game_version_name_schedule'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing audit entries, such as crashes, PCBID denials, daily
|
|
song selection, etc. Anything that could be inspected later to verify
|
|
correct operation of the network.
|
|
"""
|
|
audit = Table( # type: ignore
|
|
'audit',
|
|
metadata,
|
|
Column('id', Integer, nullable=False, primary_key=True),
|
|
Column('timestamp', Integer, nullable=False, index=True),
|
|
Column('userid', BigInteger(unsigned=True), index=True),
|
|
Column('arcadeid', Integer, index=True),
|
|
Column('type', String(64), nullable=False, index=True),
|
|
Column('data', JSON, nullable=False),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
|
|
class NetworkData(BaseData):
|
|
|
|
def get_all_news(self) -> List[News]:
|
|
"""
|
|
Grab all news in the system.
|
|
|
|
Returns:
|
|
A list of News objects sorted by timestamp.
|
|
"""
|
|
sql = "SELECT id, timestamp, title, body FROM news ORDER BY timestamp DESC"
|
|
cursor = self.execute(sql)
|
|
return [
|
|
News(
|
|
result['id'],
|
|
result['timestamp'],
|
|
result['title'],
|
|
result['body'],
|
|
) for result in cursor.fetchall()
|
|
]
|
|
|
|
def create_news(self, title: str, body: str) -> int:
|
|
"""
|
|
Given a title and body, create a new news entry.
|
|
|
|
Parameters:
|
|
title - String title of the entry.
|
|
body - String body of the entry, may contain HTML.
|
|
|
|
Returns:
|
|
The ID of the newly created entry.
|
|
"""
|
|
sql = "INSERT INTO news (timestamp, title, body) VALUES (:timestamp, :title, :body)"
|
|
cursor = self.execute(sql, {'timestamp': int(Time.now()), 'title': title, 'body': body})
|
|
return cursor.lastrowid
|
|
|
|
def get_news(self, newsid: int) -> Optional[News]:
|
|
"""
|
|
Given a news ID, grab that news entry from the DB.
|
|
|
|
Parameters:
|
|
newsid - Integer specifying news ID.
|
|
|
|
Returns:
|
|
A News object if the news entry was found or None otherwise.
|
|
"""
|
|
sql = "SELECT timestamp, title, body FROM news WHERE id = :id"
|
|
cursor = self.execute(sql, {'id': newsid})
|
|
if cursor.rowcount != 1:
|
|
# Couldn't find an entry with this ID
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return News(
|
|
newsid,
|
|
result['timestamp'],
|
|
result['title'],
|
|
result['body'],
|
|
)
|
|
|
|
def put_news(self, news: News) -> None:
|
|
"""
|
|
Given a news object, store it back into the DB.
|
|
|
|
Parameters:
|
|
news - A News object to be updated.
|
|
"""
|
|
sql = "UPDATE news SET title = :title, body = :body WHERE id = :id"
|
|
self.execute(sql, {'id': news.id, 'title': news.title, 'body': news.body})
|
|
|
|
def destroy_news(self, newsid: int) -> None:
|
|
"""
|
|
Given a news ID, remove that news entry from the DB.
|
|
|
|
Parameters:
|
|
newsid - Integer specifying news ID.
|
|
"""
|
|
sql = "DELETE FROM news WHERE id = :id LIMIT 1"
|
|
self.execute(sql, {'id': newsid})
|
|
|
|
def get_schedule_duration(self, schedule: str) -> Tuple[int, int]:
|
|
"""
|
|
Given a schedule type, returns the timestamp for the start and end
|
|
of the current schedule of this type.
|
|
"""
|
|
if schedule not in ['daily', 'weekly']:
|
|
raise Exception('Logic error, specify either \'daily\' or \'weekly\' for schedule type!')
|
|
|
|
if schedule == 'daily':
|
|
return (Time.beginning_of_today(), Time.end_of_today())
|
|
|
|
if schedule == 'weekly':
|
|
return (Time.beginning_of_this_week(), Time.end_of_this_week())
|
|
|
|
# Should never happen
|
|
return (0, 0)
|
|
|
|
def should_schedule(self, game: str, version: int, name: str, schedule: str) -> bool:
|
|
"""
|
|
Given a game/version/name pair and a schedule value, return whether
|
|
this scheduled work is overdue or not.
|
|
"""
|
|
if schedule not in ['daily', 'weekly']:
|
|
raise Exception('Logic error, specify either \'daily\' or \'weekly\' for schedule type!')
|
|
|
|
sql = (
|
|
"SELECT year, day FROM scheduled_work "
|
|
"WHERE game = :game AND version = :version AND "
|
|
"name = :name AND schedule = :schedule"
|
|
)
|
|
cursor = self.execute(sql, {'game': game, 'version': version, 'name': name, 'schedule': schedule})
|
|
if cursor.rowcount != 1:
|
|
# No scheduled work was registered, so time to get going!
|
|
return True
|
|
|
|
result = cursor.fetchone()
|
|
|
|
if schedule == 'daily':
|
|
# Just look at the day and year, make sure it matches
|
|
year, day = Time.days_into_year()
|
|
if year != result['year']:
|
|
# Wrong year, so we certainly need to run!
|
|
return True
|
|
if day != result['day']:
|
|
# Wrong day and we're daily, so need to run!
|
|
return True
|
|
|
|
if schedule == 'weekly':
|
|
# Find the beginning of the week (Monday), as days since epoch.
|
|
if Time.week_in_days_since_epoch() != result['day']:
|
|
# Wrong week, so we should run!
|
|
return True
|
|
|
|
# We have already run this work for this schedule
|
|
return False
|
|
|
|
def mark_scheduled(self, game: str, version: int, name: str, schedule: str) -> None:
|
|
if schedule not in ['daily', 'weekly']:
|
|
raise Exception('Logic error, specify either \'daily\' or \'weekly\' for schedule type!')
|
|
|
|
if schedule == 'daily':
|
|
year, day = Time.days_into_year()
|
|
sql = (
|
|
"INSERT INTO scheduled_work (game, version, name, schedule, year, day) " +
|
|
"VALUES (:game, :version, :name, :schedule, :year, :day) " +
|
|
"ON DUPLICATE KEY UPDATE year=VALUES(year), day=VALUES(day)"
|
|
)
|
|
self.execute(
|
|
sql,
|
|
{
|
|
'game': game,
|
|
'version': version,
|
|
'name': name,
|
|
'schedule': schedule,
|
|
'year': year,
|
|
'day': day,
|
|
},
|
|
)
|
|
|
|
if schedule == 'weekly':
|
|
days = Time.week_in_days_since_epoch()
|
|
sql = (
|
|
"INSERT INTO scheduled_work (game, version, name, schedule, day) " +
|
|
"VALUES (:game, :version, :name, :schedule, :day) " +
|
|
"ON DUPLICATE KEY UPDATE day=VALUES(day)"
|
|
)
|
|
self.execute(
|
|
sql,
|
|
{
|
|
'game': game,
|
|
'version': version,
|
|
'name': name,
|
|
'schedule': schedule,
|
|
'day': days,
|
|
},
|
|
)
|
|
|
|
def put_event(
|
|
self,
|
|
event: str,
|
|
data: Dict[str, Any],
|
|
timestamp: Optional[int]=None,
|
|
userid: Optional[UserID]=None,
|
|
arcadeid: Optional[ArcadeID]=None,
|
|
) -> None:
|
|
if timestamp is None:
|
|
timestamp = Time.now()
|
|
sql = "INSERT INTO audit (timestamp, userid, arcadeid, type, data) VALUES (:ts, :uid, :aid, :type, :data)"
|
|
self.execute(sql, {'ts': timestamp, 'type': event, 'data': self.serialize(data), 'uid': userid, 'aid': arcadeid})
|
|
|
|
def get_events(
|
|
self,
|
|
userid: Optional[UserID]=None,
|
|
arcadeid: Optional[ArcadeID]=None,
|
|
event: Optional[str]=None,
|
|
limit: Optional[int]=None,
|
|
since_id: Optional[int]=None,
|
|
until_id: Optional[int]=None,
|
|
) -> List[Event]:
|
|
# Base query
|
|
sql = "SELECT id, timestamp, userid, arcadeid, type, data FROM audit "
|
|
|
|
# Lets get specific!
|
|
wheres = []
|
|
if userid is not None:
|
|
wheres.append("userid = :userid")
|
|
if arcadeid is not None:
|
|
wheres.append("arcadeid = :arcadeid")
|
|
if event is not None:
|
|
wheres.append("type = :event")
|
|
if since_id is not None:
|
|
wheres.append("id >= :since_id")
|
|
if until_id is not None:
|
|
wheres.append("id < :until_id")
|
|
if len(wheres) > 0:
|
|
sql = sql + "WHERE {} ".format(' AND '.join(wheres))
|
|
|
|
# Order it newest to oldest
|
|
sql = sql + "ORDER BY id DESC"
|
|
if limit is not None:
|
|
sql = sql + " LIMIT :limit"
|
|
cursor = self.execute(sql, {'userid': userid, 'arcadeid': arcadeid, 'event': event, 'limit': limit, 'since_id': since_id, 'until_id': until_id})
|
|
events = []
|
|
for result in cursor.fetchall():
|
|
if result['userid'] is not None:
|
|
userid = UserID(result['userid'])
|
|
else:
|
|
userid = None
|
|
if result['arcadeid'] is not None:
|
|
arcadeid = ArcadeID(result['arcadeid'])
|
|
else:
|
|
arcadeid = None
|
|
events.append(
|
|
Event(
|
|
result['id'],
|
|
result['timestamp'],
|
|
userid,
|
|
arcadeid,
|
|
result['type'],
|
|
self.deserialize(result['data']),
|
|
),
|
|
)
|
|
return events
|