forked from Dniel97/artemis
move to async database
This commit is contained in:
parent
edd3ce8ead
commit
05586df08a
@ -177,9 +177,9 @@ class AimedbServlette():
|
||||
|
||||
async def handle_lookup(self, data: bytes, resp_code: int) -> ADBBaseResponse:
|
||||
req = ADBLookupRequest(data)
|
||||
user_id = self.data.card.get_user_id_from_card(req.access_code)
|
||||
is_banned = self.data.card.get_card_banned(req.access_code)
|
||||
is_locked = self.data.card.get_card_locked(req.access_code)
|
||||
user_id = await self.data.card.get_user_id_from_card(req.access_code)
|
||||
is_banned = await self.data.card.get_card_banned(req.access_code)
|
||||
is_locked = await self.data.card.get_card_locked(req.access_code)
|
||||
|
||||
ret = ADBLookupResponse.from_req(req.head, user_id)
|
||||
if is_banned and is_locked:
|
||||
@ -196,10 +196,10 @@ class AimedbServlette():
|
||||
|
||||
async def handle_lookup_ex(self, data: bytes, resp_code: int) -> ADBBaseResponse:
|
||||
req = ADBLookupRequest(data)
|
||||
user_id = self.data.card.get_user_id_from_card(req.access_code)
|
||||
user_id = await self.data.card.get_user_id_from_card(req.access_code)
|
||||
|
||||
is_banned = self.data.card.get_card_banned(req.access_code)
|
||||
is_locked = self.data.card.get_card_locked(req.access_code)
|
||||
is_banned = await self.data.card.get_card_banned(req.access_code)
|
||||
is_locked = await self.data.card.get_card_locked(req.access_code)
|
||||
|
||||
ret = ADBLookupExResponse.from_req(req.head, user_id)
|
||||
if is_banned and is_locked:
|
||||
@ -233,7 +233,7 @@ class AimedbServlette():
|
||||
be fine.
|
||||
"""
|
||||
req = ADBFelicaLookupRequest(data)
|
||||
ac = self.data.card.to_access_code(req.idm)
|
||||
ac = await self.data.card.to_access_code(req.idm)
|
||||
self.logger.info(
|
||||
f"idm {req.idm} ipm {req.pmm} -> access_code {ac}"
|
||||
)
|
||||
@ -244,17 +244,17 @@ class AimedbServlette():
|
||||
I've never seen this used.
|
||||
"""
|
||||
req = ADBFelicaLookupRequest(data)
|
||||
ac = self.data.card.to_access_code(req.idm)
|
||||
ac = await self.data.card.to_access_code(req.idm)
|
||||
|
||||
if self.config.server.allow_user_registration:
|
||||
user_id = self.data.user.create_user()
|
||||
user_id = await self.data.user.create_user()
|
||||
|
||||
if user_id is None:
|
||||
self.logger.error("Failed to register user!")
|
||||
user_id = -1
|
||||
|
||||
else:
|
||||
card_id = self.data.card.create_card(user_id, ac)
|
||||
card_id = await self.data.card.create_card(user_id, ac)
|
||||
|
||||
if card_id is None:
|
||||
self.logger.error("Failed to register card!")
|
||||
@ -273,8 +273,8 @@ class AimedbServlette():
|
||||
|
||||
async def handle_felica_lookup_ex(self, data: bytes, resp_code: int) -> bytes:
|
||||
req = ADBFelicaLookup2Request(data)
|
||||
access_code = self.data.card.to_access_code(req.idm)
|
||||
user_id = self.data.card.get_user_id_from_card(access_code=access_code)
|
||||
access_code = await self.data.card.to_access_code(req.idm)
|
||||
user_id = await self.data.card.get_user_id_from_card(access_code=access_code)
|
||||
|
||||
if user_id is None:
|
||||
user_id = -1
|
||||
@ -308,14 +308,14 @@ class AimedbServlette():
|
||||
user_id = -1
|
||||
|
||||
if self.config.server.allow_user_registration:
|
||||
user_id = self.data.user.create_user()
|
||||
user_id = await self.data.user.create_user()
|
||||
|
||||
if user_id is None:
|
||||
self.logger.error("Failed to register user!")
|
||||
user_id = -1
|
||||
|
||||
else:
|
||||
card_id = self.data.card.create_card(user_id, req.access_code)
|
||||
card_id = await self.data.card.create_card(user_id, req.access_code)
|
||||
|
||||
if card_id is None:
|
||||
self.logger.error("Failed to register card!")
|
||||
|
@ -170,10 +170,10 @@ class AllnetServlet:
|
||||
|
||||
self.logger.debug(f"Allnet request: {vars(req)}")
|
||||
|
||||
machine = self.data.arcade.get_machine(req.serial)
|
||||
machine = await self.data.arcade.get_machine(req.serial)
|
||||
if machine is None and not self.config.server.allow_unregistered_serials:
|
||||
msg = f"Unrecognised serial {req.serial} attempted allnet auth from {request_ip}."
|
||||
self.data.base.log_event(
|
||||
await self.data.base.log_event(
|
||||
"allnet", "ALLNET_AUTH_UNKNOWN_SERIAL", logging.WARN, msg
|
||||
)
|
||||
self.logger.warning(msg)
|
||||
@ -183,11 +183,11 @@ class AllnetServlet:
|
||||
return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
|
||||
|
||||
if machine is not None:
|
||||
arcade = self.data.arcade.get_arcade(machine["arcade"])
|
||||
arcade = await self.data.arcade.get_arcade(machine["arcade"])
|
||||
if self.config.server.check_arcade_ip:
|
||||
if arcade["ip"] and arcade["ip"] is not None and arcade["ip"] != req.ip:
|
||||
msg = f"Serial {req.serial} attempted allnet auth from bad IP {req.ip} (expected {arcade['ip']})."
|
||||
self.data.base.log_event(
|
||||
await self.data.base.log_event(
|
||||
"allnet", "ALLNET_AUTH_BAD_IP", logging.ERROR, msg
|
||||
)
|
||||
self.logger.warning(msg)
|
||||
@ -198,7 +198,7 @@ class AllnetServlet:
|
||||
|
||||
elif (not arcade["ip"] or arcade["ip"] is None) and self.config.server.strict_ip_checking:
|
||||
msg = f"Serial {req.serial} attempted allnet auth from bad IP {req.ip}, but arcade {arcade['id']} has no IP set! (strict checking enabled)."
|
||||
self.data.base.log_event(
|
||||
await self.data.base.log_event(
|
||||
"allnet", "ALLNET_AUTH_NO_SHOP_IP", logging.ERROR, msg
|
||||
)
|
||||
self.logger.warning(msg)
|
||||
@ -242,7 +242,7 @@ class AllnetServlet:
|
||||
if req.game_id not in TitleServlet.title_registry:
|
||||
if not self.config.server.is_develop:
|
||||
msg = f"Unrecognised game {req.game_id} attempted allnet auth from {request_ip}."
|
||||
self.data.base.log_event(
|
||||
await self.data.base.log_event(
|
||||
"allnet", "ALLNET_AUTH_UNKNOWN_GAME", logging.WARN, msg
|
||||
)
|
||||
self.logger.warning(msg)
|
||||
@ -269,7 +269,7 @@ class AllnetServlet:
|
||||
resp.uri, resp.host = TitleServlet.title_registry[req.game_id].get_allnet_info(req.game_id, int(int_ver), req.serial)
|
||||
|
||||
msg = f"{req.serial} authenticated from {request_ip}: {req.game_id} v{req.ver}"
|
||||
self.data.base.log_event("allnet", "ALLNET_AUTH_SUCCESS", logging.INFO, msg)
|
||||
await self.data.base.log_event("allnet", "ALLNET_AUTH_SUCCESS", logging.INFO, msg)
|
||||
self.logger.info(msg)
|
||||
|
||||
resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
|
||||
@ -335,7 +335,7 @@ class AllnetServlet:
|
||||
resp.uri += f"|http://{self.config.server.hostname}:{self.config.server.port}/dl/ini/{req.game_id}-{req.ver.replace('.', '')}-opt.ini"
|
||||
|
||||
self.logger.debug(f"Sending download uri {resp.uri}")
|
||||
self.data.base.log_event("allnet", "DLORDER_REQ_SUCCESS", logging.INFO, f"{Utils.get_ip_addr(request)} requested DL Order for {req.serial} {req.game_id} v{req.ver}")
|
||||
await self.data.base.log_event("allnet", "DLORDER_REQ_SUCCESS", logging.INFO, f"{Utils.get_ip_addr(request)} requested DL Order for {req.serial} {req.game_id} v{req.ver}")
|
||||
|
||||
res_str = urllib.parse.unquote(urllib.parse.urlencode(vars(resp))) + "\n"
|
||||
"""if is_dfi:
|
||||
@ -352,7 +352,7 @@ class AllnetServlet:
|
||||
|
||||
if path.exists(f"{self.config.allnet.update_cfg_folder}/{req_file}"):
|
||||
self.logger.info(f"Request for DL INI file {req_file} from {Utils.get_ip_addr(request)} successful")
|
||||
self.data.base.log_event("allnet", "DLORDER_INI_SENT", logging.INFO, f"{Utils.get_ip_addr(request)} successfully recieved {req_file}")
|
||||
await self.data.base.log_event("allnet", "DLORDER_INI_SENT", logging.INFO, f"{Utils.get_ip_addr(request)} successfully recieved {req_file}")
|
||||
|
||||
return PlainTextResponse(open(
|
||||
f"{self.config.allnet.update_cfg_folder}/{req_file}", "r"
|
||||
@ -390,7 +390,7 @@ class AllnetServlet:
|
||||
msg = f"{rep.serial} @ {client_ip} reported {rep.rep_type.name} download state {rep.rf_state.name} for {rep.gd} v{rep.dav}:"\
|
||||
f" {rep.tdsc}/{rep.tsc} segments downloaded for working files {rep.wfl} with {rep.dfl if rep.dfl else 'none'} complete."
|
||||
|
||||
self.data.base.log_event("allnet", "DL_REPORT", logging.INFO, msg, dl_data)
|
||||
await self.data.base.log_event("allnet", "DL_REPORT", logging.INFO, msg, dl_data)
|
||||
self.logger.info(msg)
|
||||
|
||||
return PlainTextResponse("OK")
|
||||
@ -540,10 +540,10 @@ class BillingServlet:
|
||||
kc_serial_bytes = req.keychipid.encode()
|
||||
|
||||
|
||||
machine = self.data.arcade.get_machine(req.keychipid)
|
||||
machine = await self.data.arcade.get_machine(req.keychipid)
|
||||
if machine is None and not self.config.server.allow_unregistered_serials:
|
||||
msg = f"Unrecognised serial {req.keychipid} attempted billing checkin from {request_ip} for {req.gameid} v{req.gamever}."
|
||||
self.data.base.log_event(
|
||||
await self.data.base.log_event(
|
||||
"allnet", "BILLING_CHECKIN_NG_SERIAL", logging.WARN, msg
|
||||
)
|
||||
self.logger.warning(msg)
|
||||
@ -555,7 +555,7 @@ class BillingServlet:
|
||||
f"{req.playcnt} billing_type {req.billingtype.name} nearfull {req.nearfull} playlimit {req.playlimit}"
|
||||
)
|
||||
self.logger.info(msg)
|
||||
self.data.base.log_event("billing", "BILLING_CHECKIN_OK", logging.INFO, msg)
|
||||
await self.data.base.log_event("billing", "BILLING_CHECKIN_OK", logging.INFO, msg)
|
||||
if req.traceleft > 0:
|
||||
self.logger.warn(f"{req.traceleft} unsent tracelogs")
|
||||
kc_playlimit = req.playlimit
|
||||
@ -699,7 +699,7 @@ class BillingInfo:
|
||||
self.boardid = str(data.get("boardid", None))
|
||||
self.tenpoip = str(data.get("tenpoip", None))
|
||||
self.libalibver = float(data.get("libalibver", None))
|
||||
self.datamax = int(data.get("datamax", None))
|
||||
self.data.max = int(data.get("datamax", None))
|
||||
self.billingtype = BillingType(int(data.get("billingtype", None)))
|
||||
self.protocolver = float(data.get("protocolver", None))
|
||||
self.operatingfix = bool(data.get("operatingfix", None))
|
||||
|
@ -69,7 +69,7 @@ arcade_owner = Table(
|
||||
|
||||
|
||||
class ArcadeData(BaseData):
|
||||
def get_machine(self, serial: str = None, id: int = None) -> Optional[Row]:
|
||||
async def get_machine(self, serial: str = None, id: int = None) -> Optional[Row]:
|
||||
if serial is not None:
|
||||
serial = serial.replace("-", "")
|
||||
if len(serial) == 11:
|
||||
@ -89,12 +89,12 @@ class ArcadeData(BaseData):
|
||||
self.logger.error(f"{__name__ }: Need either serial or ID to look up!")
|
||||
return None
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_machine(
|
||||
async def put_machine(
|
||||
self,
|
||||
arcade_id: int,
|
||||
serial: str = "",
|
||||
@ -110,13 +110,13 @@ class ArcadeData(BaseData):
|
||||
arcade=arcade_id, keychip=serial, board=board, game=game, is_cab=is_cab
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def set_machine_serial(self, machine_id: int, serial: str) -> None:
|
||||
result = self.execute(
|
||||
async def set_machine_serial(self, machine_id: int, serial: str) -> None:
|
||||
result = await self.execute(
|
||||
machine.update(machine.c.id == machine_id).values(keychip=serial)
|
||||
)
|
||||
if result is None:
|
||||
@ -125,8 +125,8 @@ class ArcadeData(BaseData):
|
||||
)
|
||||
return result.lastrowid
|
||||
|
||||
def set_machine_boardid(self, machine_id: int, boardid: str) -> None:
|
||||
result = self.execute(
|
||||
async def set_machine_boardid(self, machine_id: int, boardid: str) -> None:
|
||||
result = await self.execute(
|
||||
machine.update(machine.c.id == machine_id).values(board=boardid)
|
||||
)
|
||||
if result is None:
|
||||
@ -134,21 +134,21 @@ class ArcadeData(BaseData):
|
||||
f"Failed to update board id for machine {machine_id} -> {boardid}"
|
||||
)
|
||||
|
||||
def get_arcade(self, id: int) -> Optional[Row]:
|
||||
async def get_arcade(self, id: int) -> Optional[Row]:
|
||||
sql = arcade.select(arcade.c.id == id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_arcade_machines(self, id: int) -> Optional[List[Row]]:
|
||||
async def get_arcade_machines(self, id: int) -> Optional[List[Row]]:
|
||||
sql = machine.select(machine.c.arcade == id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_arcade(
|
||||
async def put_arcade(
|
||||
self,
|
||||
name: str,
|
||||
nickname: str = None,
|
||||
@ -171,42 +171,42 @@ class ArcadeData(BaseData):
|
||||
regional_id=regional_id,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_arcades_managed_by_user(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_arcades_managed_by_user(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(arcade).join(arcade_owner, arcade_owner.c.arcade == arcade.c.id).where(arcade_owner.c.user == user_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return False
|
||||
return result.fetchall()
|
||||
|
||||
def get_manager_permissions(self, user_id: int, arcade_id: int) -> Optional[int]:
|
||||
async def get_manager_permissions(self, user_id: int, arcade_id: int) -> Optional[int]:
|
||||
sql = select(arcade_owner.c.permissions).where(and_(arcade_owner.c.user == user_id, arcade_owner.c.arcade == arcade_id))
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return False
|
||||
return result.fetchone()
|
||||
|
||||
def get_arcade_owners(self, arcade_id: int) -> Optional[Row]:
|
||||
async def get_arcade_owners(self, arcade_id: int) -> Optional[Row]:
|
||||
sql = select(arcade_owner).where(arcade_owner.c.arcade == arcade_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def add_arcade_owner(self, arcade_id: int, user_id: int) -> None:
|
||||
async def add_arcade_owner(self, arcade_id: int, user_id: int) -> None:
|
||||
sql = insert(arcade_owner).values(arcade=arcade_id, user=user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def format_serial(
|
||||
async def format_serial(
|
||||
self, platform_code: str, platform_rev: int, serial_num: int, append: int = 4152
|
||||
) -> str:
|
||||
return f"{platform_code}{platform_rev:02d}A{serial_num:04d}{append:04d}" # 0x41 = A, 0x52 = R
|
||||
@ -217,16 +217,16 @@ class ArcadeData(BaseData):
|
||||
|
||||
return True
|
||||
|
||||
def get_arcade_by_name(self, name: str) -> Optional[List[Row]]:
|
||||
async def get_arcade_by_name(self, name: str) -> Optional[List[Row]]:
|
||||
sql = arcade.select(or_(arcade.c.name.like(f"%{name}%"), arcade.c.nickname.like(f"%{name}%")))
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_arcades_by_ip(self, ip: str) -> Optional[List[Row]]:
|
||||
async def get_arcades_by_ip(self, ip: str) -> Optional[List[Row]]:
|
||||
sql = arcade.select().where(arcade.c.ip == ip)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -92,7 +92,7 @@ class BaseData:
|
||||
message=message,
|
||||
details=json.dumps(details),
|
||||
)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
@ -104,7 +104,7 @@ class BaseData:
|
||||
|
||||
async def get_event_log(self, entries: int = 100) -> Optional[List[Dict]]:
|
||||
sql = event_log.select().limit(entries).all()
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
|
@ -27,34 +27,34 @@ aime_card = Table(
|
||||
|
||||
|
||||
class CardData(BaseData):
|
||||
def get_card_by_access_code(self, access_code: str) -> Optional[Row]:
|
||||
async def get_card_by_access_code(self, access_code: str) -> Optional[Row]:
|
||||
sql = aime_card.select(aime_card.c.access_code == access_code)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_card_by_id(self, card_id: int) -> Optional[Row]:
|
||||
async def get_card_by_id(self, card_id: int) -> Optional[Row]:
|
||||
sql = aime_card.select(aime_card.c.id == card_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def update_access_code(self, old_ac: str, new_ac: str) -> None:
|
||||
async def update_access_code(self, old_ac: str, new_ac: str) -> None:
|
||||
sql = aime_card.update(aime_card.c.access_code == old_ac).values(
|
||||
access_code=new_ac
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to change card access code from {old_ac} to {new_ac}"
|
||||
)
|
||||
|
||||
def get_user_id_from_card(self, access_code: str) -> Optional[int]:
|
||||
async def get_user_id_from_card(self, access_code: str) -> Optional[int]:
|
||||
"""
|
||||
Given a 20 digit access code as a string, get the user id associated with that card
|
||||
"""
|
||||
@ -64,7 +64,7 @@ class CardData(BaseData):
|
||||
|
||||
return int(card["user"])
|
||||
|
||||
def get_card_banned(self, access_code: str) -> Optional[bool]:
|
||||
async def get_card_banned(self, access_code: str) -> Optional[bool]:
|
||||
"""
|
||||
Given a 20 digit access code as a string, check if the card is banned
|
||||
"""
|
||||
@ -74,7 +74,7 @@ class CardData(BaseData):
|
||||
if card["is_banned"]:
|
||||
return True
|
||||
return False
|
||||
def get_card_locked(self, access_code: str) -> Optional[bool]:
|
||||
async def get_card_locked(self, access_code: str) -> Optional[bool]:
|
||||
"""
|
||||
Given a 20 digit access code as a string, check if the card is locked
|
||||
"""
|
||||
@ -85,29 +85,29 @@ class CardData(BaseData):
|
||||
return True
|
||||
return False
|
||||
|
||||
def delete_card(self, card_id: int) -> None:
|
||||
async def delete_card(self, card_id: int) -> None:
|
||||
sql = aime_card.delete(aime_card.c.id == card_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to delete card with id {card_id}")
|
||||
|
||||
def get_user_cards(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_user_cards(self, aime_id: int) -> Optional[List[Row]]:
|
||||
"""
|
||||
Returns all cards owned by a user
|
||||
"""
|
||||
sql = aime_card.select(aime_card.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def create_card(self, user_id: int, access_code: str) -> Optional[int]:
|
||||
async def create_card(self, user_id: int, access_code: str) -> Optional[int]:
|
||||
"""
|
||||
Given a aime_user id and a 20 digit access code as a string, create a card and return the ID if successful
|
||||
"""
|
||||
sql = aime_card.insert().values(user=user_id, access_code=access_code)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
@ -1,4 +1,3 @@
|
||||
from enum import Enum
|
||||
from typing import Optional, List
|
||||
from sqlalchemy import Table, Column
|
||||
from sqlalchemy.types import Integer, String, TIMESTAMP
|
||||
@ -24,15 +23,8 @@ aime_user = Table(
|
||||
mysql_charset="utf8mb4",
|
||||
)
|
||||
|
||||
|
||||
class PermissionBits(Enum):
|
||||
PermUser = 1
|
||||
PermMod = 2
|
||||
PermSysAdmin = 4
|
||||
|
||||
|
||||
class UserData(BaseData):
|
||||
def create_user(
|
||||
async def create_user(
|
||||
self,
|
||||
id: int = None,
|
||||
username: str = None,
|
||||
@ -60,14 +52,14 @@ class UserData(BaseData):
|
||||
username=username, email=email, password=password, permissions=permission
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_user(self, user_id: int) -> Optional[Row]:
|
||||
async def get_user(self, user_id: int) -> Optional[Row]:
|
||||
sql = select(aime_user).where(aime_user.c.id == user_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return False
|
||||
return result.fetchone()
|
||||
@ -85,39 +77,34 @@ class UserData(BaseData):
|
||||
|
||||
return bcrypt.checkpw(passwd, usr["password"].encode())
|
||||
|
||||
def reset_autoincrement(self, ai_value: int) -> None:
|
||||
# ALTER TABLE isn't in sqlalchemy so we do this the ugly way
|
||||
sql = f"ALTER TABLE aime_user AUTO_INCREMENT={ai_value}"
|
||||
self.execute(sql)
|
||||
|
||||
def delete_user(self, user_id: int) -> None:
|
||||
async def delete_user(self, user_id: int) -> None:
|
||||
sql = aime_user.delete(aime_user.c.id == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to delete user with id {user_id}")
|
||||
|
||||
def get_unregistered_users(self) -> List[Row]:
|
||||
async def get_unregistered_users(self) -> List[Row]:
|
||||
"""
|
||||
Returns a list of users who have not registered with the webui. They may or may not have cards.
|
||||
"""
|
||||
sql = select(aime_user).where(aime_user.c.password == None)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def find_user_by_email(self, email: str) -> Row:
|
||||
async def find_user_by_email(self, email: str) -> Row:
|
||||
sql = select(aime_user).where(aime_user.c.email == email)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return False
|
||||
return result.fetchone()
|
||||
|
||||
def find_user_by_username(self, username: str) -> List[Row]:
|
||||
async def find_user_by_username(self, username: str) -> List[Row]:
|
||||
sql = aime_user.select(aime_user.c.username.like(f"%{username}%"))
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return False
|
||||
return result.fetchall()
|
||||
|
@ -110,7 +110,7 @@ class FrontendServlet(resource.Resource):
|
||||
async def robots(cls, request: Request) -> PlainTextResponse:
|
||||
return PlainTextResponse("User-agent: *\nDisallow: /\n\nUser-agent: AdsBot-Google\nDisallow: /")
|
||||
|
||||
def render_GET(self, request):
|
||||
async def render_GET(self, request):
|
||||
self.logger.debug(f"{Utils.get_ip_addr(request)} -> {request.uri.decode()}")
|
||||
template = self.environment.get_template("core/frontend/index.jinja")
|
||||
return template.render(
|
||||
@ -167,7 +167,7 @@ class FE_Gate(FE_Base):
|
||||
sesh=vars(usr_sesh),
|
||||
).encode("utf-16")
|
||||
|
||||
def render_POST(self, request: Request):
|
||||
async def render_POST(self, request: Request):
|
||||
uri = request.uri.decode()
|
||||
ip = Utils.get_ip_addr(request)
|
||||
|
||||
@ -177,13 +177,13 @@ class FE_Gate(FE_Base):
|
||||
if passwd == b"":
|
||||
passwd = None
|
||||
|
||||
uid = self.data.card.get_user_id_from_card(access_code)
|
||||
user = self.data.user.get_user(uid)
|
||||
uid = await self.data.card.get_user_id_from_card(access_code)
|
||||
user = await self.data.user.get_user(uid)
|
||||
if uid is None:
|
||||
return redirectTo(b"/gate?e=1", request)
|
||||
|
||||
if passwd is None:
|
||||
sesh = self.data.user.check_password(uid)
|
||||
sesh = await self.data.user.check_password(uid)
|
||||
|
||||
if sesh is not None:
|
||||
return redirectTo(
|
||||
@ -210,14 +210,14 @@ class FE_Gate(FE_Base):
|
||||
email: str = request.args[b"email"][0].decode()
|
||||
passwd: bytes = request.args[b"passwd"][0]
|
||||
|
||||
uid = self.data.card.get_user_id_from_card(access_code)
|
||||
uid = await self.data.card.get_user_id_from_card(access_code)
|
||||
if uid is None:
|
||||
return redirectTo(b"/gate?e=1", request)
|
||||
|
||||
salt = bcrypt.gensalt()
|
||||
hashed = bcrypt.hashpw(passwd, salt)
|
||||
|
||||
result = self.data.user.create_user(
|
||||
result = await self.data.user.create_user(
|
||||
uid, username, email.lower(), hashed.decode(), 1
|
||||
)
|
||||
if result is None:
|
||||
@ -231,16 +231,16 @@ class FE_Gate(FE_Base):
|
||||
else:
|
||||
return b""
|
||||
|
||||
def create_user(self, request: Request):
|
||||
async def create_user(self, request: Request):
|
||||
if b"ac" not in request.args or len(request.args[b"ac"][0].decode()) != 20:
|
||||
return redirectTo(b"/gate?e=2", request)
|
||||
|
||||
ac = request.args[b"ac"][0].decode()
|
||||
card = self.data.card.get_card_by_access_code(ac)
|
||||
card = await self.data.card.get_card_by_access_code(ac)
|
||||
if card is None:
|
||||
return redirectTo(b"/gate?e=1", request)
|
||||
|
||||
user = self.data.user.get_user(card['user'])
|
||||
user = await self.data.user.get_user(card['user'])
|
||||
if user is None:
|
||||
self.logger.warning(f"Card {ac} exists with no/invalid associated user ID {card['user']}")
|
||||
return redirectTo(b"/gate?e=0", request)
|
||||
@ -257,7 +257,7 @@ class FE_Gate(FE_Base):
|
||||
|
||||
|
||||
class FE_User(FE_Base):
|
||||
def render_GET(self, request: Request):
|
||||
async def render_GET(self, request: Request):
|
||||
uri = request.uri.decode()
|
||||
template = self.environment.get_template("core/frontend/user/index.jinja")
|
||||
|
||||
@ -276,12 +276,12 @@ class FE_User(FE_Base):
|
||||
else:
|
||||
usrid = usr_sesh.userId
|
||||
|
||||
user = self.data.user.get_user(usrid)
|
||||
user = await self.data.user.get_user(usrid)
|
||||
if user is None:
|
||||
return redirectTo(b"/user", request)
|
||||
|
||||
cards = self.data.card.get_user_cards(usrid)
|
||||
arcades = self.data.arcade.get_arcades_managed_by_user(usrid)
|
||||
cards = await self.data.card.get_user_cards(usrid)
|
||||
arcades = await self.data.arcade.get_arcades_managed_by_user(usrid)
|
||||
|
||||
card_data = []
|
||||
arcade_data = []
|
||||
@ -307,12 +307,12 @@ class FE_User(FE_Base):
|
||||
arcades=arcade_data
|
||||
).encode("utf-16")
|
||||
|
||||
def render_POST(self, request: Request):
|
||||
async def render_POST(self, request: Request):
|
||||
pass
|
||||
|
||||
|
||||
class FE_System(FE_Base):
|
||||
def render_GET(self, request: Request):
|
||||
async def render_GET(self, request: Request):
|
||||
uri = request.uri.decode()
|
||||
template = self.environment.get_template("core/frontend/sys/index.jinja")
|
||||
usrlist: List[Dict] = []
|
||||
@ -331,17 +331,17 @@ class FE_System(FE_Base):
|
||||
uname_search = uri_parse.get("usrName")
|
||||
|
||||
if uid_search is not None:
|
||||
u = self.data.user.get_user(uid_search[0])
|
||||
u = await self.data.user.get_user(uid_search[0])
|
||||
if u is not None:
|
||||
usrlist.append(u._asdict())
|
||||
|
||||
elif email_search is not None:
|
||||
u = self.data.user.find_user_by_email(email_search[0])
|
||||
u = await self.data.user.find_user_by_email(email_search[0])
|
||||
if u is not None:
|
||||
usrlist.append(u._asdict())
|
||||
|
||||
elif uname_search is not None:
|
||||
ul = self.data.user.find_user_by_username(uname_search[0])
|
||||
ul = await self.data.user.find_user_by_username(uname_search[0])
|
||||
for u in ul:
|
||||
usrlist.append(u._asdict())
|
||||
|
||||
@ -353,24 +353,24 @@ class FE_System(FE_Base):
|
||||
ac_ip_search = uri_parse.get("arcadeIp")
|
||||
|
||||
if ac_id_search is not None:
|
||||
u = self.data.arcade.get_arcade(ac_id_search[0])
|
||||
u = await self.data.arcade.get_arcade(ac_id_search[0])
|
||||
if u is not None:
|
||||
aclist.append(u._asdict())
|
||||
|
||||
elif ac_name_search is not None:
|
||||
ul = self.data.arcade.get_arcade_by_name(ac_name_search[0])
|
||||
ul = await self.data.arcade.get_arcade_by_name(ac_name_search[0])
|
||||
if ul is not None:
|
||||
for u in ul:
|
||||
aclist.append(u._asdict())
|
||||
|
||||
elif ac_user_search is not None:
|
||||
ul = self.data.arcade.get_arcades_managed_by_user(ac_user_search[0])
|
||||
ul = await self.data.arcade.get_arcades_managed_by_user(ac_user_search[0])
|
||||
if ul is not None:
|
||||
for u in ul:
|
||||
aclist.append(u._asdict())
|
||||
|
||||
elif ac_ip_search is not None:
|
||||
ul = self.data.arcade.get_arcades_by_ip(ac_ip_search[0])
|
||||
ul = await self.data.arcade.get_arcades_by_ip(ac_ip_search[0])
|
||||
if ul is not None:
|
||||
for u in ul:
|
||||
aclist.append(u._asdict())
|
||||
@ -382,17 +382,17 @@ class FE_System(FE_Base):
|
||||
cab_acid_search = uri_parse.get("cabAcId")
|
||||
|
||||
if cab_id_search is not None:
|
||||
u = self.data.arcade.get_machine(id=cab_id_search[0])
|
||||
u = await self.data.arcade.get_machine(id=cab_id_search[0])
|
||||
if u is not None:
|
||||
cablist.append(u._asdict())
|
||||
|
||||
elif cab_serial_search is not None:
|
||||
u = self.data.arcade.get_machine(serial=cab_serial_search[0])
|
||||
u = await self.data.arcade.get_machine(serial=cab_serial_search[0])
|
||||
if u is not None:
|
||||
cablist.append(u._asdict())
|
||||
|
||||
elif cab_acid_search is not None:
|
||||
ul = self.data.arcade.get_arcade_machines(cab_acid_search[0])
|
||||
ul = await self.data.arcade.get_arcade_machines(cab_acid_search[0])
|
||||
for u in ul:
|
||||
cablist.append(u._asdict())
|
||||
|
||||
@ -414,12 +414,12 @@ class FE_Game(FE_Base):
|
||||
return self
|
||||
return resource.Resource.getChild(self, name, request)
|
||||
|
||||
def render_GET(self, request: Request) -> bytes:
|
||||
async def render_GET(self, request: Request) -> bytes:
|
||||
return redirectTo(b"/user", request)
|
||||
|
||||
|
||||
class FE_Arcade(FE_Base):
|
||||
def render_GET(self, request: Request):
|
||||
async def render_GET(self, request: Request):
|
||||
uri = request.uri.decode()
|
||||
template = self.environment.get_template("core/frontend/arcade/index.jinja")
|
||||
managed = []
|
||||
@ -433,8 +433,8 @@ class FE_Arcade(FE_Base):
|
||||
|
||||
if m is not None:
|
||||
arcadeid = m.group(1)
|
||||
perms = self.data.arcade.get_manager_permissions(usr_sesh.userId, arcadeid)
|
||||
arcade = self.data.arcade.get_arcade(arcadeid)
|
||||
perms = await self.data.arcade.get_manager_permissions(usr_sesh.userId, arcadeid)
|
||||
arcade = await self.data.arcade.get_arcade(arcadeid)
|
||||
|
||||
if perms is None:
|
||||
perms = 0
|
||||
@ -452,7 +452,7 @@ class FE_Arcade(FE_Base):
|
||||
|
||||
|
||||
class FE_Machine(FE_Base):
|
||||
def render_GET(self, request: Request):
|
||||
async def render_GET(self, request: Request):
|
||||
uri = request.uri.decode()
|
||||
template = self.environment.get_template("core/frontend/machine/index.jinja")
|
||||
|
||||
|
@ -18,7 +18,6 @@ title:
|
||||
loglevel: "info"
|
||||
reboot_start_time: "04:00"
|
||||
reboot_end_time: "05:00"
|
||||
ssl_key: "cert/title.key"
|
||||
|
||||
database:
|
||||
host: "localhost"
|
||||
|
8
read.py
8
read.py
@ -6,6 +6,7 @@ import yaml
|
||||
from os import path
|
||||
import logging
|
||||
import coloredlogs
|
||||
import asyncio
|
||||
|
||||
from logging.handlers import TimedRotatingFileHandler
|
||||
from typing import List, Optional
|
||||
@ -38,6 +39,9 @@ class BaseReader:
|
||||
ret.append(f"{root}/{dir}")
|
||||
|
||||
return ret
|
||||
|
||||
async def read(self) -> None:
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
@ -136,6 +140,8 @@ if __name__ == "__main__":
|
||||
for dir, mod in titles.items():
|
||||
if args.game in mod.game_codes:
|
||||
handler = mod.reader(config, args.version, bin_arg, opt_arg, args.extra)
|
||||
handler.read()
|
||||
loop = asyncio.get_event_loop()
|
||||
loop.run_until_complete(handler.read())
|
||||
|
||||
|
||||
logger.info("Done")
|
||||
|
@ -38,20 +38,20 @@ class ChuniBase:
|
||||
return {"returnCode": 1}
|
||||
|
||||
user_id = data["userId"]
|
||||
login_bonus_presets = self.data.static.get_login_bonus_presets(self.version)
|
||||
login_bonus_presets = await self.data.static.get_login_bonus_presets(self.version)
|
||||
|
||||
for preset in login_bonus_presets:
|
||||
# check if a user already has some pogress and if not add the
|
||||
# login bonus entry
|
||||
user_login_bonus = self.data.item.get_login_bonus(
|
||||
user_login_bonus = await self.data.item.get_login_bonus(
|
||||
user_id, self.version, preset["presetId"]
|
||||
)
|
||||
if user_login_bonus is None:
|
||||
self.data.item.put_login_bonus(
|
||||
await self.data.item.put_login_bonus(
|
||||
user_id, self.version, preset["presetId"]
|
||||
)
|
||||
# yeah i'm lazy
|
||||
user_login_bonus = self.data.item.get_login_bonus(
|
||||
user_login_bonus = await self.data.item.get_login_bonus(
|
||||
user_id, self.version, preset["presetId"]
|
||||
)
|
||||
|
||||
@ -67,7 +67,7 @@ class ChuniBase:
|
||||
bonus_count = user_login_bonus["bonusCount"] + 1
|
||||
last_update_date = datetime.now()
|
||||
|
||||
all_login_boni = self.data.static.get_login_bonus(
|
||||
all_login_boni = await self.data.static.get_login_bonus(
|
||||
self.version, preset["presetId"]
|
||||
)
|
||||
|
||||
@ -91,13 +91,13 @@ class ChuniBase:
|
||||
is_finished = True
|
||||
|
||||
# grab the item for the corresponding day
|
||||
login_item = self.data.static.get_login_bonus_by_required_days(
|
||||
login_item = await self.data.static.get_login_bonus_by_required_days(
|
||||
self.version, preset["presetId"], bonus_count
|
||||
)
|
||||
if login_item is not None:
|
||||
# now add the present to the database so the
|
||||
# handle_get_user_item_api_request can grab them
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id,
|
||||
{
|
||||
"itemId": login_item["presentId"],
|
||||
@ -107,7 +107,7 @@ class ChuniBase:
|
||||
},
|
||||
)
|
||||
|
||||
self.data.item.put_login_bonus(
|
||||
await self.data.item.put_login_bonus(
|
||||
user_id,
|
||||
self.version,
|
||||
preset["presetId"],
|
||||
@ -124,7 +124,7 @@ class ChuniBase:
|
||||
return {"returnCode": 1}
|
||||
|
||||
async def handle_get_game_charge_api_request(self, data: Dict) -> Dict:
|
||||
game_charge_list = self.data.static.get_enabled_charges(self.version)
|
||||
game_charge_list = await self.data.static.get_enabled_charges(self.version)
|
||||
|
||||
if game_charge_list is None or len(game_charge_list) == 0:
|
||||
return {"length": 0, "gameChargeList": []}
|
||||
@ -146,7 +146,7 @@ class ChuniBase:
|
||||
return {"length": len(charges), "gameChargeList": charges}
|
||||
|
||||
async def handle_get_game_event_api_request(self, data: Dict) -> Dict:
|
||||
game_events = self.data.static.get_enabled_events(self.version)
|
||||
game_events = await self.data.static.get_enabled_events(self.version)
|
||||
|
||||
if game_events is None or len(game_events) == 0:
|
||||
self.logger.warning("No enabled events, did you run the reader?")
|
||||
@ -194,7 +194,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_game_ranking_api_request(self, data: Dict) -> Dict:
|
||||
rankings = self.data.score.get_rankings(self.version)
|
||||
rankings = await self.data.score.get_rankings(self.version)
|
||||
return {"type": data["type"], "gameRankingList": rankings}
|
||||
|
||||
async def handle_get_game_sale_api_request(self, data: Dict) -> Dict:
|
||||
@ -241,7 +241,7 @@ class ChuniBase:
|
||||
"isAou": "false",
|
||||
}
|
||||
async def handle_get_user_activity_api_request(self, data: Dict) -> Dict:
|
||||
user_activity_list = self.data.profile.get_profile_activity(
|
||||
user_activity_list = await self.data.profile.get_profile_activity(
|
||||
data["userId"], data["kind"]
|
||||
)
|
||||
|
||||
@ -262,7 +262,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_character_api_request(self, data: Dict) -> Dict:
|
||||
characters = self.data.item.get_characters(data["userId"])
|
||||
characters = await self.data.item.get_characters(data["userId"])
|
||||
if characters is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -297,7 +297,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
|
||||
user_charge_list = self.data.profile.get_profile_charge(data["userId"])
|
||||
user_charge_list = await self.data.profile.get_profile_charge(data["userId"])
|
||||
|
||||
charge_list = []
|
||||
for charge in user_charge_list:
|
||||
@ -320,7 +320,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_course_api_request(self, data: Dict) -> Dict:
|
||||
user_course_list = self.data.score.get_courses(data["userId"])
|
||||
user_course_list = await self.data.score.get_courses(data["userId"])
|
||||
if user_course_list is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -355,7 +355,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
@ -367,7 +367,7 @@ class ChuniBase:
|
||||
return {"userId": data["userId"], "userData": profile}
|
||||
|
||||
async def handle_get_user_data_ex_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_data_ex(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data_ex(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
@ -379,7 +379,7 @@ class ChuniBase:
|
||||
return {"userId": data["userId"], "userDataEx": profile}
|
||||
|
||||
async def handle_get_user_duel_api_request(self, data: Dict) -> Dict:
|
||||
user_duel_list = self.data.item.get_duels(data["userId"])
|
||||
user_duel_list = await self.data.item.get_duels(data["userId"])
|
||||
if user_duel_list is None:
|
||||
return {}
|
||||
|
||||
@ -397,7 +397,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_rival_data_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_rival(data["rivalId"])
|
||||
p = await self.data.profile.get_rival(data["rivalId"])
|
||||
if p is None:
|
||||
return {}
|
||||
userRivalData = {
|
||||
@ -416,7 +416,7 @@ class ChuniBase:
|
||||
user_rival_music_list = []
|
||||
|
||||
# Fetch all the rival music entries for the user
|
||||
all_entries = self.data.score.get_rival_music(rival_id)
|
||||
all_entries = await self.data.score.get_rival_music(rival_id)
|
||||
|
||||
# Process the entries based on max_count and nextIndex
|
||||
for music in all_entries:
|
||||
@ -467,7 +467,7 @@ class ChuniBase:
|
||||
|
||||
# still needs to be implemented on WebUI
|
||||
# 1: Music, 2: User, 3: Character
|
||||
fav_list = self.data.item.get_all_favorites(
|
||||
fav_list = await self.data.item.get_all_favorites(
|
||||
data["userId"], self.version, fav_kind=int(data["kind"])
|
||||
)
|
||||
if fav_list is not None:
|
||||
@ -492,7 +492,7 @@ class ChuniBase:
|
||||
async def handle_get_user_item_api_request(self, data: Dict) -> Dict:
|
||||
kind = int(int(data["nextIndex"]) / 10000000000)
|
||||
next_idx = int(int(data["nextIndex"]) % 10000000000)
|
||||
user_item_list = self.data.item.get_items(data["userId"], kind)
|
||||
user_item_list = await self.data.item.get_items(data["userId"], kind)
|
||||
|
||||
if user_item_list is None or len(user_item_list) == 0:
|
||||
return {
|
||||
@ -528,7 +528,7 @@ class ChuniBase:
|
||||
|
||||
async def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
|
||||
user_id = data["userId"]
|
||||
user_login_bonus = self.data.item.get_all_login_bonus(user_id, self.version)
|
||||
user_login_bonus = await self.data.item.get_all_login_bonus(user_id, self.version)
|
||||
# ignore the loginBonus request if its disabled in config
|
||||
if user_login_bonus is None or not self.game_cfg.mods.use_login_bonus:
|
||||
return {"userId": user_id, "length": 0, "userLoginBonusList": []}
|
||||
@ -553,7 +553,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_map_api_request(self, data: Dict) -> Dict:
|
||||
user_map_list = self.data.item.get_maps(data["userId"])
|
||||
user_map_list = await self.data.item.get_maps(data["userId"])
|
||||
if user_map_list is None:
|
||||
return {}
|
||||
|
||||
@ -571,7 +571,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_music_api_request(self, data: Dict) -> Dict:
|
||||
music_detail = self.data.score.get_scores(data["userId"])
|
||||
music_detail = await self.data.score.get_scores(data["userId"])
|
||||
if music_detail is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -630,7 +630,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_option_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_option(data["userId"])
|
||||
p = await self.data.profile.get_profile_option(data["userId"])
|
||||
|
||||
option = p._asdict()
|
||||
option.pop("id")
|
||||
@ -639,7 +639,7 @@ class ChuniBase:
|
||||
return {"userId": data["userId"], "userGameOption": option}
|
||||
|
||||
async def handle_get_user_option_ex_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_option_ex(data["userId"])
|
||||
p = await self.data.profile.get_profile_option_ex(data["userId"])
|
||||
|
||||
option = p._asdict()
|
||||
option.pop("id")
|
||||
@ -651,10 +651,10 @@ class ChuniBase:
|
||||
return bytes([ord(c) for c in src]).decode("utf-8")
|
||||
|
||||
async def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_preview(data["userId"], self.version)
|
||||
profile = await self.data.profile.get_profile_preview(data["userId"], self.version)
|
||||
if profile is None:
|
||||
return None
|
||||
profile_character = self.data.item.get_character(
|
||||
profile_character = await self.data.item.get_character(
|
||||
data["userId"], profile["characterId"]
|
||||
)
|
||||
|
||||
@ -693,7 +693,7 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_recent_rating_api_request(self, data: Dict) -> Dict:
|
||||
recent_rating_list = self.data.profile.get_profile_recent_rating(data["userId"])
|
||||
recent_rating_list = await self.data.profile.get_profile_recent_rating(data["userId"])
|
||||
if recent_rating_list is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -722,15 +722,15 @@ class ChuniBase:
|
||||
team_rank = 0
|
||||
|
||||
# Get user profile
|
||||
profile = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
profile = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if profile and profile["teamId"]:
|
||||
# Get team by id
|
||||
team = self.data.profile.get_team_by_id(profile["teamId"])
|
||||
team = await self.data.profile.get_team_by_id(profile["teamId"])
|
||||
|
||||
if team:
|
||||
team_id = team["id"]
|
||||
team_name = team["teamName"]
|
||||
team_rank = self.data.profile.get_team_rank(team["id"])
|
||||
team_rank = await self.data.profile.get_team_rank(team["id"])
|
||||
|
||||
# Don't return anything if no team name has been defined for defaults and there is no team set for the player
|
||||
if not profile["teamId"] and team_name == "":
|
||||
@ -819,58 +819,58 @@ class ChuniBase:
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
|
||||
if "userDataEx" in upsert:
|
||||
self.data.profile.put_profile_data_ex(
|
||||
await self.data.profile.put_profile_data_ex(
|
||||
user_id, self.version, upsert["userDataEx"][0]
|
||||
)
|
||||
|
||||
if "userGameOption" in upsert:
|
||||
self.data.profile.put_profile_option(user_id, upsert["userGameOption"][0])
|
||||
await self.data.profile.put_profile_option(user_id, upsert["userGameOption"][0])
|
||||
|
||||
if "userGameOptionEx" in upsert:
|
||||
self.data.profile.put_profile_option_ex(
|
||||
await self.data.profile.put_profile_option_ex(
|
||||
user_id, upsert["userGameOptionEx"][0]
|
||||
)
|
||||
if "userRecentRatingList" in upsert:
|
||||
self.data.profile.put_profile_recent_rating(
|
||||
await self.data.profile.put_profile_recent_rating(
|
||||
user_id, upsert["userRecentRatingList"]
|
||||
)
|
||||
|
||||
if "userCharacterList" in upsert:
|
||||
for character in upsert["userCharacterList"]:
|
||||
self.data.item.put_character(user_id, character)
|
||||
await self.data.item.put_character(user_id, character)
|
||||
|
||||
if "userMapList" in upsert:
|
||||
for map in upsert["userMapList"]:
|
||||
self.data.item.put_map(user_id, map)
|
||||
await self.data.item.put_map(user_id, map)
|
||||
|
||||
if "userCourseList" in upsert:
|
||||
for course in upsert["userCourseList"]:
|
||||
self.data.score.put_course(user_id, course)
|
||||
await self.data.score.put_course(user_id, course)
|
||||
|
||||
if "userDuelList" in upsert:
|
||||
for duel in upsert["userDuelList"]:
|
||||
self.data.item.put_duel(user_id, duel)
|
||||
await self.data.item.put_duel(user_id, duel)
|
||||
|
||||
if "userItemList" in upsert:
|
||||
for item in upsert["userItemList"]:
|
||||
self.data.item.put_item(user_id, item)
|
||||
await self.data.item.put_item(user_id, item)
|
||||
|
||||
if "userActivityList" in upsert:
|
||||
for activity in upsert["userActivityList"]:
|
||||
self.data.profile.put_profile_activity(user_id, activity)
|
||||
await self.data.profile.put_profile_activity(user_id, activity)
|
||||
|
||||
if "userChargeList" in upsert:
|
||||
for charge in upsert["userChargeList"]:
|
||||
self.data.profile.put_profile_charge(user_id, charge)
|
||||
await self.data.profile.put_profile_charge(user_id, charge)
|
||||
|
||||
if "userMusicDetailList" in upsert:
|
||||
for song in upsert["userMusicDetailList"]:
|
||||
self.data.score.put_score(user_id, song)
|
||||
await self.data.score.put_score(user_id, song)
|
||||
|
||||
if "userPlaylogList" in upsert:
|
||||
for playlog in upsert["userPlaylogList"]:
|
||||
@ -881,7 +881,7 @@ class ChuniBase:
|
||||
playlog["playedUserName2"] = self.read_wtf8(playlog["playedUserName2"])
|
||||
if playlog["playedUserName3"] is not None:
|
||||
playlog["playedUserName3"] = self.read_wtf8(playlog["playedUserName3"])
|
||||
self.data.score.put_playlog(user_id, playlog, self.version)
|
||||
await self.data.score.put_playlog(user_id, playlog, self.version)
|
||||
|
||||
if "userTeamPoint" in upsert:
|
||||
team_points = upsert["userTeamPoint"]
|
||||
@ -889,7 +889,7 @@ class ChuniBase:
|
||||
for tp in team_points:
|
||||
if tp["teamId"] != '65535':
|
||||
# Fetch the current team data
|
||||
current_team = self.data.profile.get_team_by_id(tp["teamId"])
|
||||
current_team = await self.data.profile.get_team_by_id(tp["teamId"])
|
||||
|
||||
# Calculate the new teamPoint
|
||||
new_team_point = int(tp["teamPoint"]) + current_team["teamPoint"]
|
||||
@ -900,24 +900,24 @@ class ChuniBase:
|
||||
}
|
||||
|
||||
# Update the team data
|
||||
self.data.profile.update_team(tp["teamId"], team_data)
|
||||
await self.data.profile.update_team(tp["teamId"], team_data)
|
||||
except:
|
||||
pass # Probably a better way to catch if the team is not set yet (new profiles), but let's just pass
|
||||
if "userMapAreaList" in upsert:
|
||||
for map_area in upsert["userMapAreaList"]:
|
||||
self.data.item.put_map_area(user_id, map_area)
|
||||
await self.data.item.put_map_area(user_id, map_area)
|
||||
|
||||
if "userOverPowerList" in upsert:
|
||||
for overpower in upsert["userOverPowerList"]:
|
||||
self.data.profile.put_profile_overpower(user_id, overpower)
|
||||
await self.data.profile.put_profile_overpower(user_id, overpower)
|
||||
|
||||
if "userEmoneyList" in upsert:
|
||||
for emoney in upsert["userEmoneyList"]:
|
||||
self.data.profile.put_profile_emoney(user_id, emoney)
|
||||
await self.data.profile.put_profile_emoney(user_id, emoney)
|
||||
|
||||
if "userLoginBonusList" in upsert:
|
||||
for login in upsert["userLoginBonusList"]:
|
||||
self.data.item.put_login_bonus(
|
||||
await self.data.item.put_login_bonus(
|
||||
user_id, self.version, login["presetId"], isWatched=True
|
||||
)
|
||||
|
||||
@ -930,7 +930,7 @@ class ChuniBase:
|
||||
async def handle_upsert_user_chargelog_api_request(self, data: Dict) -> Dict:
|
||||
# add tickets after they got bought, this makes sure the tickets are
|
||||
# still valid after an unsuccessful logout
|
||||
self.data.profile.put_profile_charge(data["userId"], data["userCharge"])
|
||||
await self.data.profile.put_profile_charge(data["userId"], data["userCharge"])
|
||||
return {"returnCode": "1"}
|
||||
|
||||
async def handle_upsert_client_bookkeeping_api_request(self, data: Dict) -> Dict:
|
||||
|
@ -102,7 +102,7 @@ class ChuniNew(ChuniBase):
|
||||
return {"returnCode": "1"}
|
||||
|
||||
async def handle_get_user_map_area_api_request(self, data: Dict) -> Dict:
|
||||
user_map_areas = self.data.item.get_map_areas(data["userId"])
|
||||
user_map_areas = await self.data.item.get_map_areas(data["userId"])
|
||||
|
||||
map_areas = []
|
||||
for map_area in user_map_areas:
|
||||
@ -117,10 +117,10 @@ class ChuniNew(ChuniBase):
|
||||
return {"userId": data["userId"], "symbolCharInfoList": []}
|
||||
|
||||
async def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_preview(data["userId"], self.version)
|
||||
profile = await self.data.profile.get_profile_preview(data["userId"], self.version)
|
||||
if profile is None:
|
||||
return None
|
||||
profile_character = self.data.item.get_character(
|
||||
profile_character = await self.data.item.get_character(
|
||||
data["userId"], profile["characterId"]
|
||||
)
|
||||
|
||||
@ -165,7 +165,7 @@ class ChuniNew(ChuniBase):
|
||||
return data1
|
||||
|
||||
async def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
@ -187,7 +187,7 @@ class ChuniNew(ChuniBase):
|
||||
"""
|
||||
returns all current active banners (gachas)
|
||||
"""
|
||||
game_gachas = self.data.static.get_gachas(self.version)
|
||||
game_gachas = await self.data.static.get_gachas(self.version)
|
||||
|
||||
# clean the database rows
|
||||
game_gacha_list = []
|
||||
@ -217,7 +217,7 @@ class ChuniNew(ChuniBase):
|
||||
"""
|
||||
returns all valid cards for a given gachaId
|
||||
"""
|
||||
game_gacha_cards = self.data.static.get_gacha_cards(data["gachaId"])
|
||||
game_gacha_cards = await self.data.static.get_gacha_cards(data["gachaId"])
|
||||
|
||||
game_gacha_card_list = []
|
||||
for gacha_card in game_gacha_cards:
|
||||
@ -238,7 +238,7 @@ class ChuniNew(ChuniBase):
|
||||
}
|
||||
|
||||
async def handle_cm_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
@ -263,7 +263,7 @@ class ChuniNew(ChuniBase):
|
||||
}
|
||||
|
||||
async def handle_get_user_gacha_api_request(self, data: Dict) -> Dict:
|
||||
user_gachas = self.data.item.get_user_gachas(data["userId"])
|
||||
user_gachas = await self.data.item.get_user_gachas(data["userId"])
|
||||
if user_gachas is None:
|
||||
return {"userId": data["userId"], "length": 0, "userGachaList": []}
|
||||
|
||||
@ -282,7 +282,7 @@ class ChuniNew(ChuniBase):
|
||||
}
|
||||
|
||||
async def handle_get_user_printed_card_api_request(self, data: Dict) -> Dict:
|
||||
user_print_list = self.data.item.get_user_print_states(
|
||||
user_print_list = await self.data.item.get_user_print_states(
|
||||
data["userId"], has_completed=True
|
||||
)
|
||||
if user_print_list is None:
|
||||
@ -319,7 +319,7 @@ class ChuniNew(ChuniBase):
|
||||
async def handle_get_user_card_print_error_api_request(self, data: Dict) -> Dict:
|
||||
user_id = data["userId"]
|
||||
|
||||
user_print_states = self.data.item.get_user_print_states(
|
||||
user_print_states = await self.data.item.get_user_print_states(
|
||||
user_id, has_completed=False
|
||||
)
|
||||
|
||||
@ -362,14 +362,14 @@ class ChuniNew(ChuniBase):
|
||||
# characterId should be returned
|
||||
if chara_id != -1:
|
||||
# get the
|
||||
card = self.data.static.get_gacha_card_by_character(gacha_id, chara_id)
|
||||
card = await self.data.static.get_gacha_card_by_character(gacha_id, chara_id)
|
||||
|
||||
tmp = card._asdict()
|
||||
tmp.pop("id")
|
||||
|
||||
rolled_cards.append(tmp)
|
||||
else:
|
||||
gacha_cards = self.data.static.get_gacha_cards(gacha_id)
|
||||
gacha_cards = await self.data.static.get_gacha_cards(gacha_id)
|
||||
|
||||
# get the card id for each roll
|
||||
for _ in range(num_rolls):
|
||||
@ -396,7 +396,7 @@ class ChuniNew(ChuniBase):
|
||||
user_data.pop("rankUpChallengeResults")
|
||||
user_data.pop("userEmoney")
|
||||
|
||||
self.data.profile.put_profile_data(user_id, self.version, user_data)
|
||||
await self.data.profile.put_profile_data(user_id, self.version, user_data)
|
||||
|
||||
# save the user gacha
|
||||
user_gacha = upsert["userGacha"]
|
||||
@ -404,16 +404,16 @@ class ChuniNew(ChuniBase):
|
||||
user_gacha.pop("gachaId")
|
||||
user_gacha.pop("dailyGachaDate")
|
||||
|
||||
self.data.item.put_user_gacha(user_id, gacha_id, user_gacha)
|
||||
await self.data.item.put_user_gacha(user_id, gacha_id, user_gacha)
|
||||
|
||||
# save all user items
|
||||
if "userItemList" in upsert:
|
||||
for item in upsert["userItemList"]:
|
||||
self.data.item.put_item(user_id, item)
|
||||
await self.data.item.put_item(user_id, item)
|
||||
|
||||
# add every gamegachaCard to database
|
||||
for card in upsert["gameGachaCardList"]:
|
||||
self.data.item.put_user_print_state(
|
||||
await self.data.item.put_user_print_state(
|
||||
user_id,
|
||||
hasCompleted=False,
|
||||
placeId=place_id,
|
||||
@ -423,7 +423,7 @@ class ChuniNew(ChuniBase):
|
||||
|
||||
# retrieve every game gacha card which has been added in order to get
|
||||
# the orderId for the next request
|
||||
user_print_states = self.data.item.get_user_print_states_by_gacha(
|
||||
user_print_states = await self.data.item.get_user_print_states_by_gacha(
|
||||
user_id, gacha_id, has_completed=False
|
||||
)
|
||||
card_print_state_list = []
|
||||
@ -465,7 +465,7 @@ class ChuniNew(ChuniBase):
|
||||
)
|
||||
|
||||
# add the entry to the user print table with the random serialId
|
||||
self.data.item.put_user_print_detail(user_id, serial_id, user_print_detail)
|
||||
await self.data.item.put_user_print_detail(user_id, serial_id, user_print_detail)
|
||||
|
||||
return {
|
||||
"returnCode": 1,
|
||||
@ -482,10 +482,10 @@ class ChuniNew(ChuniBase):
|
||||
# save all user items
|
||||
if "userItemList" in data:
|
||||
for item in data["userItemList"]:
|
||||
self.data.item.put_item(user_id, item)
|
||||
await self.data.item.put_item(user_id, item)
|
||||
|
||||
# set the card print state to success and use the orderId as the key
|
||||
self.data.item.put_user_print_state(
|
||||
await self.data.item.put_user_print_state(
|
||||
user_id, id=upsert["orderId"], hasCompleted=True
|
||||
)
|
||||
|
||||
@ -497,7 +497,7 @@ class ChuniNew(ChuniBase):
|
||||
|
||||
# set the card print state to success and use the orderId as the key
|
||||
for order_id in order_ids:
|
||||
self.data.item.put_user_print_state(user_id, id=order_id, hasCompleted=True)
|
||||
await self.data.item.put_user_print_state(user_id, id=order_id, hasCompleted=True)
|
||||
|
||||
return {"returnCode": "1", "apiName": "CMUpsertUserPrintCancelApi"}
|
||||
|
||||
@ -508,11 +508,11 @@ class ChuniNew(ChuniBase):
|
||||
async def handle_begin_matching_api_request(self, data: Dict) -> Dict:
|
||||
room_id = 1
|
||||
# check if there is a free matching room
|
||||
matching_room = self.data.item.get_oldest_free_matching(self.version)
|
||||
matching_room = await self.data.item.get_oldest_free_matching(self.version)
|
||||
|
||||
if matching_room is None:
|
||||
# grab the latest roomId and add 1 for the new room
|
||||
newest_matching = self.data.item.get_newest_matching(self.version)
|
||||
newest_matching = await self.data.item.get_newest_matching(self.version)
|
||||
if newest_matching is not None:
|
||||
room_id = newest_matching["roomId"] + 1
|
||||
|
||||
@ -522,12 +522,12 @@ class ChuniNew(ChuniBase):
|
||||
|
||||
# create the new room with room_id and the current user id (host)
|
||||
# user id is required for the countdown later on
|
||||
self.data.item.put_matching(
|
||||
await self.data.item.put_matching(
|
||||
self.version, room_id, [new_member], user_id=new_member["userId"]
|
||||
)
|
||||
|
||||
# get the newly created matching room
|
||||
matching_room = self.data.item.get_matching(self.version, room_id)
|
||||
matching_room = await self.data.item.get_matching(self.version, room_id)
|
||||
else:
|
||||
# a room already exists, so just add the new member to it
|
||||
matching_member_list = matching_room["matchingMemberInfoList"]
|
||||
@ -537,7 +537,7 @@ class ChuniNew(ChuniBase):
|
||||
matching_member_list.append(new_member)
|
||||
|
||||
# add the updated room to the database, make sure to set isFull correctly!
|
||||
self.data.item.put_matching(
|
||||
await self.data.item.put_matching(
|
||||
self.version,
|
||||
matching_room["roomId"],
|
||||
matching_member_list,
|
||||
@ -555,7 +555,7 @@ class ChuniNew(ChuniBase):
|
||||
return {"roomId": 1, "matchingWaitState": matching_wait}
|
||||
|
||||
async def handle_end_matching_api_request(self, data: Dict) -> Dict:
|
||||
matching_room = self.data.item.get_matching(self.version, data["roomId"])
|
||||
matching_room = await self.data.item.get_matching(self.version, data["roomId"])
|
||||
members = matching_room["matchingMemberInfoList"]
|
||||
|
||||
# only set the host user to role 1 every other to 0?
|
||||
@ -564,7 +564,7 @@ class ChuniNew(ChuniBase):
|
||||
for m in members
|
||||
]
|
||||
|
||||
self.data.item.put_matching(
|
||||
await self.data.item.put_matching(
|
||||
self.version,
|
||||
matching_room["roomId"],
|
||||
members,
|
||||
@ -585,7 +585,7 @@ class ChuniNew(ChuniBase):
|
||||
async def handle_remove_matching_member_api_request(self, data: Dict) -> Dict:
|
||||
# get all matching rooms, because Chuni only returns the userId
|
||||
# not the actual roomId
|
||||
matching_rooms = self.data.item.get_all_matchings(self.version)
|
||||
matching_rooms = await self.data.item.get_all_matchings(self.version)
|
||||
if matching_rooms is None:
|
||||
return {"returnCode": "1"}
|
||||
|
||||
@ -599,10 +599,10 @@ class ChuniNew(ChuniBase):
|
||||
|
||||
# if the last user got removed, delete the matching room
|
||||
if len(new_members) <= 0:
|
||||
self.data.item.delete_matching(self.version, room["roomId"])
|
||||
await self.data.item.delete_matching(self.version, room["roomId"])
|
||||
else:
|
||||
# remove the user from the room
|
||||
self.data.item.put_matching(
|
||||
await self.data.item.put_matching(
|
||||
self.version,
|
||||
room["roomId"],
|
||||
new_members,
|
||||
@ -615,7 +615,7 @@ class ChuniNew(ChuniBase):
|
||||
async def handle_get_matching_state_api_request(self, data: Dict) -> Dict:
|
||||
polling_interval = 1
|
||||
# get the current active room
|
||||
matching_room = self.data.item.get_matching(self.version, data["roomId"])
|
||||
matching_room = await self.data.item.get_matching(self.version, data["roomId"])
|
||||
members = matching_room["matchingMemberInfoList"]
|
||||
rest_sec = matching_room["restMSec"]
|
||||
|
||||
@ -638,7 +638,7 @@ class ChuniNew(ChuniBase):
|
||||
current_member["userName"] = self.read_wtf8(current_member["userName"])
|
||||
members[i] = current_member
|
||||
|
||||
self.data.item.put_matching(
|
||||
await self.data.item.put_matching(
|
||||
self.version,
|
||||
data["roomId"],
|
||||
members,
|
||||
|
@ -28,7 +28,7 @@ class ChuniReader(BaseReader):
|
||||
self.logger.error(f"Invalid chunithm version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
data_dirs = []
|
||||
if self.bin_dir is not None:
|
||||
data_dirs += self.get_data_directories(self.bin_dir)
|
||||
@ -38,13 +38,13 @@ class ChuniReader(BaseReader):
|
||||
|
||||
for dir in data_dirs:
|
||||
self.logger.info(f"Read from {dir}")
|
||||
self.read_events(f"{dir}/event")
|
||||
self.read_music(f"{dir}/music")
|
||||
self.read_charges(f"{dir}/chargeItem")
|
||||
self.read_avatar(f"{dir}/avatarAccessory")
|
||||
self.read_login_bonus(f"{dir}/")
|
||||
await self.read_events(f"{dir}/event")
|
||||
await self.read_music(f"{dir}/music")
|
||||
await self.read_charges(f"{dir}/chargeItem")
|
||||
await self.read_avatar(f"{dir}/avatarAccessory")
|
||||
await self.read_login_bonus(f"{dir}/")
|
||||
|
||||
def read_login_bonus(self, root_dir: str) -> None:
|
||||
async def read_login_bonus(self, root_dir: str) -> None:
|
||||
for root, dirs, files in walk(f"{root_dir}loginBonusPreset"):
|
||||
for dir in dirs:
|
||||
if path.exists(f"{root}/{dir}/LoginBonusPreset.xml"):
|
||||
@ -60,7 +60,7 @@ class ChuniReader(BaseReader):
|
||||
True if xml_root.find("disableFlag").text == "false" else False
|
||||
)
|
||||
|
||||
result = self.data.static.put_login_bonus_preset(
|
||||
result = await self.data.static.put_login_bonus_preset(
|
||||
self.version, id, name, is_enabled
|
||||
)
|
||||
|
||||
@ -98,7 +98,7 @@ class ChuniReader(BaseReader):
|
||||
bonus_root.find("loginBonusCategoryType").text
|
||||
)
|
||||
|
||||
result = self.data.static.put_login_bonus(
|
||||
result = await self.data.static.put_login_bonus(
|
||||
self.version,
|
||||
id,
|
||||
bonus_id,
|
||||
@ -117,7 +117,7 @@ class ChuniReader(BaseReader):
|
||||
f"Failed to insert login bonus {bonus_id}"
|
||||
)
|
||||
|
||||
def read_events(self, evt_dir: str) -> None:
|
||||
async def read_events(self, evt_dir: str) -> None:
|
||||
for root, dirs, files in walk(evt_dir):
|
||||
for dir in dirs:
|
||||
if path.exists(f"{root}/{dir}/Event.xml"):
|
||||
@ -132,7 +132,7 @@ class ChuniReader(BaseReader):
|
||||
for substances in xml_root.findall("substances"):
|
||||
event_type = substances.find("type").text
|
||||
|
||||
result = self.data.static.put_event(
|
||||
result = await self.data.static.put_event(
|
||||
self.version, id, event_type, name
|
||||
)
|
||||
if result is not None:
|
||||
@ -140,7 +140,7 @@ class ChuniReader(BaseReader):
|
||||
else:
|
||||
self.logger.warning(f"Failed to insert event {id}")
|
||||
|
||||
def read_music(self, music_dir: str) -> None:
|
||||
async def read_music(self, music_dir: str) -> None:
|
||||
for root, dirs, files in walk(music_dir):
|
||||
for dir in dirs:
|
||||
if path.exists(f"{root}/{dir}/Music.xml"):
|
||||
@ -185,7 +185,7 @@ class ChuniReader(BaseReader):
|
||||
)
|
||||
we_chara = None
|
||||
|
||||
result = self.data.static.put_music(
|
||||
result = await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
chart_id,
|
||||
@ -206,7 +206,7 @@ class ChuniReader(BaseReader):
|
||||
f"Failed to insert music {song_id} chart {chart_id}"
|
||||
)
|
||||
|
||||
def read_charges(self, charge_dir: str) -> None:
|
||||
async def read_charges(self, charge_dir: str) -> None:
|
||||
for root, dirs, files in walk(charge_dir):
|
||||
for dir in dirs:
|
||||
if path.exists(f"{root}/{dir}/ChargeItem.xml"):
|
||||
@ -222,7 +222,7 @@ class ChuniReader(BaseReader):
|
||||
consumeType = xml_root.find("consumeType").text
|
||||
sellingAppeal = bool(xml_root.find("sellingAppeal").text)
|
||||
|
||||
result = self.data.static.put_charge(
|
||||
result = await self.data.static.put_charge(
|
||||
self.version,
|
||||
id,
|
||||
name,
|
||||
@ -236,7 +236,7 @@ class ChuniReader(BaseReader):
|
||||
else:
|
||||
self.logger.warning(f"Failed to insert charge {id}")
|
||||
|
||||
def read_avatar(self, avatar_dir: str) -> None:
|
||||
async def read_avatar(self, avatar_dir: str) -> None:
|
||||
for root, dirs, files in walk(avatar_dir):
|
||||
for dir in dirs:
|
||||
if path.exists(f"{root}/{dir}/AvatarAccessory.xml"):
|
||||
@ -254,7 +254,7 @@ class ChuniReader(BaseReader):
|
||||
for texture in xml_root.findall("texture"):
|
||||
texturePath = texture.find("path").text
|
||||
|
||||
result = self.data.static.put_avatar(
|
||||
result = await self.data.static.put_avatar(
|
||||
self.version, id, name, category, iconPath, texturePath
|
||||
)
|
||||
|
||||
|
@ -245,7 +245,7 @@ matching = Table(
|
||||
|
||||
|
||||
class ChuniItemData(BaseData):
|
||||
def get_oldest_free_matching(self, version: int) -> Optional[Row]:
|
||||
async def get_oldest_free_matching(self, version: int) -> Optional[Row]:
|
||||
sql = matching.select(
|
||||
and_(
|
||||
matching.c.version == version,
|
||||
@ -253,46 +253,46 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
).order_by(matching.c.roomId.asc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_newest_matching(self, version: int) -> Optional[Row]:
|
||||
async def get_newest_matching(self, version: int) -> Optional[Row]:
|
||||
sql = matching.select(
|
||||
and_(
|
||||
matching.c.version == version
|
||||
)
|
||||
).order_by(matching.c.roomId.desc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_all_matchings(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_all_matchings(self, version: int) -> Optional[List[Row]]:
|
||||
sql = matching.select(
|
||||
and_(
|
||||
matching.c.version == version
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_matching(self, version: int, room_id: int) -> Optional[Row]:
|
||||
async def get_matching(self, version: int, room_id: int) -> Optional[Row]:
|
||||
sql = matching.select(
|
||||
and_(matching.c.version == version, matching.c.roomId == room_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_matching(
|
||||
async def put_matching(
|
||||
self,
|
||||
version: int,
|
||||
room_id: int,
|
||||
@ -314,22 +314,22 @@ class ChuniItemData(BaseData):
|
||||
restMSec=rest_sec, matchingMemberInfoList=matching_member_info_list
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def delete_matching(self, version: int, room_id: int):
|
||||
async def delete_matching(self, version: int, room_id: int):
|
||||
sql = delete(matching).where(
|
||||
and_(matching.c.roomId == room_id, matching.c.version == version)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_all_favorites(
|
||||
async def get_all_favorites(
|
||||
self, user_id: int, version: int, fav_kind: int = 1
|
||||
) -> Optional[List[Row]]:
|
||||
sql = favorite.select(
|
||||
@ -340,12 +340,12 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_login_bonus(
|
||||
async def put_login_bonus(
|
||||
self, user_id: int, version: int, preset_id: int, **login_bonus_data
|
||||
) -> Optional[int]:
|
||||
sql = insert(login_bonus).values(
|
||||
@ -354,12 +354,12 @@ class ChuniItemData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(presetId=preset_id, **login_bonus_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_all_login_bonus(
|
||||
async def get_all_login_bonus(
|
||||
self, user_id: int, version: int, is_finished: bool = False
|
||||
) -> Optional[List[Row]]:
|
||||
sql = login_bonus.select(
|
||||
@ -370,12 +370,12 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_login_bonus(
|
||||
async def get_login_bonus(
|
||||
self, user_id: int, version: int, preset_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = login_bonus.select(
|
||||
@ -386,12 +386,12 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_character(self, user_id: int, character_data: Dict) -> Optional[int]:
|
||||
async def put_character(self, user_id: int, character_data: Dict) -> Optional[int]:
|
||||
character_data["user"] = user_id
|
||||
|
||||
character_data = self.fix_bools(character_data)
|
||||
@ -399,30 +399,30 @@ class ChuniItemData(BaseData):
|
||||
sql = insert(character).values(**character_data)
|
||||
conflict = sql.on_duplicate_key_update(**character_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_character(self, user_id: int, character_id: int) -> Optional[Dict]:
|
||||
async def get_character(self, user_id: int, character_id: int) -> Optional[Dict]:
|
||||
sql = select(character).where(
|
||||
and_(character.c.user == user_id, character.c.characterId == character_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_characters(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_characters(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(character).where(character.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_item(self, user_id: int, item_data: Dict) -> Optional[int]:
|
||||
async def put_item(self, user_id: int, item_data: Dict) -> Optional[int]:
|
||||
item_data["user"] = user_id
|
||||
|
||||
item_data = self.fix_bools(item_data)
|
||||
@ -430,12 +430,12 @@ class ChuniItemData(BaseData):
|
||||
sql = insert(item).values(**item_data)
|
||||
conflict = sql.on_duplicate_key_update(**item_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_items(self, user_id: int, kind: int = None) -> Optional[List[Row]]:
|
||||
async def get_items(self, user_id: int, kind: int = None) -> Optional[List[Row]]:
|
||||
if kind is None:
|
||||
sql = select(item).where(item.c.user == user_id)
|
||||
else:
|
||||
@ -443,12 +443,12 @@ class ChuniItemData(BaseData):
|
||||
and_(item.c.user == user_id, item.c.itemKind == kind)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_duel(self, user_id: int, duel_data: Dict) -> Optional[int]:
|
||||
async def put_duel(self, user_id: int, duel_data: Dict) -> Optional[int]:
|
||||
duel_data["user"] = user_id
|
||||
|
||||
duel_data = self.fix_bools(duel_data)
|
||||
@ -456,20 +456,20 @@ class ChuniItemData(BaseData):
|
||||
sql = insert(duel).values(**duel_data)
|
||||
conflict = sql.on_duplicate_key_update(**duel_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_duels(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_duels(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(duel).where(duel.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_map(self, user_id: int, map_data: Dict) -> Optional[int]:
|
||||
async def put_map(self, user_id: int, map_data: Dict) -> Optional[int]:
|
||||
map_data["user"] = user_id
|
||||
|
||||
map_data = self.fix_bools(map_data)
|
||||
@ -477,20 +477,20 @@ class ChuniItemData(BaseData):
|
||||
sql = insert(map).values(**map_data)
|
||||
conflict = sql.on_duplicate_key_update(**map_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_maps(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_maps(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(map).where(map.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_map_area(self, user_id: int, map_area_data: Dict) -> Optional[int]:
|
||||
async def put_map_area(self, user_id: int, map_area_data: Dict) -> Optional[int]:
|
||||
map_area_data["user"] = user_id
|
||||
|
||||
map_area_data = self.fix_bools(map_area_data)
|
||||
@ -498,28 +498,28 @@ class ChuniItemData(BaseData):
|
||||
sql = insert(map_area).values(**map_area_data)
|
||||
conflict = sql.on_duplicate_key_update(**map_area_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_map_areas(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_map_areas(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(map_area).where(map_area.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_user_gachas(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_user_gachas(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = gacha.select(gacha.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_user_gacha(
|
||||
async def put_user_gacha(
|
||||
self, aime_id: int, gacha_id: int, gacha_data: Dict
|
||||
) -> Optional[int]:
|
||||
sql = insert(gacha).values(user=aime_id, gachaId=gacha_id, **gacha_data)
|
||||
@ -527,14 +527,14 @@ class ChuniItemData(BaseData):
|
||||
conflict = sql.on_duplicate_key_update(
|
||||
user=aime_id, gachaId=gacha_id, **gacha_data
|
||||
)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_user_gacha: Failed to insert! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_user_print_states(
|
||||
async def get_user_print_states(
|
||||
self, aime_id: int, has_completed: bool = False
|
||||
) -> Optional[List[Row]]:
|
||||
sql = print_state.select(
|
||||
@ -544,12 +544,12 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_user_print_states_by_gacha(
|
||||
async def get_user_print_states_by_gacha(
|
||||
self, aime_id: int, gacha_id: int, has_completed: bool = False
|
||||
) -> Optional[List[Row]]:
|
||||
sql = print_state.select(
|
||||
@ -560,16 +560,16 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_user_print_state(self, aime_id: int, **print_data) -> Optional[int]:
|
||||
async def put_user_print_state(self, aime_id: int, **print_data) -> Optional[int]:
|
||||
sql = insert(print_state).values(user=aime_id, **print_data)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(user=aime_id, **print_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -578,7 +578,7 @@ class ChuniItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_user_print_detail(
|
||||
async def put_user_print_detail(
|
||||
self, aime_id: int, serial_id: str, user_print_data: Dict
|
||||
) -> Optional[int]:
|
||||
sql = insert(print_detail).values(
|
||||
@ -586,7 +586,7 @@ class ChuniItemData(BaseData):
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(user=aime_id, **user_print_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
|
@ -395,7 +395,7 @@ team = Table(
|
||||
|
||||
|
||||
class ChuniProfileData(BaseData):
|
||||
def put_profile_data(
|
||||
async def put_profile_data(
|
||||
self, aime_id: int, version: int, profile_data: Dict
|
||||
) -> Optional[int]:
|
||||
profile_data["user"] = aime_id
|
||||
@ -407,26 +407,26 @@ class ChuniProfileData(BaseData):
|
||||
|
||||
sql = insert(profile).values(**profile_data)
|
||||
conflict = sql.on_duplicate_key_update(**profile_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_profile_data: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_preview(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_preview(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = (
|
||||
select([profile, option])
|
||||
.join(option, profile.c.user == option.c.user)
|
||||
.filter(and_(profile.c.user == aime_id, profile.c.version <= version))
|
||||
).order_by(profile.c.version.desc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_data(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_data(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(profile).where(
|
||||
and_(
|
||||
profile.c.user == aime_id,
|
||||
@ -434,12 +434,12 @@ class ChuniProfileData(BaseData):
|
||||
)
|
||||
).order_by(profile.c.version.desc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_data_ex(
|
||||
async def put_profile_data_ex(
|
||||
self, aime_id: int, version: int, profile_ex_data: Dict
|
||||
) -> Optional[int]:
|
||||
profile_ex_data["user"] = aime_id
|
||||
@ -449,7 +449,7 @@ class ChuniProfileData(BaseData):
|
||||
|
||||
sql = insert(profile_ex).values(**profile_ex_data)
|
||||
conflict = sql.on_duplicate_key_update(**profile_ex_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -458,7 +458,7 @@ class ChuniProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_data_ex(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_data_ex(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(profile_ex).where(
|
||||
and_(
|
||||
profile_ex.c.user == aime_id,
|
||||
@ -466,17 +466,17 @@ class ChuniProfileData(BaseData):
|
||||
)
|
||||
).order_by(profile_ex.c.version.desc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_option(self, aime_id: int, option_data: Dict) -> Optional[int]:
|
||||
async def put_profile_option(self, aime_id: int, option_data: Dict) -> Optional[int]:
|
||||
option_data["user"] = aime_id
|
||||
|
||||
sql = insert(option).values(**option_data)
|
||||
conflict = sql.on_duplicate_key_update(**option_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -485,22 +485,22 @@ class ChuniProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_option(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_profile_option(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(option).where(option.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_option_ex(
|
||||
async def put_profile_option_ex(
|
||||
self, aime_id: int, option_ex_data: Dict
|
||||
) -> Optional[int]:
|
||||
option_ex_data["user"] = aime_id
|
||||
|
||||
sql = insert(option_ex).values(**option_ex_data)
|
||||
conflict = sql.on_duplicate_key_update(**option_ex_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -509,15 +509,15 @@ class ChuniProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_option_ex(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_profile_option_ex(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(option_ex).where(option_ex.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_recent_rating(
|
||||
async def put_profile_recent_rating(
|
||||
self, aime_id: int, recent_rating_data: List[Dict]
|
||||
) -> Optional[int]:
|
||||
sql = insert(recent_rating).values(
|
||||
@ -525,7 +525,7 @@ class ChuniProfileData(BaseData):
|
||||
)
|
||||
conflict = sql.on_duplicate_key_update(recentRating=recent_rating_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_recent_rating: Failed to update! aime_id: {aime_id}"
|
||||
@ -533,15 +533,15 @@ class ChuniProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_recent_rating(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_profile_recent_rating(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(recent_rating).where(recent_rating.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_activity(self, aime_id: int, activity_data: Dict) -> Optional[int]:
|
||||
async def put_profile_activity(self, aime_id: int, activity_data: Dict) -> Optional[int]:
|
||||
# The game just uses "id" but we need to distinguish that from the db column "id"
|
||||
activity_data["user"] = aime_id
|
||||
activity_data["activityId"] = activity_data["id"]
|
||||
@ -549,7 +549,7 @@ class ChuniProfileData(BaseData):
|
||||
|
||||
sql = insert(activity).values(**activity_data)
|
||||
conflict = sql.on_duplicate_key_update(**activity_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -558,24 +558,24 @@ class ChuniProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_activity(self, aime_id: int, kind: int) -> Optional[List[Row]]:
|
||||
async def get_profile_activity(self, aime_id: int, kind: int) -> Optional[List[Row]]:
|
||||
sql = (
|
||||
select(activity)
|
||||
.where(and_(activity.c.user == aime_id, activity.c.kind == kind))
|
||||
.order_by(activity.c.sortNumber.desc()) # to get the last played track
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_profile_charge(self, aime_id: int, charge_data: Dict) -> Optional[int]:
|
||||
async def put_profile_charge(self, aime_id: int, charge_data: Dict) -> Optional[int]:
|
||||
charge_data["user"] = aime_id
|
||||
|
||||
sql = insert(charge).values(**charge_data)
|
||||
conflict = sql.on_duplicate_key_update(**charge_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -584,40 +584,40 @@ class ChuniProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_charge(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_profile_charge(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(charge).where(charge.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def add_profile_region(self, aime_id: int, region_id: int) -> Optional[int]:
|
||||
async def add_profile_region(self, aime_id: int, region_id: int) -> Optional[int]:
|
||||
pass
|
||||
|
||||
def get_profile_regions(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_profile_regions(self, aime_id: int) -> Optional[List[Row]]:
|
||||
pass
|
||||
|
||||
def put_profile_emoney(self, aime_id: int, emoney_data: Dict) -> Optional[int]:
|
||||
async def put_profile_emoney(self, aime_id: int, emoney_data: Dict) -> Optional[int]:
|
||||
emoney_data["user"] = aime_id
|
||||
|
||||
sql = insert(emoney).values(**emoney_data)
|
||||
conflict = sql.on_duplicate_key_update(**emoney_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_emoney(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_profile_emoney(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(emoney).where(emoney.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_profile_overpower(
|
||||
async def put_profile_overpower(
|
||||
self, aime_id: int, overpower_data: Dict
|
||||
) -> Optional[int]:
|
||||
overpower_data["user"] = aime_id
|
||||
@ -625,31 +625,31 @@ class ChuniProfileData(BaseData):
|
||||
sql = insert(overpower).values(**overpower_data)
|
||||
conflict = sql.on_duplicate_key_update(**overpower_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_overpower(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_profile_overpower(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(overpower).where(overpower.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_team_by_id(self, team_id: int) -> Optional[Row]:
|
||||
async def get_team_by_id(self, team_id: int) -> Optional[Row]:
|
||||
sql = select(team).where(team.c.id == team_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_team_rank(self, team_id: int) -> int:
|
||||
async def get_team_rank(self, team_id: int) -> int:
|
||||
# Normal ranking system, likely the one used in the real servers
|
||||
# Query all teams sorted by 'teamPoint'
|
||||
result = self.execute(
|
||||
result = await self.execute(
|
||||
select(team.c.id).order_by(team.c.teamPoint.desc())
|
||||
)
|
||||
|
||||
@ -666,13 +666,13 @@ class ChuniProfileData(BaseData):
|
||||
# RIP scaled team ranking. Gone, but forgotten
|
||||
# def get_team_rank_scaled(self, team_id: int) -> int:
|
||||
|
||||
def update_team(self, team_id: int, team_data: Dict) -> bool:
|
||||
async def update_team(self, team_id: int, team_data: Dict) -> bool:
|
||||
team_data["id"] = team_id
|
||||
|
||||
sql = insert(team).values(**team_data)
|
||||
conflict = sql.on_duplicate_key_update(**team_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -680,16 +680,16 @@ class ChuniProfileData(BaseData):
|
||||
)
|
||||
return False
|
||||
return True
|
||||
def get_rival(self, rival_id: int) -> Optional[Row]:
|
||||
async def get_rival(self, rival_id: int) -> Optional[Row]:
|
||||
sql = select(profile).where(profile.c.user == rival_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
def get_overview(self) -> Dict:
|
||||
async def get_overview(self) -> Dict:
|
||||
# Fetch and add up all the playcounts
|
||||
playcount_sql = self.execute(select(profile.c.playCount))
|
||||
playcount_sql = await self.execute(select(profile.c.playCount))
|
||||
|
||||
if playcount_sql is None:
|
||||
self.logger.warn(
|
||||
|
@ -142,55 +142,55 @@ playlog = Table(
|
||||
|
||||
|
||||
class ChuniScoreData(BaseData):
|
||||
def get_courses(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_courses(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(course).where(course.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_course(self, aime_id: int, course_data: Dict) -> Optional[int]:
|
||||
async def put_course(self, aime_id: int, course_data: Dict) -> Optional[int]:
|
||||
course_data["user"] = aime_id
|
||||
course_data = self.fix_bools(course_data)
|
||||
|
||||
sql = insert(course).values(**course_data)
|
||||
conflict = sql.on_duplicate_key_update(**course_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_scores(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_scores(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(best_score).where(best_score.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_score(self, aime_id: int, score_data: Dict) -> Optional[int]:
|
||||
async def put_score(self, aime_id: int, score_data: Dict) -> Optional[int]:
|
||||
score_data["user"] = aime_id
|
||||
score_data = self.fix_bools(score_data)
|
||||
|
||||
sql = insert(best_score).values(**score_data)
|
||||
conflict = sql.on_duplicate_key_update(**score_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_playlogs(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_playlogs(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(playlog).where(playlog.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_playlog(self, aime_id: int, playlog_data: Dict, version: int) -> Optional[int]:
|
||||
async def put_playlog(self, aime_id: int, playlog_data: Dict, version: int) -> Optional[int]:
|
||||
# Calculate the ROM version that should be inserted into the DB, based on the version of the ggame being inserted
|
||||
# We only need from Version 10 (Plost) and back, as newer versions include romVersion in their upsert
|
||||
# This matters both for gameRankings, as well as a future DB update to keep version data separate
|
||||
@ -216,12 +216,12 @@ class ChuniScoreData(BaseData):
|
||||
sql = insert(playlog).values(**playlog_data)
|
||||
conflict = sql.on_duplicate_key_update(**playlog_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_rankings(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_rankings(self, version: int) -> Optional[List[Dict]]:
|
||||
# Calculates the ROM version that should be fetched for rankings, based on the game version being retrieved
|
||||
# This prevents tracks that are not accessible in your version from counting towards the 10 results
|
||||
romVer = {
|
||||
@ -241,7 +241,7 @@ class ChuniScoreData(BaseData):
|
||||
0: "1.00%"
|
||||
}
|
||||
sql = select([playlog.c.musicId.label('id'), func.count(playlog.c.musicId).label('point')]).where((playlog.c.level != 4) & (playlog.c.romVersion.like(romVer.get(version, "%")))).group_by(playlog.c.musicId).order_by(func.count(playlog.c.musicId).desc()).limit(10)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
@ -249,10 +249,10 @@ class ChuniScoreData(BaseData):
|
||||
rows = result.fetchall()
|
||||
return [dict(row) for row in rows]
|
||||
|
||||
def get_rival_music(self, rival_id: int) -> Optional[List[Dict]]:
|
||||
async def get_rival_music(self, rival_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(best_score).where(best_score.c.user == rival_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -175,7 +175,7 @@ login_bonus = Table(
|
||||
|
||||
|
||||
class ChuniStaticData(BaseData):
|
||||
def put_login_bonus(
|
||||
async def put_login_bonus(
|
||||
self,
|
||||
version: int,
|
||||
preset_id: int,
|
||||
@ -207,12 +207,12 @@ class ChuniStaticData(BaseData):
|
||||
loginBonusCategoryType=login_bonus_category_type,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_login_bonus(
|
||||
async def get_login_bonus(
|
||||
self,
|
||||
version: int,
|
||||
preset_id: int,
|
||||
@ -224,12 +224,12 @@ class ChuniStaticData(BaseData):
|
||||
)
|
||||
).order_by(login_bonus.c.needLoginDayCount.desc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_login_bonus_by_required_days(
|
||||
async def get_login_bonus_by_required_days(
|
||||
self, version: int, preset_id: int, need_login_day_count: int
|
||||
) -> Optional[Row]:
|
||||
sql = login_bonus.select(
|
||||
@ -240,12 +240,12 @@ class ChuniStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_login_bonus_preset(
|
||||
async def put_login_bonus_preset(
|
||||
self, version: int, preset_id: int, preset_name: str, is_enabled: bool
|
||||
) -> Optional[int]:
|
||||
sql = insert(login_bonus_preset).values(
|
||||
@ -259,12 +259,12 @@ class ChuniStaticData(BaseData):
|
||||
presetName=preset_name, isEnabled=is_enabled
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_login_bonus_presets(
|
||||
async def get_login_bonus_presets(
|
||||
self, version: int, is_enabled: bool = True
|
||||
) -> Optional[List[Row]]:
|
||||
sql = login_bonus_preset.select(
|
||||
@ -274,12 +274,12 @@ class ChuniStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_event(
|
||||
async def put_event(
|
||||
self, version: int, event_id: int, type: int, name: str
|
||||
) -> Optional[int]:
|
||||
sql = insert(events).values(
|
||||
@ -288,19 +288,19 @@ class ChuniStaticData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(name=name)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def update_event(
|
||||
async def update_event(
|
||||
self, version: int, event_id: int, enabled: bool
|
||||
) -> Optional[bool]:
|
||||
sql = events.update(
|
||||
and_(events.c.version == version, events.c.eventId == event_id)
|
||||
).values(enabled=enabled)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"update_event: failed to update event! version: {version}, event_id: {event_id}, enabled: {enabled}"
|
||||
@ -315,35 +315,35 @@ class ChuniStaticData(BaseData):
|
||||
return None
|
||||
return event["enabled"]
|
||||
|
||||
def get_event(self, version: int, event_id: int) -> Optional[Row]:
|
||||
async def get_event(self, version: int, event_id: int) -> Optional[Row]:
|
||||
sql = select(events).where(
|
||||
and_(events.c.version == version, events.c.eventId == event_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_enabled_events(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_events(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(events).where(
|
||||
and_(events.c.version == version, events.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_events(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_events(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(events).where(events.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_music(
|
||||
async def put_music(
|
||||
self,
|
||||
version: int,
|
||||
song_id: int,
|
||||
@ -376,12 +376,12 @@ class ChuniStaticData(BaseData):
|
||||
worldsEndTag=we_tag,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_charge(
|
||||
async def put_charge(
|
||||
self,
|
||||
version: int,
|
||||
charge_id: int,
|
||||
@ -406,38 +406,38 @@ class ChuniStaticData(BaseData):
|
||||
sellingAppeal=selling_appeal,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_enabled_charges(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_charges(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(charge).where(
|
||||
and_(charge.c.version == version, charge.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_charges(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_charges(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(charge).where(charge.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_music(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_music(self, version: int) -> Optional[List[Row]]:
|
||||
sql = music.select(music.c.version <= version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_music_chart(
|
||||
async def get_music_chart(
|
||||
self, version: int, song_id: int, chart_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(music).where(
|
||||
@ -448,21 +448,21 @@ class ChuniStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_song(self, music_id: int) -> Optional[Row]:
|
||||
async def get_song(self, music_id: int) -> Optional[Row]:
|
||||
sql = music.select(music.c.id == music_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
|
||||
def put_avatar(
|
||||
async def put_avatar(
|
||||
self,
|
||||
version: int,
|
||||
avatarAccessoryId: int,
|
||||
@ -487,12 +487,12 @@ class ChuniStaticData(BaseData):
|
||||
texturePath=texturePath,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_gacha(
|
||||
async def put_gacha(
|
||||
self,
|
||||
version: int,
|
||||
gacha_id: int,
|
||||
@ -513,33 +513,33 @@ class ChuniStaticData(BaseData):
|
||||
**gacha_data,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert gacha! gacha_id {gacha_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_gachas(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_gachas(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = gachas.select(gachas.c.version <= version).order_by(
|
||||
gachas.c.gachaId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_gacha(self, version: int, gacha_id: int) -> Optional[Dict]:
|
||||
async def get_gacha(self, version: int, gacha_id: int) -> Optional[Dict]:
|
||||
sql = gachas.select(
|
||||
and_(gachas.c.version <= version, gachas.c.gachaId == gacha_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_gacha_card(
|
||||
async def put_gacha_card(
|
||||
self, gacha_id: int, card_id: int, **gacha_card
|
||||
) -> Optional[int]:
|
||||
sql = insert(gacha_cards).values(gachaId=gacha_id, cardId=card_id, **gacha_card)
|
||||
@ -548,21 +548,21 @@ class ChuniStaticData(BaseData):
|
||||
gachaId=gacha_id, cardId=card_id, **gacha_card
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert gacha card! gacha_id {gacha_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_gacha_cards(self, gacha_id: int) -> Optional[List[Dict]]:
|
||||
async def get_gacha_cards(self, gacha_id: int) -> Optional[List[Dict]]:
|
||||
sql = gacha_cards.select(gacha_cards.c.gachaId == gacha_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_gacha_card_by_character(
|
||||
async def get_gacha_card_by_character(
|
||||
self, gacha_id: int, chara_id: int
|
||||
) -> Optional[Dict]:
|
||||
sql_sub = (
|
||||
@ -574,26 +574,26 @@ class ChuniStaticData(BaseData):
|
||||
and_(gacha_cards.c.gachaId == gacha_id, gacha_cards.c.cardId == sql_sub)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_card(self, version: int, card_id: int, **card_data) -> Optional[int]:
|
||||
async def put_card(self, version: int, card_id: int, **card_data) -> Optional[int]:
|
||||
sql = insert(cards).values(version=version, cardId=card_id, **card_data)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**card_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert card! card_id {card_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_card(self, version: int, card_id: int) -> Optional[Dict]:
|
||||
async def get_card(self, version: int, card_id: int) -> Optional[Dict]:
|
||||
sql = cards.select(and_(cards.c.version <= version, cards.c.cardId == card_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
@ -50,7 +50,7 @@ class CardMakerReader(BaseReader):
|
||||
):
|
||||
return f"{root}/{dir}"
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
static_datas = {
|
||||
"static_gachas.csv": "read_ongeki_gacha_csv",
|
||||
"static_gacha_cards.csv": "read_ongeki_gacha_card_csv",
|
||||
@ -66,7 +66,7 @@ class CardMakerReader(BaseReader):
|
||||
for file, func in static_datas.items():
|
||||
if os.path.exists(f"{self.bin_dir}/MU3/{file}"):
|
||||
read_csv = getattr(CardMakerReader, func)
|
||||
read_csv(self, f"{self.bin_dir}/MU3/{file}")
|
||||
await read_csv(self, f"{self.bin_dir}/MU3/{file}")
|
||||
else:
|
||||
self.logger.warning(
|
||||
f"Couldn't find {file} file in {self.bin_dir}, skipping"
|
||||
@ -78,12 +78,12 @@ class CardMakerReader(BaseReader):
|
||||
# ONGEKI (MU3) cnnot easily access the bin data(A000.pac)
|
||||
# so only opt_dir will work for now
|
||||
for dir in data_dirs:
|
||||
self.read_chuni_card(f"{dir}/CHU/card")
|
||||
self.read_chuni_gacha(f"{dir}/CHU/gacha")
|
||||
self.read_mai2_card(f"{dir}/MAI/card")
|
||||
self.read_ongeki_gacha(f"{dir}/MU3/gacha")
|
||||
await self.read_chuni_card(f"{dir}/CHU/card")
|
||||
await self.read_chuni_gacha(f"{dir}/CHU/gacha")
|
||||
await self.read_mai2_card(f"{dir}/MAI/card")
|
||||
await self.read_ongeki_gacha(f"{dir}/MU3/gacha")
|
||||
|
||||
def read_chuni_card(self, base_dir: str) -> None:
|
||||
async def read_chuni_card(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading cards from {base_dir}...")
|
||||
|
||||
version_ids = {
|
||||
@ -114,7 +114,7 @@ class CardMakerReader(BaseReader):
|
||||
chain = int(troot.find("chain").text)
|
||||
skill_name = troot.find("skillName").text
|
||||
|
||||
self.chuni_data.static.put_card(
|
||||
await self.chuni_data.static.put_card(
|
||||
version,
|
||||
card_id,
|
||||
charaName=chara_name,
|
||||
@ -131,7 +131,7 @@ class CardMakerReader(BaseReader):
|
||||
|
||||
self.logger.info(f"Added chuni card {card_id}")
|
||||
|
||||
def read_chuni_gacha(self, base_dir: str) -> None:
|
||||
async def read_chuni_gacha(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading gachas from {base_dir}...")
|
||||
|
||||
version_ids = {
|
||||
@ -158,7 +158,7 @@ class CardMakerReader(BaseReader):
|
||||
True if troot.find("ceilingType").text == "1" else False
|
||||
)
|
||||
|
||||
self.chuni_data.static.put_gacha(
|
||||
await self.chuni_data.static.put_gacha(
|
||||
version,
|
||||
gacha_id,
|
||||
name,
|
||||
@ -181,7 +181,7 @@ class CardMakerReader(BaseReader):
|
||||
True if gacha_card.find("pickup").text == "1" else False
|
||||
)
|
||||
|
||||
self.chuni_data.static.put_gacha_card(
|
||||
await self.chuni_data.static.put_gacha_card(
|
||||
gacha_id,
|
||||
card_id,
|
||||
weight=weight,
|
||||
@ -193,7 +193,7 @@ class CardMakerReader(BaseReader):
|
||||
f"Added chuni card {card_id} to gacha {gacha_id}"
|
||||
)
|
||||
|
||||
def read_mai2_card(self, base_dir: str) -> None:
|
||||
async def read_mai2_card(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading cards from {base_dir}...")
|
||||
|
||||
version_ids = {
|
||||
@ -231,18 +231,18 @@ class CardMakerReader(BaseReader):
|
||||
False if re.search(r"\d{2}/\d{2}/\d{2}", name) else enabled
|
||||
)
|
||||
|
||||
self.mai2_data.static.put_card(
|
||||
await self.mai2_data.static.put_card(
|
||||
version, card_id, name, enabled=enabled
|
||||
)
|
||||
self.logger.info(f"Added mai2 card {card_id}")
|
||||
|
||||
def read_ongeki_gacha_csv(self, file_path: str) -> None:
|
||||
async def read_ongeki_gacha_csv(self, file_path: str) -> None:
|
||||
self.logger.info(f"Reading gachas from {file_path}...")
|
||||
|
||||
with open(file_path, encoding="utf-8") as f:
|
||||
reader = csv.DictReader(f)
|
||||
for row in reader:
|
||||
self.ongeki_data.static.put_gacha(
|
||||
await self.ongeki_data.static.put_gacha(
|
||||
row["version"],
|
||||
row["gachaId"],
|
||||
row["gachaName"],
|
||||
@ -254,13 +254,13 @@ class CardMakerReader(BaseReader):
|
||||
|
||||
self.logger.info(f"Added ongeki gacha {row['gachaId']}")
|
||||
|
||||
def read_ongeki_gacha_card_csv(self, file_path: str) -> None:
|
||||
async def read_ongeki_gacha_card_csv(self, file_path: str) -> None:
|
||||
self.logger.info(f"Reading gacha cards from {file_path}...")
|
||||
|
||||
with open(file_path, encoding="utf-8") as f:
|
||||
reader = csv.DictReader(f)
|
||||
for row in reader:
|
||||
self.ongeki_data.static.put_gacha_card(
|
||||
await self.ongeki_data.static.put_gacha_card(
|
||||
row["gachaId"],
|
||||
row["cardId"],
|
||||
rarity=row["rarity"],
|
||||
@ -271,7 +271,7 @@ class CardMakerReader(BaseReader):
|
||||
|
||||
self.logger.info(f"Added ongeki card {row['cardId']} to gacha")
|
||||
|
||||
def read_ongeki_gacha(self, base_dir: str) -> None:
|
||||
async def read_ongeki_gacha(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading gachas from {base_dir}...")
|
||||
|
||||
# assuming some GachaKinds based on the GachaType
|
||||
@ -294,7 +294,7 @@ class CardMakerReader(BaseReader):
|
||||
|
||||
# skip already existing gachas
|
||||
if (
|
||||
self.ongeki_data.static.get_gacha(
|
||||
await self.ongeki_data.static.get_gacha(
|
||||
OngekiConstants.VER_ONGEKI_BRIGHT_MEMORY, gacha_id
|
||||
)
|
||||
is not None
|
||||
@ -320,7 +320,7 @@ class CardMakerReader(BaseReader):
|
||||
is_ceiling = 1
|
||||
max_select_point = 33
|
||||
|
||||
self.ongeki_data.static.put_gacha(
|
||||
await self.ongeki_data.static.put_gacha(
|
||||
version,
|
||||
gacha_id,
|
||||
name,
|
||||
|
@ -35,7 +35,7 @@ class CxbBase:
|
||||
return {"data": []}
|
||||
|
||||
async def handle_auth_usercheck_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_index(
|
||||
profile = await self.data.profile.get_profile_index(
|
||||
0, data["usercheck"]["authid"], self.version
|
||||
)
|
||||
if profile is not None:
|
||||
@ -50,7 +50,7 @@ class CxbBase:
|
||||
return {"token": data["entry"]["authid"], "uid": data["entry"]["authid"]}
|
||||
|
||||
async def handle_auth_login_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_index(
|
||||
profile = await self.data.profile.get_profile_index(
|
||||
0, data["login"]["authid"], self.version
|
||||
)
|
||||
|
||||
@ -204,8 +204,8 @@ class CxbBase:
|
||||
uid = data["loadrange"]["uid"]
|
||||
|
||||
self.logger.info(f"Load data for {uid}")
|
||||
profile = self.data.profile.get_profile(uid, self.version)
|
||||
songs = self.data.score.get_best_scores(uid)
|
||||
profile = await self.data.profile.get_profile(uid, self.version)
|
||||
songs = await self.data.score.get_best_scores(uid)
|
||||
|
||||
data1 = []
|
||||
index = []
|
||||
@ -271,7 +271,7 @@ class CxbBase:
|
||||
thread_ScoreData = Thread(target=CxbBase.task_generateScoreData(song, index, data1))
|
||||
thread_ScoreData.start()
|
||||
|
||||
v_profile = self.data.profile.get_profile_index(0, uid, self.version)
|
||||
v_profile = await self.data.profile.get_profile_index(0, uid, self.version)
|
||||
v_profile_data = v_profile["data"]
|
||||
|
||||
for _, data in enumerate(profile):
|
||||
@ -300,11 +300,11 @@ class CxbBase:
|
||||
|
||||
for value in data["saveindex"]["data"]:
|
||||
if "playedUserId" in value[1]:
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
data["saveindex"]["uid"], self.version, value[0], value[1]
|
||||
)
|
||||
if "mcode" not in value[1]:
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
data["saveindex"]["uid"], self.version, value[0], value[1]
|
||||
)
|
||||
if "shopId" in value:
|
||||
@ -335,7 +335,7 @@ class CxbBase:
|
||||
"index": value[0],
|
||||
}
|
||||
)
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
data["saveindex"]["uid"],
|
||||
song_json["mcode"],
|
||||
self.version,
|
||||
@ -360,32 +360,32 @@ class CxbBase:
|
||||
|
||||
for index, value in enumerate(data["saveindex"]["data"]):
|
||||
if int(data["saveindex"]["index"][index]) == 101:
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
aimeId, self.version, data["saveindex"]["index"][index], value
|
||||
)
|
||||
if (
|
||||
int(data["saveindex"]["index"][index]) >= 700000
|
||||
and int(data["saveindex"]["index"][index]) <= 701000
|
||||
):
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
aimeId, self.version, data["saveindex"]["index"][index], value
|
||||
)
|
||||
if (
|
||||
int(data["saveindex"]["index"][index]) >= 500
|
||||
and int(data["saveindex"]["index"][index]) <= 510
|
||||
):
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
aimeId, self.version, data["saveindex"]["index"][index], value
|
||||
)
|
||||
if "playedUserId" in value:
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
aimeId,
|
||||
self.version,
|
||||
data["saveindex"]["index"][index],
|
||||
json.loads(value),
|
||||
)
|
||||
if "mcode" not in value and "normalCR" not in value:
|
||||
self.data.profile.put_profile(
|
||||
await self.data.profile.put_profile(
|
||||
aimeId,
|
||||
self.version,
|
||||
data["saveindex"]["index"][index],
|
||||
@ -437,7 +437,7 @@ class CxbBase:
|
||||
}
|
||||
)
|
||||
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
aimeId, data1["mcode"], self.version, indexSongList[i], songCode[0]
|
||||
)
|
||||
i += 1
|
||||
@ -446,7 +446,7 @@ class CxbBase:
|
||||
async def handle_action_sprankreq_request(self, data: Dict) -> Dict:
|
||||
uid = data["sprankreq"]["uid"]
|
||||
self.logger.info(f"Get best rankings for {uid}")
|
||||
p = self.data.score.get_best_rankings(uid)
|
||||
p = await self.data.score.get_best_rankings(uid)
|
||||
|
||||
rankList: List[Dict[str, Any]] = []
|
||||
|
||||
@ -492,7 +492,7 @@ class CxbBase:
|
||||
# REV S2
|
||||
if "clear" in rid:
|
||||
try:
|
||||
self.data.score.put_ranking(
|
||||
await self.data.score.put_ranking(
|
||||
user_id=uid,
|
||||
rev_id=int(rid["rid"]),
|
||||
song_id=int(rid["sc"][1]),
|
||||
@ -500,7 +500,7 @@ class CxbBase:
|
||||
clear=rid["clear"],
|
||||
)
|
||||
except Exception:
|
||||
self.data.score.put_ranking(
|
||||
await self.data.score.put_ranking(
|
||||
user_id=uid,
|
||||
rev_id=int(rid["rid"]),
|
||||
song_id=0,
|
||||
@ -510,7 +510,7 @@ class CxbBase:
|
||||
# REV
|
||||
else:
|
||||
try:
|
||||
self.data.score.put_ranking(
|
||||
await self.data.score.put_ranking(
|
||||
user_id=uid,
|
||||
rev_id=int(rid["rid"]),
|
||||
song_id=int(rid["sc"][1]),
|
||||
@ -518,7 +518,7 @@ class CxbBase:
|
||||
clear=0,
|
||||
)
|
||||
except Exception:
|
||||
self.data.score.put_ranking(
|
||||
await self.data.score.put_ranking(
|
||||
user_id=uid,
|
||||
rev_id=int(rid["rid"]),
|
||||
song_id=0,
|
||||
@ -530,12 +530,12 @@ class CxbBase:
|
||||
async def handle_action_addenergy_request(self, data: Dict) -> Dict:
|
||||
uid = data["addenergy"]["uid"]
|
||||
self.logger.info(f"Add energy to user {uid}")
|
||||
profile = self.data.profile.get_profile_index(0, uid, self.version)
|
||||
profile = await self.data.profile.get_profile_index(0, uid, self.version)
|
||||
data1 = profile["data"]
|
||||
p = self.data.item.get_energy(uid)
|
||||
p = await self.data.item.get_energy(uid)
|
||||
|
||||
if not p:
|
||||
self.data.item.put_energy(uid, 5)
|
||||
await self.data.item.put_energy(uid, 5)
|
||||
|
||||
return {
|
||||
"class": data1["myClass"],
|
||||
@ -548,7 +548,7 @@ class CxbBase:
|
||||
energy = p["energy"]
|
||||
|
||||
newenergy = int(energy) + 5
|
||||
self.data.item.put_energy(uid, newenergy)
|
||||
await self.data.item.put_energy(uid, newenergy)
|
||||
|
||||
if int(energy) <= 995:
|
||||
array.append(
|
||||
|
@ -1,6 +1,5 @@
|
||||
from typing import Optional, Dict, List
|
||||
from os import walk, path
|
||||
import urllib
|
||||
from typing import Optional
|
||||
from os import path
|
||||
import csv
|
||||
|
||||
from read import BaseReader
|
||||
@ -8,7 +7,6 @@ from core.config import CoreConfig
|
||||
from titles.cxb.database import CxbData
|
||||
from titles.cxb.const import CxbConstants
|
||||
|
||||
|
||||
class CxbReader(BaseReader):
|
||||
def __init__(
|
||||
self,
|
||||
@ -29,17 +27,14 @@ class CxbReader(BaseReader):
|
||||
self.logger.error(f"Invalid project cxb version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
pull_bin_ram = True
|
||||
async def read(self) -> None:
|
||||
if path.exists(self.bin_dir):
|
||||
await self.read_csv(self.bin_dir)
|
||||
|
||||
else:
|
||||
self.logger.warn(f"{self.bin_dir} does not exist, nothing to import")
|
||||
|
||||
if not path.exists(f"{self.bin_dir}"):
|
||||
self.logger.warning(f"Couldn't find csv file in {self.bin_dir}, skipping")
|
||||
pull_bin_ram = False
|
||||
|
||||
if pull_bin_ram:
|
||||
self.read_csv(f"{self.bin_dir}")
|
||||
|
||||
def read_csv(self, bin_dir: str) -> None:
|
||||
async def read_csv(self, bin_dir: str) -> None:
|
||||
self.logger.info(f"Read csv from {bin_dir}")
|
||||
|
||||
try:
|
||||
@ -55,7 +50,7 @@ class CxbReader(BaseReader):
|
||||
|
||||
if not "N/A" in row["standard"]:
|
||||
self.logger.info(f"Added song {song_id} chart 0")
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
index,
|
||||
@ -71,7 +66,7 @@ class CxbReader(BaseReader):
|
||||
)
|
||||
if not "N/A" in row["hard"]:
|
||||
self.logger.info(f"Added song {song_id} chart 1")
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
index,
|
||||
@ -83,7 +78,7 @@ class CxbReader(BaseReader):
|
||||
)
|
||||
if not "N/A" in row["master"]:
|
||||
self.logger.info(f"Added song {song_id} chart 2")
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
index,
|
||||
@ -97,7 +92,7 @@ class CxbReader(BaseReader):
|
||||
)
|
||||
if not "N/A" in row["unlimited"]:
|
||||
self.logger.info(f"Added song {song_id} chart 3")
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
index,
|
||||
@ -113,7 +108,7 @@ class CxbReader(BaseReader):
|
||||
)
|
||||
if not "N/A" in row["easy"]:
|
||||
self.logger.info(f"Added song {song_id} chart 4")
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
index,
|
||||
|
@ -25,7 +25,7 @@ class CxbRev(CxbBase):
|
||||
score_data = json.loads(data["putlog"]["data"])
|
||||
userid = score_data["usid"]
|
||||
|
||||
self.data.score.put_playlog(
|
||||
await self.data.score.put_playlog(
|
||||
userid,
|
||||
score_data["mcode"],
|
||||
score_data["difficulty"],
|
||||
|
@ -19,12 +19,12 @@ energy = Table(
|
||||
|
||||
|
||||
class CxbItemData(BaseData):
|
||||
def put_energy(self, user_id: int, rev_energy: int) -> Optional[int]:
|
||||
async def put_energy(self, user_id: int, rev_energy: int) -> Optional[int]:
|
||||
sql = insert(energy).values(user=user_id, energy=rev_energy)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(energy=rev_energy)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert item! user: {user_id}, energy: {rev_energy}"
|
||||
@ -33,10 +33,10 @@ class CxbItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_energy(self, user_id: int) -> Optional[Dict]:
|
||||
async def get_energy(self, user_id: int) -> Optional[Dict]:
|
||||
sql = energy.select(and_(energy.c.user == user_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -21,7 +21,7 @@ profile = Table(
|
||||
|
||||
|
||||
class CxbProfileData(BaseData):
|
||||
def put_profile(
|
||||
async def put_profile(
|
||||
self, user_id: int, version: int, index: int, data: JSON
|
||||
) -> Optional[int]:
|
||||
sql = insert(profile).values(
|
||||
@ -30,7 +30,7 @@ class CxbProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(index=index, data=data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to update! user: {user_id}, index: {index}, data: {data}"
|
||||
@ -39,7 +39,7 @@ class CxbProfileData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
async def get_profile(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
"""
|
||||
Given a game version and either a profile or aime id, return the profile
|
||||
"""
|
||||
@ -47,12 +47,12 @@ class CxbProfileData(BaseData):
|
||||
and_(profile.c.version == version, profile.c.user == aime_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_profile_index(
|
||||
async def get_profile_index(
|
||||
self, index: int, aime_id: int = None, version: int = None
|
||||
) -> Optional[Dict]:
|
||||
"""
|
||||
@ -72,7 +72,7 @@ class CxbProfileData(BaseData):
|
||||
)
|
||||
return None
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -58,7 +58,7 @@ ranking = Table(
|
||||
|
||||
|
||||
class CxbScoreData(BaseData):
|
||||
def put_best_score(
|
||||
async def put_best_score(
|
||||
self,
|
||||
user_id: int,
|
||||
song_mcode: str,
|
||||
@ -79,7 +79,7 @@ class CxbScoreData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(data=sql.inserted.data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert best score! profile: {user_id}, song: {song_mcode}, data: {data}"
|
||||
@ -88,7 +88,7 @@ class CxbScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_playlog(
|
||||
async def put_playlog(
|
||||
self,
|
||||
user_id: int,
|
||||
song_mcode: str,
|
||||
@ -125,7 +125,7 @@ class CxbScoreData(BaseData):
|
||||
combo=combo,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert playlog! profile: {user_id}, song: {song_mcode}, chart: {chart_id}"
|
||||
@ -134,7 +134,7 @@ class CxbScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_ranking(
|
||||
async def put_ranking(
|
||||
self, user_id: int, rev_id: int, song_id: int, score: int, clear: int
|
||||
) -> Optional[int]:
|
||||
"""
|
||||
@ -151,7 +151,7 @@ class CxbScoreData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(score=score)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert ranking log! profile: {user_id}, score: {score}, clear: {clear}"
|
||||
@ -160,28 +160,28 @@ class CxbScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_best_score(self, user_id: int, song_mcode: int) -> Optional[Dict]:
|
||||
async def get_best_score(self, user_id: int, song_mcode: int) -> Optional[Dict]:
|
||||
sql = score.select(
|
||||
and_(score.c.user == user_id, score.c.song_mcode == song_mcode)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_best_scores(self, user_id: int) -> Optional[Dict]:
|
||||
async def get_best_scores(self, user_id: int) -> Optional[Dict]:
|
||||
sql = score.select(score.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_best_rankings(self, user_id: int) -> Optional[List[Dict]]:
|
||||
async def get_best_rankings(self, user_id: int) -> Optional[List[Dict]]:
|
||||
sql = ranking.select(ranking.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -29,7 +29,7 @@ music = Table(
|
||||
|
||||
|
||||
class CxbStaticData(BaseData):
|
||||
def put_music(
|
||||
async def put_music(
|
||||
self,
|
||||
version: int,
|
||||
mcode: str,
|
||||
@ -55,12 +55,12 @@ class CxbStaticData(BaseData):
|
||||
title=title, artist=artist, category=category, level=level
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_music(
|
||||
async def get_music(
|
||||
self, version: int, song_id: Optional[int] = None
|
||||
) -> Optional[List[Row]]:
|
||||
if song_id is None:
|
||||
@ -73,12 +73,12 @@ class CxbStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_music_chart(
|
||||
async def get_music_chart(
|
||||
self, version: int, song_id: int, chart_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(music).where(
|
||||
@ -89,7 +89,7 @@ class CxbStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -128,7 +128,7 @@ class DivaBase:
|
||||
async def handle_shop_catalog_request(self, data: Dict) -> Dict:
|
||||
catalog = ""
|
||||
|
||||
shopList = self.data.static.get_enabled_shops(self.version)
|
||||
shopList = await self.data.static.get_enabled_shops(self.version)
|
||||
if not shopList:
|
||||
with open(r"titles/diva/data/ShopCatalog.dat", encoding="utf-8") as shop:
|
||||
lines = shop.readlines()
|
||||
@ -164,8 +164,8 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_buy_module_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
module = self.data.static.get_enabled_shop(self.version, int(data["mdl_id"]))
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
module = await self.data.static.get_enabled_shop(self.version, int(data["mdl_id"]))
|
||||
|
||||
# make sure module is available to purchase
|
||||
if not module:
|
||||
@ -177,11 +177,11 @@ class DivaBase:
|
||||
|
||||
new_vcld_pts = profile["vcld_pts"] - int(data["mdl_price"])
|
||||
|
||||
self.data.profile.update_profile(profile["user"], vcld_pts=new_vcld_pts)
|
||||
self.data.module.put_module(data["pd_id"], self.version, data["mdl_id"])
|
||||
await self.data.profile.update_profile(profile["user"], vcld_pts=new_vcld_pts)
|
||||
await self.data.module.put_module(data["pd_id"], self.version, data["mdl_id"])
|
||||
|
||||
# generate the mdl_have string
|
||||
mdl_have = self.data.module.get_modules_have_string(data["pd_id"], self.version)
|
||||
mdl_have = await self.data.module.get_modules_have_string(data["pd_id"], self.version)
|
||||
|
||||
response = "&shp_rslt=1"
|
||||
response += f"&mdl_id={data['mdl_id']}"
|
||||
@ -193,7 +193,7 @@ class DivaBase:
|
||||
async def handle_cstmz_itm_ctlg_request(self, data: Dict) -> Dict:
|
||||
catalog = ""
|
||||
|
||||
itemList = self.data.static.get_enabled_items(self.version)
|
||||
itemList = await self.data.static.get_enabled_items(self.version)
|
||||
if not itemList:
|
||||
with open(r"titles/diva/data/ItemCatalog.dat", encoding="utf-8") as item:
|
||||
lines = item.readlines()
|
||||
@ -229,8 +229,8 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_buy_cstmz_itm_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
item = self.data.static.get_enabled_item(
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
item = await self.data.static.get_enabled_item(
|
||||
self.version, int(data["cstmz_itm_id"])
|
||||
)
|
||||
|
||||
@ -245,14 +245,14 @@ class DivaBase:
|
||||
new_vcld_pts = profile["vcld_pts"] - int(data["cstmz_itm_price"])
|
||||
|
||||
# save new Vocaloid Points balance
|
||||
self.data.profile.update_profile(profile["user"], vcld_pts=new_vcld_pts)
|
||||
await self.data.profile.update_profile(profile["user"], vcld_pts=new_vcld_pts)
|
||||
|
||||
self.data.customize.put_customize_item(
|
||||
await self.data.customize.put_customize_item(
|
||||
data["pd_id"], self.version, data["cstmz_itm_id"]
|
||||
)
|
||||
|
||||
# generate the cstmz_itm_have string
|
||||
cstmz_itm_have = self.data.customize.get_customize_items_have_string(
|
||||
cstmz_itm_have = await self.data.customize.get_customize_items_have_string(
|
||||
data["pd_id"], self.version
|
||||
)
|
||||
|
||||
@ -297,7 +297,7 @@ class DivaBase:
|
||||
async def handle_qst_inf_request(self, data: Dict) -> Dict:
|
||||
quest = ""
|
||||
|
||||
questList = self.data.static.get_enabled_quests(self.version)
|
||||
questList = await self.data.static.get_enabled_quests(self.version)
|
||||
if not questList:
|
||||
with open(r"titles/diva/data/QuestInfo.dat", encoding="utf-8") as shop:
|
||||
lines = shop.readlines()
|
||||
@ -381,8 +381,8 @@ class DivaBase:
|
||||
return f""
|
||||
|
||||
async def handle_pre_start_request(self, data: Dict) -> str:
|
||||
profile = self.data.profile.get_profile(data["aime_id"], self.version)
|
||||
profile_shop = self.data.item.get_shop(data["aime_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["aime_id"], self.version)
|
||||
profile_shop = await self.data.item.get_shop(data["aime_id"], self.version)
|
||||
|
||||
if profile is None:
|
||||
return f"&ps_result=-3"
|
||||
@ -422,28 +422,28 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_registration_request(self, data: Dict) -> Dict:
|
||||
self.data.profile.create_profile(
|
||||
await self.data.profile.create_profile(
|
||||
self.version, data["aime_id"], data["player_name"]
|
||||
)
|
||||
return f"&cd_adm_result=1&pd_id={data['aime_id']}"
|
||||
|
||||
async def handle_start_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile_shop = self.data.item.get_shop(data["pd_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile_shop = await self.data.item.get_shop(data["pd_id"], self.version)
|
||||
if profile is None:
|
||||
return
|
||||
|
||||
mdl_have = "F" * 250
|
||||
# generate the mdl_have string if "unlock_all_modules" is disabled
|
||||
if not self.game_config.mods.unlock_all_modules:
|
||||
mdl_have = self.data.module.get_modules_have_string(
|
||||
mdl_have = await self.data.module.get_modules_have_string(
|
||||
data["pd_id"], self.version
|
||||
)
|
||||
|
||||
cstmz_itm_have = "F" * 250
|
||||
# generate the cstmz_itm_have string if "unlock_all_items" is disabled
|
||||
if not self.game_config.mods.unlock_all_items:
|
||||
cstmz_itm_have = self.data.customize.get_customize_items_have_string(
|
||||
cstmz_itm_have = await self.data.customize.get_customize_items_have_string(
|
||||
data["pd_id"], self.version
|
||||
)
|
||||
|
||||
@ -524,7 +524,7 @@ class DivaBase:
|
||||
}
|
||||
|
||||
# get clear status from user scores
|
||||
pv_records = self.data.score.get_best_scores(data["pd_id"])
|
||||
pv_records = await self.data.score.get_best_scores(data["pd_id"])
|
||||
clear_status = "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0"
|
||||
|
||||
if pv_records is not None:
|
||||
@ -586,7 +586,7 @@ class DivaBase:
|
||||
return f""
|
||||
|
||||
async def handle_spend_credit_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
if profile is None:
|
||||
return
|
||||
|
||||
@ -663,30 +663,30 @@ class DivaBase:
|
||||
|
||||
return pv_result
|
||||
|
||||
def task_generateScoreData(self, data: Dict, pd_by_pv_id, song):
|
||||
async def task_generateScoreData(self, data: Dict, pd_by_pv_id, song):
|
||||
|
||||
if int(song) > 0:
|
||||
# the request do not send a edition so just perform a query best score and ranking for each edition.
|
||||
# 0=ORIGINAL, 1=EXTRA
|
||||
pd_db_song_0 = self.data.score.get_best_user_score(
|
||||
pd_db_song_0 = await self.data.score.get_best_user_score(
|
||||
data["pd_id"], int(song), data["difficulty"], edition=0
|
||||
)
|
||||
pd_db_song_1 = self.data.score.get_best_user_score(
|
||||
pd_db_song_1 = await self.data.score.get_best_user_score(
|
||||
data["pd_id"], int(song), data["difficulty"], edition=1
|
||||
)
|
||||
|
||||
pd_db_ranking_0, pd_db_ranking_1 = None, None
|
||||
if pd_db_song_0:
|
||||
pd_db_ranking_0 = self.data.score.get_global_ranking(
|
||||
pd_db_ranking_0 = await self.data.score.get_global_ranking(
|
||||
data["pd_id"], int(song), data["difficulty"], edition=0
|
||||
)
|
||||
|
||||
if pd_db_song_1:
|
||||
pd_db_ranking_1 = self.data.score.get_global_ranking(
|
||||
pd_db_ranking_1 = await self.data.score.get_global_ranking(
|
||||
data["pd_id"], int(song), data["difficulty"], edition=1
|
||||
)
|
||||
|
||||
pd_db_customize = self.data.pv_customize.get_pv_customize(
|
||||
pd_db_customize = await self.data.pv_customize.get_pv_customize(
|
||||
data["pd_id"], int(song)
|
||||
)
|
||||
|
||||
@ -712,7 +712,7 @@ class DivaBase:
|
||||
pd_by_pv_id = []
|
||||
|
||||
for song in song_id:
|
||||
thread_ScoreData = Thread(target=self.task_generateScoreData(data, pd_by_pv_id, song))
|
||||
thread_ScoreData = Thread(target=await self.task_generateScoreData(data, pd_by_pv_id, song))
|
||||
threads.append(thread_ScoreData)
|
||||
|
||||
for x in threads:
|
||||
@ -735,7 +735,7 @@ class DivaBase:
|
||||
return f""
|
||||
|
||||
async def handle_stage_result_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
|
||||
pd_song_list = data["stg_ply_pv_id"].split(",")
|
||||
pd_song_difficulty = data["stg_difficulty"].split(",")
|
||||
@ -753,14 +753,14 @@ class DivaBase:
|
||||
|
||||
for index, value in enumerate(pd_song_list):
|
||||
if "-1" not in pd_song_list[index]:
|
||||
profile_pd_db_song = self.data.score.get_best_user_score(
|
||||
profile_pd_db_song = await self.data.score.get_best_user_score(
|
||||
data["pd_id"],
|
||||
pd_song_list[index],
|
||||
pd_song_difficulty[index],
|
||||
pd_song_edition[index],
|
||||
)
|
||||
if profile_pd_db_song is None:
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
pd_song_list[index],
|
||||
@ -777,7 +777,7 @@ class DivaBase:
|
||||
pd_song_worst_cnt[index],
|
||||
pd_song_max_combo[index],
|
||||
)
|
||||
self.data.score.put_playlog(
|
||||
await self.data.score.put_playlog(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
pd_song_list[index],
|
||||
@ -795,7 +795,7 @@ class DivaBase:
|
||||
pd_song_max_combo[index],
|
||||
)
|
||||
elif int(pd_song_max_score[index]) >= int(profile_pd_db_song["score"]):
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
pd_song_list[index],
|
||||
@ -812,7 +812,7 @@ class DivaBase:
|
||||
pd_song_worst_cnt[index],
|
||||
pd_song_max_combo[index],
|
||||
)
|
||||
self.data.score.put_playlog(
|
||||
await self.data.score.put_playlog(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
pd_song_list[index],
|
||||
@ -830,7 +830,7 @@ class DivaBase:
|
||||
pd_song_max_combo[index],
|
||||
)
|
||||
elif int(pd_song_max_score[index]) != int(profile_pd_db_song["score"]):
|
||||
self.data.score.put_playlog(
|
||||
await self.data.score.put_playlog(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
pd_song_list[index],
|
||||
@ -851,7 +851,7 @@ class DivaBase:
|
||||
# Profile saving based on registration list
|
||||
|
||||
# Calculate new level
|
||||
best_scores = self.data.score.get_best_scores(data["pd_id"])
|
||||
best_scores = await self.data.score.get_best_scores(data["pd_id"])
|
||||
|
||||
total_atn_pnt = 0
|
||||
for best_score in best_scores:
|
||||
@ -865,7 +865,7 @@ class DivaBase:
|
||||
response += f"&lv_pnt_old={int(profile['lv_pnt'])}"
|
||||
|
||||
# update the profile and commit changes to the db
|
||||
self.data.profile.update_profile(
|
||||
await self.data.profile.update_profile(
|
||||
profile["user"],
|
||||
lv_num=new_level,
|
||||
lv_pnt=new_level_pnt,
|
||||
@ -914,15 +914,15 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_end_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
|
||||
self.data.profile.update_profile(
|
||||
await self.data.profile.update_profile(
|
||||
profile["user"], my_qst_id=data["my_qst_id"], my_qst_sts=data["my_qst_sts"]
|
||||
)
|
||||
return f""
|
||||
|
||||
async def handle_shop_exit_request(self, data: Dict) -> Dict:
|
||||
self.data.item.put_shop(
|
||||
await self.data.item.put_shop(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
data["mdl_eqp_cmn_ary"],
|
||||
@ -930,7 +930,7 @@ class DivaBase:
|
||||
data["ms_itm_flg_cmn_ary"],
|
||||
)
|
||||
if int(data["use_pv_mdl_eqp"]) == 1:
|
||||
self.data.pv_customize.put_pv_customize(
|
||||
await self.data.pv_customize.put_pv_customize(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
data["ply_pv_id"],
|
||||
@ -939,7 +939,7 @@ class DivaBase:
|
||||
data["ms_itm_flg_pv_ary"],
|
||||
)
|
||||
else:
|
||||
self.data.pv_customize.put_pv_customize(
|
||||
await self.data.pv_customize.put_pv_customize(
|
||||
data["pd_id"],
|
||||
self.version,
|
||||
data["ply_pv_id"],
|
||||
@ -952,7 +952,7 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_card_procedure_request(self, data: Dict) -> str:
|
||||
profile = self.data.profile.get_profile(data["aime_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["aime_id"], self.version)
|
||||
if profile is None:
|
||||
return "&cd_adm_result=0"
|
||||
|
||||
@ -972,7 +972,7 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_change_name_request(self, data: Dict) -> str:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
|
||||
# make sure user has enough Vocaloid Points
|
||||
if profile["vcld_pts"] < int(data["chg_name_price"]):
|
||||
@ -980,7 +980,7 @@ class DivaBase:
|
||||
|
||||
# update the vocaloid points and player name
|
||||
new_vcld_pts = profile["vcld_pts"] - int(data["chg_name_price"])
|
||||
self.data.profile.update_profile(
|
||||
await self.data.profile.update_profile(
|
||||
profile["user"], player_name=data["player_name"], vcld_pts=new_vcld_pts
|
||||
)
|
||||
|
||||
@ -992,14 +992,14 @@ class DivaBase:
|
||||
return response
|
||||
|
||||
async def handle_change_passwd_request(self, data: Dict) -> str:
|
||||
profile = self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
profile = await self.data.profile.get_profile(data["pd_id"], self.version)
|
||||
|
||||
# TODO: return correct error number instead of 0
|
||||
if data["passwd"] != profile["passwd"]:
|
||||
return "&cd_adm_result=0"
|
||||
|
||||
# set password to true and update the saved password
|
||||
self.data.profile.update_profile(
|
||||
await self.data.profile.update_profile(
|
||||
profile["user"], passwd_stat=1, passwd=data["new_passwd"]
|
||||
)
|
||||
|
||||
|
@ -28,7 +28,7 @@ class DivaReader(BaseReader):
|
||||
self.logger.error(f"Invalid project diva version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
pull_bin_ram = True
|
||||
pull_bin_rom = True
|
||||
pull_opt_rom = True
|
||||
@ -48,14 +48,14 @@ class DivaReader(BaseReader):
|
||||
self.logger.warning("No option directory specified, skipping")
|
||||
|
||||
if pull_bin_ram:
|
||||
self.read_ram(f"{self.bin_dir}/ram")
|
||||
await self.read_ram(f"{self.bin_dir}/ram")
|
||||
if pull_bin_rom:
|
||||
self.read_rom(f"{self.bin_dir}/rom")
|
||||
await self.read_rom(f"{self.bin_dir}/rom")
|
||||
if pull_opt_rom:
|
||||
for dir in opt_dirs:
|
||||
self.read_rom(f"{dir}/rom")
|
||||
await self.read_rom(f"{dir}/rom")
|
||||
|
||||
def read_ram(self, ram_root_dir: str) -> None:
|
||||
async def read_ram(self, ram_root_dir: str) -> None:
|
||||
self.logger.info(f"Read RAM from {ram_root_dir}")
|
||||
|
||||
if path.exists(f"{ram_root_dir}/databank"):
|
||||
@ -91,7 +91,7 @@ class DivaReader(BaseReader):
|
||||
f"Added shop item {split[x+0]}"
|
||||
)
|
||||
|
||||
self.data.static.put_shop(
|
||||
await self.data.static.put_shop(
|
||||
self.version,
|
||||
split[x + 0],
|
||||
split[x + 2],
|
||||
@ -109,7 +109,7 @@ class DivaReader(BaseReader):
|
||||
for x in range(0, len(split), 7):
|
||||
self.logger.info(f"Added item {split[x+0]}")
|
||||
|
||||
self.data.static.put_items(
|
||||
await self.data.static.put_items(
|
||||
self.version,
|
||||
split[x + 0],
|
||||
split[x + 2],
|
||||
@ -123,7 +123,7 @@ class DivaReader(BaseReader):
|
||||
elif file.startswith("QuestInfo") and len(split) >= 9:
|
||||
self.logger.info(f"Added quest {split[0]}")
|
||||
|
||||
self.data.static.put_quests(
|
||||
await self.data.static.put_quests(
|
||||
self.version,
|
||||
split[0],
|
||||
split[6],
|
||||
@ -141,7 +141,7 @@ class DivaReader(BaseReader):
|
||||
else:
|
||||
self.logger.warning(f"Databank folder not found in {ram_root_dir}, skipping")
|
||||
|
||||
def read_rom(self, rom_root_dir: str) -> None:
|
||||
async def read_rom(self, rom_root_dir: str) -> None:
|
||||
self.logger.info(f"Read ROM from {rom_root_dir}")
|
||||
pv_list: Dict[str, Dict] = {}
|
||||
|
||||
@ -199,7 +199,7 @@ class DivaReader(BaseReader):
|
||||
diff = pv_data["difficulty"]["easy"]["0"]["level"].split("_")
|
||||
self.logger.info(f"Added song {song_id} chart 0")
|
||||
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
0,
|
||||
@ -220,7 +220,7 @@ class DivaReader(BaseReader):
|
||||
diff = pv_data["difficulty"]["normal"]["0"]["level"].split("_")
|
||||
self.logger.info(f"Added song {song_id} chart 1")
|
||||
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
1,
|
||||
@ -238,7 +238,7 @@ class DivaReader(BaseReader):
|
||||
diff = pv_data["difficulty"]["hard"]["0"]["level"].split("_")
|
||||
self.logger.info(f"Added song {song_id} chart 2")
|
||||
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
2,
|
||||
@ -257,7 +257,7 @@ class DivaReader(BaseReader):
|
||||
diff = pv_data["difficulty"]["extreme"]["0"]["level"].split("_")
|
||||
self.logger.info(f"Added song {song_id} chart 3")
|
||||
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
3,
|
||||
@ -275,7 +275,7 @@ class DivaReader(BaseReader):
|
||||
diff = pv_data["difficulty"]["extreme"]["1"]["level"].split("_")
|
||||
self.logger.info(f"Added song {song_id} chart 4")
|
||||
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
4,
|
||||
|
@ -25,10 +25,10 @@ customize = Table(
|
||||
|
||||
|
||||
class DivaCustomizeItemData(BaseData):
|
||||
def put_customize_item(self, aime_id: int, version: int, item_id: int) -> None:
|
||||
async def put_customize_item(self, aime_id: int, version: int, item_id: int) -> None:
|
||||
sql = insert(customize).values(version=version, user=aime_id, item_id=item_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} Failed to insert diva profile customize item! aime id: {aime_id} item: {item_id}"
|
||||
@ -36,7 +36,7 @@ class DivaCustomizeItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_customize_items(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
async def get_customize_items(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
"""
|
||||
Given a game version and an aime id, return all the customize items, not used directly
|
||||
"""
|
||||
@ -44,12 +44,12 @@ class DivaCustomizeItemData(BaseData):
|
||||
and_(customize.c.version == version, customize.c.user == aime_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_customize_items_have_string(self, aime_id: int, version: int) -> str:
|
||||
async def get_customize_items_have_string(self, aime_id: int, version: int) -> str:
|
||||
"""
|
||||
Given a game version and an aime id, return the cstmz_itm_have hex string
|
||||
required for diva directly
|
||||
|
@ -26,7 +26,7 @@ shop = Table(
|
||||
|
||||
|
||||
class DivaItemData(BaseData):
|
||||
def put_shop(
|
||||
async def put_shop(
|
||||
self,
|
||||
aime_id: int,
|
||||
version: int,
|
||||
@ -48,7 +48,7 @@ class DivaItemData(BaseData):
|
||||
ms_itm_flg_ary=ms_itm_flg_ary,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} Failed to insert diva profile! aime id: {aime_id} array: {mdl_eqp_ary}"
|
||||
@ -56,13 +56,13 @@ class DivaItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_shop(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
async def get_shop(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
"""
|
||||
Given a game version and either a profile or aime id, return the profile
|
||||
"""
|
||||
sql = shop.select(and_(shop.c.version == version, shop.c.user == aime_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -23,10 +23,10 @@ module = Table(
|
||||
|
||||
|
||||
class DivaModuleData(BaseData):
|
||||
def put_module(self, aime_id: int, version: int, module_id: int) -> None:
|
||||
async def put_module(self, aime_id: int, version: int, module_id: int) -> None:
|
||||
sql = insert(module).values(version=version, user=aime_id, module_id=module_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} Failed to insert diva profile module! aime id: {aime_id} module: {module_id}"
|
||||
@ -34,18 +34,18 @@ class DivaModuleData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_modules(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
async def get_modules(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
"""
|
||||
Given a game version and an aime id, return all the modules, not used directly
|
||||
"""
|
||||
sql = module.select(and_(module.c.version == version, module.c.user == aime_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_modules_have_string(self, aime_id: int, version: int) -> str:
|
||||
async def get_modules_have_string(self, aime_id: int, version: int) -> str:
|
||||
"""
|
||||
Given a game version and an aime id, return the mdl_have hex string
|
||||
required for diva directly
|
||||
|
@ -70,7 +70,7 @@ profile = Table(
|
||||
|
||||
|
||||
class DivaProfileData(BaseData):
|
||||
def create_profile(
|
||||
async def create_profile(
|
||||
self, version: int, aime_id: int, player_name: str
|
||||
) -> Optional[int]:
|
||||
"""
|
||||
@ -82,7 +82,7 @@ class DivaProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(player_name=sql.inserted.player_name)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} Failed to insert diva profile! aime id: {aime_id} username: {player_name}"
|
||||
@ -90,21 +90,21 @@ class DivaProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def update_profile(self, aime_id: int, **profile_args) -> None:
|
||||
async def update_profile(self, aime_id: int, **profile_args) -> None:
|
||||
"""
|
||||
Given an aime_id update the profile corresponding to the arguments
|
||||
which are the diva_profile Columns
|
||||
"""
|
||||
sql = profile.update(profile.c.user == aime_id).values(**profile_args)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"update_profile: failed to update profile! profile: {aime_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def get_profile(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
async def get_profile(self, aime_id: int, version: int) -> Optional[List[Dict]]:
|
||||
"""
|
||||
Given a game version and either a profile or aime id, return the profile
|
||||
"""
|
||||
@ -112,7 +112,7 @@ class DivaProfileData(BaseData):
|
||||
and_(profile.c.version == version, profile.c.user == aime_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -39,7 +39,7 @@ pv_customize = Table(
|
||||
|
||||
|
||||
class DivaPvCustomizeData(BaseData):
|
||||
def put_pv_customize(
|
||||
async def put_pv_customize(
|
||||
self,
|
||||
aime_id: int,
|
||||
version: int,
|
||||
@ -64,7 +64,7 @@ class DivaPvCustomizeData(BaseData):
|
||||
ms_itm_flg_ary=ms_itm_flg_ary,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} Failed to insert diva pv customize! aime id: {aime_id}"
|
||||
@ -72,7 +72,7 @@ class DivaPvCustomizeData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_pv_customize(self, aime_id: int, pv_id: int) -> Optional[List[Dict]]:
|
||||
async def get_pv_customize(self, aime_id: int, pv_id: int) -> Optional[List[Dict]]:
|
||||
"""
|
||||
Given either a profile or aime id, return a Pv Customize row
|
||||
"""
|
||||
@ -80,7 +80,7 @@ class DivaPvCustomizeData(BaseData):
|
||||
and_(pv_customize.c.user == aime_id, pv_customize.c.pv_id == pv_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -57,7 +57,7 @@ playlog = Table(
|
||||
|
||||
|
||||
class DivaScoreData(BaseData):
|
||||
def put_best_score(
|
||||
async def put_best_score(
|
||||
self,
|
||||
user_id: int,
|
||||
game_version: int,
|
||||
@ -109,7 +109,7 @@ class DivaScoreData(BaseData):
|
||||
max_combo=max_combo,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert best score! profile: {user_id}, song: {song_id}"
|
||||
@ -118,7 +118,7 @@ class DivaScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_playlog(
|
||||
async def put_playlog(
|
||||
self,
|
||||
user_id: int,
|
||||
game_version: int,
|
||||
@ -157,7 +157,7 @@ class DivaScoreData(BaseData):
|
||||
max_combo=max_combo,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert playlog! profile: {user_id}, song: {song_id}, chart: {difficulty}"
|
||||
@ -166,7 +166,7 @@ class DivaScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_best_user_score(
|
||||
async def get_best_user_score(
|
||||
self, user_id: int, pv_id: int, difficulty: int, edition: int
|
||||
) -> Optional[Row]:
|
||||
sql = score.select(
|
||||
@ -178,12 +178,12 @@ class DivaScoreData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_top3_scores(
|
||||
async def get_top3_scores(
|
||||
self, pv_id: int, difficulty: int, edition: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = (
|
||||
@ -198,12 +198,12 @@ class DivaScoreData(BaseData):
|
||||
.limit(3)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_global_ranking(
|
||||
async def get_global_ranking(
|
||||
self, user_id: int, pv_id: int, difficulty: int, edition: int
|
||||
) -> Optional[List[Row]]:
|
||||
# get the subquery max score of a user with pv_id, difficulty and
|
||||
@ -227,15 +227,15 @@ class DivaScoreData(BaseData):
|
||||
score.c.edition == edition,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_best_scores(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_best_scores(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = score.select(score.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -83,7 +83,7 @@ items = Table(
|
||||
|
||||
|
||||
class DivaStaticData(BaseData):
|
||||
def put_quests(
|
||||
async def put_quests(
|
||||
self,
|
||||
version: int,
|
||||
questId: int,
|
||||
@ -111,22 +111,22 @@ class DivaStaticData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(name=name)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_enabled_quests(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_quests(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(quests).where(
|
||||
and_(quests.c.version == version, quests.c.quest_enable == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_shop(
|
||||
async def put_shop(
|
||||
self,
|
||||
version: int,
|
||||
shopId: int,
|
||||
@ -150,12 +150,12 @@ class DivaStaticData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(name=name)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_enabled_shop(self, version: int, shopId: int) -> Optional[Row]:
|
||||
async def get_enabled_shop(self, version: int, shopId: int) -> Optional[Row]:
|
||||
sql = select(shop).where(
|
||||
and_(
|
||||
shop.c.version == version,
|
||||
@ -164,22 +164,22 @@ class DivaStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_enabled_shops(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_shops(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(shop).where(
|
||||
and_(shop.c.version == version, shop.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_items(
|
||||
async def put_items(
|
||||
self,
|
||||
version: int,
|
||||
itemId: int,
|
||||
@ -203,12 +203,12 @@ class DivaStaticData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(name=name)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_enabled_item(self, version: int, itemId: int) -> Optional[Row]:
|
||||
async def get_enabled_item(self, version: int, itemId: int) -> Optional[Row]:
|
||||
sql = select(items).where(
|
||||
and_(
|
||||
items.c.version == version,
|
||||
@ -217,22 +217,22 @@ class DivaStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_enabled_items(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_items(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(items).where(
|
||||
and_(items.c.version == version, items.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_music(
|
||||
async def put_music(
|
||||
self,
|
||||
version: int,
|
||||
song: int,
|
||||
@ -271,12 +271,12 @@ class DivaStaticData(BaseData):
|
||||
date=date,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_music(
|
||||
async def get_music(
|
||||
self, version: int, song_id: Optional[int] = None
|
||||
) -> Optional[List[Row]]:
|
||||
if song_id is None:
|
||||
@ -289,12 +289,12 @@ class DivaStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_music_chart(
|
||||
async def get_music_chart(
|
||||
self, version: int, song_id: int, chart_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(music).where(
|
||||
@ -305,7 +305,7 @@ class DivaStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -37,7 +37,7 @@ class IDACFrontend(FE_Base):
|
||||
34: "full_tune_fragments",
|
||||
}
|
||||
|
||||
def generate_all_tables_json(self, user_id: int):
|
||||
async def generate_all_tables_json(self, user_id: int):
|
||||
json_export = {}
|
||||
|
||||
idac_tables = {
|
||||
@ -73,7 +73,7 @@ class IDACFrontend(FE_Base):
|
||||
sql = sql.where(table.c.version == self.version)
|
||||
|
||||
# lol use the profile connection for items, dirty hack
|
||||
result = self.data.profile.execute(sql)
|
||||
result = await self.data.profile.execute(sql)
|
||||
data_list = result.fetchall()
|
||||
|
||||
# add the list to the json export with the correct table name
|
||||
@ -86,7 +86,7 @@ class IDACFrontend(FE_Base):
|
||||
|
||||
return json.dumps(json_export, indent=4, default=str, ensure_ascii=False)
|
||||
|
||||
def render_GET(self, request: Request) -> bytes:
|
||||
async def render_GET(self, request: Request) -> bytes:
|
||||
uri: str = request.uri.decode()
|
||||
|
||||
template = self.environment.get_template(
|
||||
@ -103,7 +103,7 @@ class IDACFrontend(FE_Base):
|
||||
return redirectTo(b"/game/idac", request)
|
||||
|
||||
# set the file name, content type and size to download the json
|
||||
content = self.generate_all_tables_json(user_id).encode("utf-8")
|
||||
content = await self.generate_all_tables_json(user_id).encode("utf-8")
|
||||
request.responseHeaders.addRawHeader(
|
||||
b"content-type", b"application/octet-stream"
|
||||
)
|
||||
@ -119,9 +119,9 @@ class IDACFrontend(FE_Base):
|
||||
|
||||
profile_data, tickets, rank = None, None, None
|
||||
if user_id > 0:
|
||||
profile_data = self.data.profile.get_profile(user_id, self.version)
|
||||
ticket_data = self.data.item.get_tickets(user_id)
|
||||
rank = self.data.profile.get_profile_rank(user_id, self.version)
|
||||
profile_data = await self.data.profile.get_profile(user_id, self.version)
|
||||
ticket_data = await self.data.item.get_tickets(user_id)
|
||||
rank = await self.data.profile.get_profile_rank(user_id, self.version)
|
||||
|
||||
tickets = {
|
||||
self.ticket_names[ticket["ticket_id"]]: ticket["ticket_cnt"]
|
||||
@ -137,6 +137,3 @@ class IDACFrontend(FE_Base):
|
||||
sesh=vars(usr_sesh),
|
||||
active_page="idac",
|
||||
).encode("utf-16")
|
||||
|
||||
def render_POST(self, request: Request) -> bytes:
|
||||
pass
|
||||
|
@ -124,7 +124,7 @@ class IDACServlet(BaseServlet):
|
||||
resp = None
|
||||
try:
|
||||
handler = getattr(self.versions[internal_ver], func_to_find)
|
||||
resp = handler(req_data, header_application)
|
||||
resp = await handler(req_data, header_application)
|
||||
|
||||
except Exception as e:
|
||||
traceback.print_exc()
|
||||
|
@ -33,7 +33,7 @@ class IDACReader(BaseReader):
|
||||
self.logger.error(f"Invalid Initial D THE ARCADE version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
if self.bin_dir is None and self.opt_dir is None:
|
||||
self.logger.error(
|
||||
(
|
||||
@ -59,9 +59,9 @@ class IDACReader(BaseReader):
|
||||
)
|
||||
exit(1)
|
||||
|
||||
self.read_idac_profile(self.opt_dir)
|
||||
await self.read_idac_profile(self.opt_dir)
|
||||
|
||||
def read_idac_profile(self, file_path: str) -> None:
|
||||
async def read_idac_profile(self, file_path: str) -> None:
|
||||
self.logger.info(f"Reading profile from {file_path}...")
|
||||
|
||||
# read it as binary to avoid encoding issues
|
||||
@ -88,14 +88,14 @@ class IDACReader(BaseReader):
|
||||
self.logger.info("Exiting...")
|
||||
exit(0)
|
||||
|
||||
user_id = self.data.user.create_user()
|
||||
user_id = await self.data.user.create_user()
|
||||
|
||||
if user_id is None:
|
||||
self.logger.error("Failed to register user!")
|
||||
user_id = -1
|
||||
|
||||
else:
|
||||
card_id = self.data.card.create_card(user_id, access_code)
|
||||
card_id = await self.data.card.create_card(user_id, access_code)
|
||||
|
||||
if card_id is None:
|
||||
self.logger.error("Failed to register card!")
|
||||
@ -150,7 +150,7 @@ class IDACReader(BaseReader):
|
||||
|
||||
# lol use the profile connection for items, dirty hack
|
||||
conflict = sql.on_duplicate_key_update(**data)
|
||||
result = self.data.profile.execute(conflict)
|
||||
result = await self.data.profile.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to insert data into table {name}")
|
||||
|
@ -297,7 +297,7 @@ timetrial_event = Table(
|
||||
|
||||
|
||||
class IDACItemData(BaseData):
|
||||
def get_random_user_car(self, aime_id: int, version: int) -> Optional[List[Row]]:
|
||||
async def get_random_user_car(self, aime_id: int, version: int) -> Optional[List[Row]]:
|
||||
sql = (
|
||||
select(car)
|
||||
.where(and_(car.c.user == aime_id, car.c.version == version))
|
||||
@ -305,20 +305,20 @@ class IDACItemData(BaseData):
|
||||
.limit(1)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_random_car(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_random_car(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(car).where(car.c.version == version).order_by(func.rand()).limit(1)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_car(
|
||||
async def get_car(
|
||||
self, aime_id: int, version: int, style_car_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(car).where(
|
||||
@ -329,12 +329,12 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_cars(
|
||||
async def get_cars(
|
||||
self, version: int, aime_id: int, only_pickup: bool = False
|
||||
) -> Optional[List[Row]]:
|
||||
if only_pickup:
|
||||
@ -350,106 +350,106 @@ class IDACItemData(BaseData):
|
||||
and_(car.c.user == aime_id, car.c.version == version)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_ticket(self, aime_id: int, ticket_id: int) -> Optional[Row]:
|
||||
async def get_ticket(self, aime_id: int, ticket_id: int) -> Optional[Row]:
|
||||
sql = select(ticket).where(
|
||||
ticket.c.user == aime_id, ticket.c.ticket_id == ticket_id
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_tickets(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_tickets(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(ticket).where(ticket.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_story(self, aime_id: int, chapter_id: int) -> Optional[Row]:
|
||||
async def get_story(self, aime_id: int, chapter_id: int) -> Optional[Row]:
|
||||
sql = select(story).where(
|
||||
and_(story.c.user == aime_id, story.c.chapter == chapter_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_stories(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_stories(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(story).where(story.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_story_episodes(self, aime_id: int, chapter_id: int) -> Optional[List[Row]]:
|
||||
async def get_story_episodes(self, aime_id: int, chapter_id: int) -> Optional[List[Row]]:
|
||||
sql = select(episode).where(
|
||||
and_(episode.c.user == aime_id, episode.c.chapter == chapter_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_story_episode(self, aime_id: int, episode_id: int) -> Optional[Row]:
|
||||
async def get_story_episode(self, aime_id: int, episode_id: int) -> Optional[Row]:
|
||||
sql = select(episode).where(
|
||||
and_(episode.c.user == aime_id, episode.c.episode == episode_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_story_episode_difficulties(
|
||||
async def get_story_episode_difficulties(
|
||||
self, aime_id: int, episode_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(difficulty).where(
|
||||
and_(difficulty.c.user == aime_id, difficulty.c.episode == episode_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_courses(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_courses(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(course).where(course.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_course(self, aime_id: int, course_id: int) -> Optional[Row]:
|
||||
async def get_course(self, aime_id: int, course_id: int) -> Optional[Row]:
|
||||
sql = select(course).where(
|
||||
and_(course.c.user == aime_id, course.c.course_id == course_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_time_trial_courses(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_time_trial_courses(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(trial.c.course_id).where(trial.c.version == version).distinct()
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_time_trial_user_best_time_by_course_car(
|
||||
async def get_time_trial_user_best_time_by_course_car(
|
||||
self, version: int, aime_id: int, course_id: int, style_car_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = select(trial).where(
|
||||
@ -461,12 +461,12 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_time_trial_user_best_courses(
|
||||
async def get_time_trial_user_best_courses(
|
||||
self, version: int, aime_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
# get for a given aime_id the best time for each course
|
||||
@ -491,12 +491,12 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_time_trial_best_cars_by_course(
|
||||
async def get_time_trial_best_cars_by_course(
|
||||
self, version: int, course_id: int, aime_id: Optional[int] = None
|
||||
) -> Optional[List[Row]]:
|
||||
subquery = (
|
||||
@ -527,12 +527,12 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_time_trial_ranking_by_course(
|
||||
async def get_time_trial_ranking_by_course(
|
||||
self,
|
||||
version: int,
|
||||
course_id: int,
|
||||
@ -568,12 +568,12 @@ class IDACItemData(BaseData):
|
||||
if limit is not None:
|
||||
sql = sql.limit(limit)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_time_trial_best_ranking_by_course(
|
||||
async def get_time_trial_best_ranking_by_course(
|
||||
self, version: int, aime_id: int, course_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = (
|
||||
@ -589,12 +589,12 @@ class IDACItemData(BaseData):
|
||||
.limit(1)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_challenge(
|
||||
async def get_challenge(
|
||||
self, aime_id: int, vs_type: int, play_difficulty: int
|
||||
) -> Optional[Row]:
|
||||
sql = select(challenge).where(
|
||||
@ -605,20 +605,20 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_challenges(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_challenges(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(challenge).where(challenge.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_best_challenges_by_vs_type(
|
||||
async def get_best_challenges_by_vs_type(
|
||||
self, aime_id: int, story_type: int = 4
|
||||
) -> Optional[List[Row]]:
|
||||
subquery = (
|
||||
@ -653,20 +653,20 @@ class IDACItemData(BaseData):
|
||||
.order_by(challenge.c.vs_type)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_theory_courses(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_theory_courses(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(theory_course).where(theory_course.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_theory_course_by_powerhouse_lv(
|
||||
async def get_theory_course_by_powerhouse_lv(
|
||||
self, aime_id: int, course_id: int, powerhouse_lv: int, count: int = 3
|
||||
) -> Optional[List[Row]]:
|
||||
sql = (
|
||||
@ -682,40 +682,40 @@ class IDACItemData(BaseData):
|
||||
.limit(count)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_theory_course(self, aime_id: int, course_id: int) -> Optional[List[Row]]:
|
||||
async def get_theory_course(self, aime_id: int, course_id: int) -> Optional[List[Row]]:
|
||||
sql = select(theory_course).where(
|
||||
and_(
|
||||
theory_course.c.user == aime_id, theory_course.c.course_id == course_id
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_theory_partners(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_theory_partners(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(theory_partner).where(theory_partner.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_theory_running(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_theory_running(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(theory_running).where(theory_running.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_theory_running_by_course(
|
||||
async def get_theory_running_by_course(
|
||||
self, aime_id: int, course_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = select(theory_running).where(
|
||||
@ -725,32 +725,32 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_vs_infos(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_vs_infos(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(vs_info).where(vs_info.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_stamps(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_stamps(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(stamp).where(
|
||||
and_(
|
||||
stamp.c.user == aime_id,
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_timetrial_event(self, aime_id: int, timetrial_event_id: int) -> Optional[Row]:
|
||||
async def get_timetrial_event(self, aime_id: int, timetrial_event_id: int) -> Optional[Row]:
|
||||
sql = select(timetrial_event).where(
|
||||
and_(
|
||||
timetrial_event.c.user == aime_id,
|
||||
@ -758,49 +758,49 @@ class IDACItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_car(self, aime_id: int, version: int, car_data: Dict) -> Optional[int]:
|
||||
async def put_car(self, aime_id: int, version: int, car_data: Dict) -> Optional[int]:
|
||||
car_data["user"] = aime_id
|
||||
car_data["version"] = version
|
||||
|
||||
sql = insert(car).values(**car_data)
|
||||
conflict = sql.on_duplicate_key_update(**car_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_car: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_ticket(self, aime_id: int, ticket_data: Dict) -> Optional[int]:
|
||||
async def put_ticket(self, aime_id: int, ticket_data: Dict) -> Optional[int]:
|
||||
ticket_data["user"] = aime_id
|
||||
|
||||
sql = insert(ticket).values(**ticket_data)
|
||||
conflict = sql.on_duplicate_key_update(**ticket_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_ticket: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_story(self, aime_id: int, story_data: Dict) -> Optional[int]:
|
||||
async def put_story(self, aime_id: int, story_data: Dict) -> Optional[int]:
|
||||
story_data["user"] = aime_id
|
||||
|
||||
sql = insert(story).values(**story_data)
|
||||
conflict = sql.on_duplicate_key_update(**story_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_story: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_story_episode_play_status(
|
||||
async def put_story_episode_play_status(
|
||||
self, aime_id: int, chapter_id: int, play_status: int = 1
|
||||
) -> Optional[int]:
|
||||
sql = (
|
||||
@ -809,7 +809,7 @@ class IDACItemData(BaseData):
|
||||
.values(play_status=play_status)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
f"put_story_episode_play_status: Failed to update! aime_id: {aime_id}"
|
||||
@ -817,7 +817,7 @@ class IDACItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_story_episode(
|
||||
async def put_story_episode(
|
||||
self, aime_id: int, chapter_id: int, episode_data: Dict
|
||||
) -> Optional[int]:
|
||||
episode_data["user"] = aime_id
|
||||
@ -825,14 +825,14 @@ class IDACItemData(BaseData):
|
||||
|
||||
sql = insert(episode).values(**episode_data)
|
||||
conflict = sql.on_duplicate_key_update(**episode_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_story_episode: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_story_episode_difficulty(
|
||||
async def put_story_episode_difficulty(
|
||||
self, aime_id: int, episode_id: int, difficulty_data: Dict
|
||||
) -> Optional[int]:
|
||||
difficulty_data["user"] = aime_id
|
||||
@ -840,7 +840,7 @@ class IDACItemData(BaseData):
|
||||
|
||||
sql = insert(difficulty).values(**difficulty_data)
|
||||
conflict = sql.on_duplicate_key_update(**difficulty_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -849,19 +849,19 @@ class IDACItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_course(self, aime_id: int, course_data: Dict) -> Optional[int]:
|
||||
async def put_course(self, aime_id: int, course_data: Dict) -> Optional[int]:
|
||||
course_data["user"] = aime_id
|
||||
|
||||
sql = insert(course).values(**course_data)
|
||||
conflict = sql.on_duplicate_key_update(**course_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_course: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_time_trial(
|
||||
async def put_time_trial(
|
||||
self, version: int, aime_id: int, time_trial_data: Dict
|
||||
) -> Optional[int]:
|
||||
time_trial_data["user"] = aime_id
|
||||
@ -869,47 +869,47 @@ class IDACItemData(BaseData):
|
||||
|
||||
sql = insert(trial).values(**time_trial_data)
|
||||
conflict = sql.on_duplicate_key_update(**time_trial_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_time_trial: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_challenge(self, aime_id: int, challenge_data: Dict) -> Optional[int]:
|
||||
async def put_challenge(self, aime_id: int, challenge_data: Dict) -> Optional[int]:
|
||||
challenge_data["user"] = aime_id
|
||||
|
||||
sql = insert(challenge).values(**challenge_data)
|
||||
conflict = sql.on_duplicate_key_update(**challenge_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_challenge: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_theory_course(
|
||||
async def put_theory_course(
|
||||
self, aime_id: int, theory_course_data: Dict
|
||||
) -> Optional[int]:
|
||||
theory_course_data["user"] = aime_id
|
||||
|
||||
sql = insert(theory_course).values(**theory_course_data)
|
||||
conflict = sql.on_duplicate_key_update(**theory_course_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_theory_course: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_theory_partner(
|
||||
async def put_theory_partner(
|
||||
self, aime_id: int, theory_partner_data: Dict
|
||||
) -> Optional[int]:
|
||||
theory_partner_data["user"] = aime_id
|
||||
|
||||
sql = insert(theory_partner).values(**theory_partner_data)
|
||||
conflict = sql.on_duplicate_key_update(**theory_partner_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -918,14 +918,14 @@ class IDACItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_theory_running(
|
||||
async def put_theory_running(
|
||||
self, aime_id: int, theory_running_data: Dict
|
||||
) -> Optional[int]:
|
||||
theory_running_data["user"] = aime_id
|
||||
|
||||
sql = insert(theory_running).values(**theory_running_data)
|
||||
conflict = sql.on_duplicate_key_update(**theory_running_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -934,26 +934,26 @@ class IDACItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_vs_info(self, aime_id: int, vs_info_data: Dict) -> Optional[int]:
|
||||
async def put_vs_info(self, aime_id: int, vs_info_data: Dict) -> Optional[int]:
|
||||
vs_info_data["user"] = aime_id
|
||||
|
||||
sql = insert(vs_info).values(**vs_info_data)
|
||||
conflict = sql.on_duplicate_key_update(**vs_info_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_vs_info: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_stamp(
|
||||
async def put_stamp(
|
||||
self, aime_id: int, stamp_data: Dict
|
||||
) -> Optional[int]:
|
||||
stamp_data["user"] = aime_id
|
||||
|
||||
sql = insert(stamp).values(**stamp_data)
|
||||
conflict = sql.on_duplicate_key_update(**stamp_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -962,7 +962,7 @@ class IDACItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_timetrial_event(
|
||||
async def put_timetrial_event(
|
||||
self, aime_id: int, time_trial_event_id: int, point: int
|
||||
) -> Optional[int]:
|
||||
timetrial_event_data = {
|
||||
@ -973,7 +973,7 @@ class IDACItemData(BaseData):
|
||||
|
||||
sql = insert(timetrial_event).values(**timetrial_event_data)
|
||||
conflict = sql.on_duplicate_key_update(**timetrial_event_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
|
@ -253,7 +253,7 @@ class IDACProfileData(BaseData):
|
||||
)
|
||||
self.date_time_format_short = "%Y-%m-%d"
|
||||
|
||||
def get_profile(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(profile).where(
|
||||
and_(
|
||||
profile.c.user == aime_id,
|
||||
@ -261,12 +261,12 @@ class IDACProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_different_random_profiles(
|
||||
async def get_different_random_profiles(
|
||||
self, aime_id: int, version: int, count: int = 9
|
||||
) -> Optional[Row]:
|
||||
sql = (
|
||||
@ -281,36 +281,36 @@ class IDACProfileData(BaseData):
|
||||
.limit(count)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_profile_config(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_profile_config(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(config).where(
|
||||
and_(
|
||||
config.c.user == aime_id,
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_avatar(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_profile_avatar(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(avatar).where(
|
||||
and_(
|
||||
avatar.c.user == aime_id,
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_rank(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_rank(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(rank).where(
|
||||
and_(
|
||||
rank.c.user == aime_id,
|
||||
@ -318,12 +318,12 @@ class IDACProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_stock(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_stock(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(stock).where(
|
||||
and_(
|
||||
stock.c.user == aime_id,
|
||||
@ -331,12 +331,12 @@ class IDACProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_theory(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_theory(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(theory).where(
|
||||
and_(
|
||||
theory.c.user == aime_id,
|
||||
@ -344,12 +344,12 @@ class IDACProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile(
|
||||
async def put_profile(
|
||||
self, aime_id: int, version: int, profile_data: Dict
|
||||
) -> Optional[int]:
|
||||
profile_data["user"] = aime_id
|
||||
@ -357,19 +357,19 @@ class IDACProfileData(BaseData):
|
||||
|
||||
sql = insert(profile).values(**profile_data)
|
||||
conflict = sql.on_duplicate_key_update(**profile_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_profile: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_config(self, aime_id: int, config_data: Dict) -> Optional[int]:
|
||||
async def put_profile_config(self, aime_id: int, config_data: Dict) -> Optional[int]:
|
||||
config_data["user"] = aime_id
|
||||
|
||||
sql = insert(config).values(**config_data)
|
||||
conflict = sql.on_duplicate_key_update(**config_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -378,12 +378,12 @@ class IDACProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_avatar(self, aime_id: int, avatar_data: Dict) -> Optional[int]:
|
||||
async def put_profile_avatar(self, aime_id: int, avatar_data: Dict) -> Optional[int]:
|
||||
avatar_data["user"] = aime_id
|
||||
|
||||
sql = insert(avatar).values(**avatar_data)
|
||||
conflict = sql.on_duplicate_key_update(**avatar_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
@ -392,7 +392,7 @@ class IDACProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_rank(
|
||||
async def put_profile_rank(
|
||||
self, aime_id: int, version: int, rank_data: Dict
|
||||
) -> Optional[int]:
|
||||
rank_data["user"] = aime_id
|
||||
@ -400,14 +400,14 @@ class IDACProfileData(BaseData):
|
||||
|
||||
sql = insert(rank).values(**rank_data)
|
||||
conflict = sql.on_duplicate_key_update(**rank_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_profile_rank: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_stock(
|
||||
async def put_profile_stock(
|
||||
self, aime_id: int, version: int, stock_data: Dict
|
||||
) -> Optional[int]:
|
||||
stock_data["user"] = aime_id
|
||||
@ -415,14 +415,14 @@ class IDACProfileData(BaseData):
|
||||
|
||||
sql = insert(stock).values(**stock_data)
|
||||
conflict = sql.on_duplicate_key_update(**stock_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(f"put_profile_stock: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_theory(
|
||||
async def put_profile_theory(
|
||||
self, aime_id: int, version: int, theory_data: Dict
|
||||
) -> Optional[int]:
|
||||
theory_data["user"] = aime_id
|
||||
@ -430,7 +430,7 @@ class IDACProfileData(BaseData):
|
||||
|
||||
sql = insert(theory).values(**theory_data)
|
||||
conflict = sql.on_duplicate_key_update(**theory_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warn(
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -81,7 +81,7 @@ class IDZUserDB:
|
||||
self.logger.debug("Connection closed")
|
||||
return
|
||||
|
||||
await self.dataReceived(data, reader, writer)
|
||||
await self.data.Received(data, reader, writer)
|
||||
await writer.drain()
|
||||
|
||||
except ConnectionResetError as e:
|
||||
|
@ -82,7 +82,7 @@ class Mai2Base:
|
||||
return {"length": 0, "gameTournamentInfoList": []}
|
||||
|
||||
async def handle_get_game_event_api_request(self, data: Dict) -> Dict:
|
||||
events = self.data.static.get_enabled_events(self.version)
|
||||
events = await self.data.static.get_enabled_events(self.version)
|
||||
events_lst = []
|
||||
if events is None or not events:
|
||||
self.logger.warning("No enabled events, did you run the reader?")
|
||||
@ -112,7 +112,7 @@ class Mai2Base:
|
||||
return {"length": 0, "musicIdList": []}
|
||||
|
||||
async def handle_get_game_charge_api_request(self, data: Dict) -> Dict:
|
||||
game_charge_list = self.data.static.get_enabled_tickets(self.version, 1)
|
||||
game_charge_list = await self.data.static.get_enabled_tickets(self.version, 1)
|
||||
if game_charge_list is None:
|
||||
return {"length": 0, "gameChargeList": []}
|
||||
|
||||
@ -143,8 +143,8 @@ class Mai2Base:
|
||||
return {"returnCode": 1, "apiName": "UpsertClientTestmodeApi"}
|
||||
|
||||
async def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_detail(data["userId"], self.version, False)
|
||||
w = self.data.profile.get_web_option(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_detail(data["userId"], self.version, False)
|
||||
w = await self.data.profile.get_web_option(data["userId"], self.version)
|
||||
if p is None or w is None:
|
||||
return {} # Register
|
||||
profile = p._asdict()
|
||||
@ -170,15 +170,15 @@ class Mai2Base:
|
||||
}
|
||||
|
||||
async def handle_user_login_api_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
consec = self.data.profile.get_consec_login(data["userId"], self.version)
|
||||
profile = await self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
consec = await self.data.profile.get_consec_login(data["userId"], self.version)
|
||||
|
||||
if profile is not None:
|
||||
lastLoginDate = profile["lastLoginDate"]
|
||||
loginCt = profile["playCount"]
|
||||
|
||||
if "regionId" in data:
|
||||
self.data.profile.put_profile_region(data["userId"], data["regionId"])
|
||||
await self.data.profile.put_profile_region(data["userId"], data["regionId"])
|
||||
else:
|
||||
loginCt = 0
|
||||
lastLoginDate = "2017-12-05 07:00:00.0"
|
||||
@ -193,11 +193,11 @@ class Mai2Base:
|
||||
|
||||
if lastlogindate_ < today_midnight:
|
||||
consec_ct = consec['logins'] + 1
|
||||
self.data.profile.add_consec_login(data["userId"], self.version)
|
||||
await self.data.profile.add_consec_login(data["userId"], self.version)
|
||||
|
||||
elif lastlogindate_ < yesterday_midnight:
|
||||
consec_ct = 1
|
||||
self.data.profile.reset_consec_login(data["userId"], self.version)
|
||||
await self.data.profile.reset_consec_login(data["userId"], self.version)
|
||||
|
||||
else:
|
||||
consec_ct = consec['logins']
|
||||
@ -214,7 +214,7 @@ class Mai2Base:
|
||||
user_id = data["userId"]
|
||||
playlog = data["userPlaylog"]
|
||||
|
||||
self.data.score.put_playlog(user_id, playlog)
|
||||
await self.data.score.put_playlog(user_id, playlog)
|
||||
|
||||
return {"returnCode": 1, "apiName": "UploadUserPlaylogApi"}
|
||||
|
||||
@ -224,7 +224,7 @@ class Mai2Base:
|
||||
|
||||
# remove the ".0" from the date string, festival only?
|
||||
charge["purchaseDate"] = charge["purchaseDate"].replace(".0", "")
|
||||
self.data.item.put_charge(
|
||||
await self.data.item.put_charge(
|
||||
user_id,
|
||||
charge["chargeId"],
|
||||
charge["stock"],
|
||||
@ -246,64 +246,64 @@ class Mai2Base:
|
||||
upsert["userData"][0].pop("accessCode")
|
||||
upsert["userData"][0].pop("userId")
|
||||
|
||||
self.data.profile.put_profile_detail(
|
||||
await self.data.profile.put_profile_detail(
|
||||
user_id, self.version, upsert["userData"][0], False
|
||||
)
|
||||
|
||||
if "userWebOption" in upsert and len(upsert["userWebOption"]) > 0:
|
||||
upsert["userWebOption"][0]["isNetMember"] = True
|
||||
self.data.profile.put_web_option(
|
||||
await self.data.profile.put_web_option(
|
||||
user_id, self.version, upsert["userWebOption"][0]
|
||||
)
|
||||
|
||||
if "userGradeStatusList" in upsert and len(upsert["userGradeStatusList"]) > 0:
|
||||
self.data.profile.put_grade_status(
|
||||
await self.data.profile.put_grade_status(
|
||||
user_id, upsert["userGradeStatusList"][0]
|
||||
)
|
||||
|
||||
if "userBossList" in upsert and len(upsert["userBossList"]) > 0:
|
||||
self.data.profile.put_boss_list(
|
||||
await self.data.profile.put_boss_list(
|
||||
user_id, upsert["userBossList"][0]
|
||||
)
|
||||
|
||||
if "userPlaylogList" in upsert and len(upsert["userPlaylogList"]) > 0:
|
||||
for playlog in upsert["userPlaylogList"]:
|
||||
self.data.score.put_playlog(
|
||||
await self.data.score.put_playlog(
|
||||
user_id, playlog, False
|
||||
)
|
||||
|
||||
if "userExtend" in upsert and len(upsert["userExtend"]) > 0:
|
||||
self.data.profile.put_profile_extend(
|
||||
await self.data.profile.put_profile_extend(
|
||||
user_id, self.version, upsert["userExtend"][0]
|
||||
)
|
||||
|
||||
if "userGhost" in upsert:
|
||||
for ghost in upsert["userGhost"]:
|
||||
self.data.profile.put_profile_ghost(user_id, self.version, ghost)
|
||||
await self.data.profile.put_profile_ghost(user_id, self.version, ghost)
|
||||
|
||||
if "userRecentRatingList" in upsert:
|
||||
self.data.profile.put_recent_rating(user_id, upsert["userRecentRatingList"])
|
||||
await self.data.profile.put_recent_rating(user_id, upsert["userRecentRatingList"])
|
||||
|
||||
if "userOption" in upsert and len(upsert["userOption"]) > 0:
|
||||
upsert["userOption"][0].pop("userId")
|
||||
self.data.profile.put_profile_option(
|
||||
await self.data.profile.put_profile_option(
|
||||
user_id, self.version, upsert["userOption"][0], False
|
||||
)
|
||||
|
||||
if "userRatingList" in upsert and len(upsert["userRatingList"]) > 0:
|
||||
self.data.profile.put_profile_rating(
|
||||
await self.data.profile.put_profile_rating(
|
||||
user_id, self.version, upsert["userRatingList"][0]
|
||||
)
|
||||
|
||||
if "userActivityList" in upsert and len(upsert["userActivityList"]) > 0:
|
||||
for act in upsert["userActivityList"]:
|
||||
self.data.profile.put_profile_activity(user_id, act)
|
||||
await self.data.profile.put_profile_activity(user_id, act)
|
||||
|
||||
if "userChargeList" in upsert and len(upsert["userChargeList"]) > 0:
|
||||
for charge in upsert["userChargeList"]:
|
||||
# remove the ".0" from the date string, festival only?
|
||||
charge["purchaseDate"] = charge["purchaseDate"].replace(".0", "")
|
||||
self.data.item.put_charge(
|
||||
await self.data.item.put_charge(
|
||||
user_id,
|
||||
charge["chargeId"],
|
||||
charge["stock"],
|
||||
@ -313,14 +313,14 @@ class Mai2Base:
|
||||
|
||||
if "userCharacterList" in upsert and len(upsert["userCharacterList"]) > 0:
|
||||
for char in upsert["userCharacterList"]:
|
||||
self.data.item.put_character_(
|
||||
await self.data.item.put_character_(
|
||||
user_id,
|
||||
char
|
||||
)
|
||||
|
||||
if "userItemList" in upsert and len(upsert["userItemList"]) > 0:
|
||||
for item in upsert["userItemList"]:
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id,
|
||||
int(item["itemKind"]),
|
||||
item["itemId"],
|
||||
@ -330,7 +330,7 @@ class Mai2Base:
|
||||
|
||||
if "userLoginBonusList" in upsert and len(upsert["userLoginBonusList"]) > 0:
|
||||
for login_bonus in upsert["userLoginBonusList"]:
|
||||
self.data.item.put_login_bonus(
|
||||
await self.data.item.put_login_bonus(
|
||||
user_id,
|
||||
login_bonus["bonusId"],
|
||||
login_bonus["point"],
|
||||
@ -340,7 +340,7 @@ class Mai2Base:
|
||||
|
||||
if "userMapList" in upsert and len(upsert["userMapList"]) > 0:
|
||||
for map in upsert["userMapList"]:
|
||||
self.data.item.put_map(
|
||||
await self.data.item.put_map(
|
||||
user_id,
|
||||
map["mapId"],
|
||||
map["distance"],
|
||||
@ -351,15 +351,15 @@ class Mai2Base:
|
||||
|
||||
if "userMusicDetailList" in upsert and len(upsert["userMusicDetailList"]) > 0:
|
||||
for music in upsert["userMusicDetailList"]:
|
||||
self.data.score.put_best_score(user_id, music, False)
|
||||
await self.data.score.put_best_score(user_id, music, False)
|
||||
|
||||
if "userCourseList" in upsert and len(upsert["userCourseList"]) > 0:
|
||||
for course in upsert["userCourseList"]:
|
||||
self.data.score.put_course(user_id, course)
|
||||
await self.data.score.put_course(user_id, course)
|
||||
|
||||
if "userFavoriteList" in upsert and len(upsert["userFavoriteList"]) > 0:
|
||||
for fav in upsert["userFavoriteList"]:
|
||||
self.data.item.put_favorite(user_id, fav["kind"], fav["itemIdList"])
|
||||
await self.data.item.put_favorite(user_id, fav["kind"], fav["itemIdList"])
|
||||
|
||||
if (
|
||||
"userFriendSeasonRankingList" in upsert
|
||||
@ -371,7 +371,7 @@ class Mai2Base:
|
||||
fsr["recordDate"], f"{Mai2Constants.DATE_TIME_FORMAT}.0"
|
||||
),
|
||||
)
|
||||
self.data.item.put_friend_season_ranking(user_id, fsr)
|
||||
await self.data.item.put_friend_season_ranking(user_id, fsr)
|
||||
|
||||
return {"returnCode": 1, "apiName": "UpsertUserAllApi"}
|
||||
|
||||
@ -379,7 +379,7 @@ class Mai2Base:
|
||||
return {"returnCode": 1}
|
||||
|
||||
async def handle_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_detail(data["userId"], self.version, False)
|
||||
profile = await self.data.profile.get_profile_detail(data["userId"], self.version, False)
|
||||
if profile is None:
|
||||
return
|
||||
|
||||
@ -391,7 +391,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "userData": profile_dict}
|
||||
|
||||
async def handle_get_user_extend_api_request(self, data: Dict) -> Dict:
|
||||
extend = self.data.profile.get_profile_extend(data["userId"], self.version)
|
||||
extend = await self.data.profile.get_profile_extend(data["userId"], self.version)
|
||||
if extend is None:
|
||||
return
|
||||
|
||||
@ -403,7 +403,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "userExtend": extend_dict}
|
||||
|
||||
async def handle_get_user_option_api_request(self, data: Dict) -> Dict:
|
||||
options = self.data.profile.get_profile_option(data["userId"], self.version, False)
|
||||
options = await self.data.profile.get_profile_option(data["userId"], self.version, False)
|
||||
if options is None:
|
||||
return
|
||||
|
||||
@ -415,7 +415,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "userOption": options_dict}
|
||||
|
||||
async def handle_get_user_card_api_request(self, data: Dict) -> Dict:
|
||||
user_cards = self.data.item.get_cards(data["userId"])
|
||||
user_cards = await self.data.item.get_cards(data["userId"])
|
||||
if user_cards is None:
|
||||
return {"userId": data["userId"], "nextIndex": 0, "userCardList": []}
|
||||
|
||||
@ -449,7 +449,7 @@ class Mai2Base:
|
||||
}
|
||||
|
||||
async def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
|
||||
user_charges = self.data.item.get_charges(data["userId"])
|
||||
user_charges = await self.data.item.get_charges(data["userId"])
|
||||
if user_charges is None:
|
||||
return {"userId": data["userId"], "length": 0, "userChargeList": []}
|
||||
|
||||
@ -477,7 +477,7 @@ class Mai2Base:
|
||||
return { "userId": data.get("userId", 0), "length": 0, "userPresentEventList": []}
|
||||
|
||||
async def handle_get_user_boss_api_request(self, data: Dict) -> Dict:
|
||||
b = self.data.profile.get_boss_list(data["userId"])
|
||||
b = await self.data.profile.get_boss_list(data["userId"])
|
||||
if b is None:
|
||||
return { "userId": data.get("userId", 0), "userBossData": {}}
|
||||
boss_lst = b._asdict()
|
||||
@ -489,7 +489,7 @@ class Mai2Base:
|
||||
async def handle_get_user_item_api_request(self, data: Dict) -> Dict:
|
||||
kind = int(data["nextIndex"] / 10000000000)
|
||||
next_idx = int(data["nextIndex"] % 10000000000)
|
||||
user_item_list = self.data.item.get_items(data["userId"], kind)
|
||||
user_item_list = await self.data.item.get_items(data["userId"], kind)
|
||||
|
||||
items: List[Dict[str, Any]] = []
|
||||
for i in range(next_idx, len(user_item_list)):
|
||||
@ -515,7 +515,7 @@ class Mai2Base:
|
||||
}
|
||||
|
||||
async def handle_get_user_character_api_request(self, data: Dict) -> Dict:
|
||||
characters = self.data.item.get_characters(data["userId"])
|
||||
characters = await self.data.item.get_characters(data["userId"])
|
||||
|
||||
chara_list = []
|
||||
for chara in characters:
|
||||
@ -529,7 +529,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "userCharacterList": chara_list}
|
||||
|
||||
async def handle_get_user_favorite_api_request(self, data: Dict) -> Dict:
|
||||
favorites = self.data.item.get_favorites(data["userId"], data["itemKind"])
|
||||
favorites = await self.data.item.get_favorites(data["userId"], data["itemKind"])
|
||||
if favorites is None:
|
||||
return
|
||||
|
||||
@ -546,7 +546,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "userFavoriteData": userFavs}
|
||||
|
||||
async def handle_get_user_ghost_api_request(self, data: Dict) -> Dict:
|
||||
ghost = self.data.profile.get_profile_ghost(data["userId"], self.version)
|
||||
ghost = await self.data.profile.get_profile_ghost(data["userId"], self.version)
|
||||
if ghost is None:
|
||||
return
|
||||
|
||||
@ -558,7 +558,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "userGhost": ghost_dict}
|
||||
|
||||
async def handle_get_user_recent_rating_api_request(self, data: Dict) -> Dict:
|
||||
rating = self.data.profile.get_recent_rating(data["userId"])
|
||||
rating = await self.data.profile.get_recent_rating(data["userId"])
|
||||
if rating is None:
|
||||
return
|
||||
|
||||
@ -568,7 +568,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "length": len(lst), "userRecentRatingList": lst}
|
||||
|
||||
async def handle_get_user_rating_api_request(self, data: Dict) -> Dict:
|
||||
rating = self.data.profile.get_profile_rating(data["userId"], self.version)
|
||||
rating = await self.data.profile.get_profile_rating(data["userId"], self.version)
|
||||
if rating is None:
|
||||
return
|
||||
|
||||
@ -583,8 +583,8 @@ class Mai2Base:
|
||||
"""
|
||||
kind 1 is playlist, kind 2 is music list
|
||||
"""
|
||||
playlist = self.data.profile.get_profile_activity(data["userId"], 1)
|
||||
musiclist = self.data.profile.get_profile_activity(data["userId"], 2)
|
||||
playlist = await self.data.profile.get_profile_activity(data["userId"], 1)
|
||||
musiclist = await self.data.profile.get_profile_activity(data["userId"], 2)
|
||||
if playlist is None or musiclist is None:
|
||||
return
|
||||
|
||||
@ -608,7 +608,7 @@ class Mai2Base:
|
||||
return {"userActivity": {"playList": plst, "musicList": mlst}}
|
||||
|
||||
async def handle_get_user_course_api_request(self, data: Dict) -> Dict:
|
||||
user_courses = self.data.score.get_courses(data["userId"])
|
||||
user_courses = await self.data.score.get_courses(data["userId"])
|
||||
if user_courses is None:
|
||||
return {"userId": data["userId"], "nextIndex": 0, "userCourseList": []}
|
||||
|
||||
@ -626,7 +626,7 @@ class Mai2Base:
|
||||
return {"length": 0, "userPortraitList": []}
|
||||
|
||||
async def handle_get_user_friend_season_ranking_api_request(self, data: Dict) -> Dict:
|
||||
friend_season_ranking = self.data.item.get_friend_season_ranking(data["userId"])
|
||||
friend_season_ranking = await self.data.item.get_friend_season_ranking(data["userId"])
|
||||
if friend_season_ranking is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -662,7 +662,7 @@ class Mai2Base:
|
||||
}
|
||||
|
||||
async def handle_get_user_map_api_request(self, data: Dict) -> Dict:
|
||||
maps = self.data.item.get_maps(data["userId"])
|
||||
maps = await self.data.item.get_maps(data["userId"])
|
||||
if maps is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -695,7 +695,7 @@ class Mai2Base:
|
||||
}
|
||||
|
||||
async def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
|
||||
login_bonuses = self.data.item.get_login_bonuses(data["userId"])
|
||||
login_bonuses = await self.data.item.get_login_bonuses(data["userId"])
|
||||
if login_bonuses is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -731,7 +731,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "length": 0, "userRegionList": []}
|
||||
|
||||
async def handle_get_user_web_option_api_request(self, data: Dict) -> Dict:
|
||||
w = self.data.profile.get_web_option(data["userId"], self.version)
|
||||
w = await self.data.profile.get_web_option(data["userId"], self.version)
|
||||
if w is None:
|
||||
return {"userId": data["userId"], "userWebOption": {}}
|
||||
|
||||
@ -746,7 +746,7 @@ class Mai2Base:
|
||||
return {"userId": data["userId"], "length": 0, "userSurvivalList": []}
|
||||
|
||||
async def handle_get_user_grade_api_request(self, data: Dict) -> Dict:
|
||||
g = self.data.profile.get_grade_status(data["userId"])
|
||||
g = await self.data.profile.get_grade_status(data["userId"])
|
||||
if g is None:
|
||||
return {"userId": data["userId"], "userGradeStatus": {}, "length": 0, "userGradeList": []}
|
||||
grade_stat = g._asdict()
|
||||
@ -766,7 +766,7 @@ class Mai2Base:
|
||||
self.logger.warning("handle_get_user_music_api_request: Could not find userid in data, or userId is 0")
|
||||
return {}
|
||||
|
||||
songs = self.data.score.get_best_scores(user_id, is_dx=False)
|
||||
songs = await self.data.score.get_best_scores(user_id, is_dx=False)
|
||||
if songs is None:
|
||||
self.logger.debug("handle_get_user_music_api_request: get_best_scores returned None!")
|
||||
return {
|
||||
|
@ -34,8 +34,8 @@ class Mai2DX(Mai2Base):
|
||||
}
|
||||
|
||||
async def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
o = self.data.profile.get_profile_option(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
o = await self.data.profile.get_profile_option(data["userId"], self.version)
|
||||
if p is None or o is None:
|
||||
return {} # Register
|
||||
profile = p._asdict()
|
||||
@ -73,7 +73,7 @@ class Mai2DX(Mai2Base):
|
||||
user_id = data["userId"]
|
||||
playlog = data["userPlaylog"]
|
||||
|
||||
self.data.score.put_playlog(user_id, playlog)
|
||||
await self.data.score.put_playlog(user_id, playlog)
|
||||
|
||||
return {"returnCode": 1, "apiName": "UploadUserPlaylogApi"}
|
||||
|
||||
@ -83,7 +83,7 @@ class Mai2DX(Mai2Base):
|
||||
|
||||
# remove the ".0" from the date string, festival only?
|
||||
charge["purchaseDate"] = charge["purchaseDate"].replace(".0", "")
|
||||
self.data.item.put_charge(
|
||||
await self.data.item.put_charge(
|
||||
user_id,
|
||||
charge["chargeId"],
|
||||
charge["stock"],
|
||||
@ -104,39 +104,39 @@ class Mai2DX(Mai2Base):
|
||||
if "userData" in upsert and len(upsert["userData"]) > 0:
|
||||
upsert["userData"][0]["isNetMember"] = 1
|
||||
upsert["userData"][0].pop("accessCode")
|
||||
self.data.profile.put_profile_detail(
|
||||
await self.data.profile.put_profile_detail(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
|
||||
if "userExtend" in upsert and len(upsert["userExtend"]) > 0:
|
||||
self.data.profile.put_profile_extend(
|
||||
await self.data.profile.put_profile_extend(
|
||||
user_id, self.version, upsert["userExtend"][0]
|
||||
)
|
||||
|
||||
if "userGhost" in upsert:
|
||||
for ghost in upsert["userGhost"]:
|
||||
self.data.profile.put_profile_ghost(user_id, self.version, ghost)
|
||||
await self.data.profile.put_profile_ghost(user_id, self.version, ghost)
|
||||
|
||||
if "userOption" in upsert and len(upsert["userOption"]) > 0:
|
||||
self.data.profile.put_profile_option(
|
||||
await self.data.profile.put_profile_option(
|
||||
user_id, self.version, upsert["userOption"][0]
|
||||
)
|
||||
|
||||
if "userRatingList" in upsert and len(upsert["userRatingList"]) > 0:
|
||||
self.data.profile.put_profile_rating(
|
||||
await self.data.profile.put_profile_rating(
|
||||
user_id, self.version, upsert["userRatingList"][0]
|
||||
)
|
||||
|
||||
if "userActivityList" in upsert and len(upsert["userActivityList"]) > 0:
|
||||
for k, v in upsert["userActivityList"][0].items():
|
||||
for act in v:
|
||||
self.data.profile.put_profile_activity(user_id, act)
|
||||
await self.data.profile.put_profile_activity(user_id, act)
|
||||
|
||||
if "userChargeList" in upsert and len(upsert["userChargeList"]) > 0:
|
||||
for charge in upsert["userChargeList"]:
|
||||
# remove the ".0" from the date string, festival only?
|
||||
charge["purchaseDate"] = charge["purchaseDate"].replace(".0", "")
|
||||
self.data.item.put_charge(
|
||||
await self.data.item.put_charge(
|
||||
user_id,
|
||||
charge["chargeId"],
|
||||
charge["stock"],
|
||||
@ -150,7 +150,7 @@ class Mai2DX(Mai2Base):
|
||||
|
||||
if "userCharacterList" in upsert and len(upsert["userCharacterList"]) > 0:
|
||||
for char in upsert["userCharacterList"]:
|
||||
self.data.item.put_character(
|
||||
await self.data.item.put_character(
|
||||
user_id,
|
||||
char["characterId"],
|
||||
char["level"],
|
||||
@ -160,7 +160,7 @@ class Mai2DX(Mai2Base):
|
||||
|
||||
if "userItemList" in upsert and len(upsert["userItemList"]) > 0:
|
||||
for item in upsert["userItemList"]:
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id,
|
||||
int(item["itemKind"]),
|
||||
item["itemId"],
|
||||
@ -170,7 +170,7 @@ class Mai2DX(Mai2Base):
|
||||
|
||||
if "userLoginBonusList" in upsert and len(upsert["userLoginBonusList"]) > 0:
|
||||
for login_bonus in upsert["userLoginBonusList"]:
|
||||
self.data.item.put_login_bonus(
|
||||
await self.data.item.put_login_bonus(
|
||||
user_id,
|
||||
login_bonus["bonusId"],
|
||||
login_bonus["point"],
|
||||
@ -180,7 +180,7 @@ class Mai2DX(Mai2Base):
|
||||
|
||||
if "userMapList" in upsert and len(upsert["userMapList"]) > 0:
|
||||
for map in upsert["userMapList"]:
|
||||
self.data.item.put_map(
|
||||
await self.data.item.put_map(
|
||||
user_id,
|
||||
map["mapId"],
|
||||
map["distance"],
|
||||
@ -191,15 +191,15 @@ class Mai2DX(Mai2Base):
|
||||
|
||||
if "userMusicDetailList" in upsert and len(upsert["userMusicDetailList"]) > 0:
|
||||
for music in upsert["userMusicDetailList"]:
|
||||
self.data.score.put_best_score(user_id, music)
|
||||
await self.data.score.put_best_score(user_id, music)
|
||||
|
||||
if "userCourseList" in upsert and len(upsert["userCourseList"]) > 0:
|
||||
for course in upsert["userCourseList"]:
|
||||
self.data.score.put_course(user_id, course)
|
||||
await self.data.score.put_course(user_id, course)
|
||||
|
||||
if "userFavoriteList" in upsert and len(upsert["userFavoriteList"]) > 0:
|
||||
for fav in upsert["userFavoriteList"]:
|
||||
self.data.item.put_favorite(user_id, fav["kind"], fav["itemIdList"])
|
||||
await self.data.item.put_favorite(user_id, fav["kind"], fav["itemIdList"])
|
||||
|
||||
if (
|
||||
"userFriendSeasonRankingList" in upsert
|
||||
@ -211,12 +211,12 @@ class Mai2DX(Mai2Base):
|
||||
fsr["recordDate"], f"{Mai2Constants.DATE_TIME_FORMAT}.0"
|
||||
),
|
||||
)
|
||||
self.data.item.put_friend_season_ranking(user_id, fsr)
|
||||
await self.data.item.put_friend_season_ranking(user_id, fsr)
|
||||
|
||||
return {"returnCode": 1, "apiName": "UpsertUserAllApi"}
|
||||
|
||||
async def handle_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
profile = await self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
if profile is None:
|
||||
return
|
||||
|
||||
@ -228,7 +228,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userId": data["userId"], "userData": profile_dict}
|
||||
|
||||
async def handle_get_user_extend_api_request(self, data: Dict) -> Dict:
|
||||
extend = self.data.profile.get_profile_extend(data["userId"], self.version)
|
||||
extend = await self.data.profile.get_profile_extend(data["userId"], self.version)
|
||||
if extend is None:
|
||||
return
|
||||
|
||||
@ -240,7 +240,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userId": data["userId"], "userExtend": extend_dict}
|
||||
|
||||
async def handle_get_user_option_api_request(self, data: Dict) -> Dict:
|
||||
options = self.data.profile.get_profile_option(data["userId"], self.version)
|
||||
options = await self.data.profile.get_profile_option(data["userId"], self.version)
|
||||
if options is None:
|
||||
return
|
||||
|
||||
@ -252,7 +252,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userId": data["userId"], "userOption": options_dict}
|
||||
|
||||
async def handle_get_user_card_api_request(self, data: Dict) -> Dict:
|
||||
user_cards = self.data.item.get_cards(data["userId"])
|
||||
user_cards = await self.data.item.get_cards(data["userId"])
|
||||
if user_cards is None:
|
||||
return {"userId": data["userId"], "nextIndex": 0, "userCardList": []}
|
||||
|
||||
@ -286,7 +286,7 @@ class Mai2DX(Mai2Base):
|
||||
}
|
||||
|
||||
async def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
|
||||
user_charges = self.data.item.get_charges(data["userId"])
|
||||
user_charges = await self.data.item.get_charges(data["userId"])
|
||||
if user_charges is None:
|
||||
return {"userId": data["userId"], "length": 0, "userChargeList": []}
|
||||
|
||||
@ -313,7 +313,7 @@ class Mai2DX(Mai2Base):
|
||||
async def handle_get_user_item_api_request(self, data: Dict) -> Dict:
|
||||
kind = int(data["nextIndex"] / 10000000000)
|
||||
next_idx = int(data["nextIndex"] % 10000000000)
|
||||
user_item_list = self.data.item.get_items(data["userId"], kind)
|
||||
user_item_list = await self.data.item.get_items(data["userId"], kind)
|
||||
|
||||
items: List[Dict[str, Any]] = []
|
||||
for i in range(next_idx, len(user_item_list)):
|
||||
@ -339,7 +339,7 @@ class Mai2DX(Mai2Base):
|
||||
}
|
||||
|
||||
async def handle_get_user_character_api_request(self, data: Dict) -> Dict:
|
||||
characters = self.data.item.get_characters(data["userId"])
|
||||
characters = await self.data.item.get_characters(data["userId"])
|
||||
|
||||
chara_list = []
|
||||
for chara in characters:
|
||||
@ -351,7 +351,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userId": data["userId"], "userCharacterList": chara_list}
|
||||
|
||||
async def handle_get_user_favorite_api_request(self, data: Dict) -> Dict:
|
||||
favorites = self.data.item.get_favorites(data["userId"], data["itemKind"])
|
||||
favorites = await self.data.item.get_favorites(data["userId"], data["itemKind"])
|
||||
if favorites is None:
|
||||
return
|
||||
|
||||
@ -368,7 +368,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userId": data["userId"], "userFavoriteData": userFavs}
|
||||
|
||||
async def handle_get_user_ghost_api_request(self, data: Dict) -> Dict:
|
||||
ghost = self.data.profile.get_profile_ghost(data["userId"], self.version)
|
||||
ghost = await self.data.profile.get_profile_ghost(data["userId"], self.version)
|
||||
if ghost is None:
|
||||
return
|
||||
|
||||
@ -380,7 +380,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userId": data["userId"], "userGhost": ghost_dict}
|
||||
|
||||
async def handle_get_user_rating_api_request(self, data: Dict) -> Dict:
|
||||
rating = self.data.profile.get_profile_rating(data["userId"], self.version)
|
||||
rating = await self.data.profile.get_profile_rating(data["userId"], self.version)
|
||||
if rating is None:
|
||||
return
|
||||
|
||||
@ -395,8 +395,8 @@ class Mai2DX(Mai2Base):
|
||||
"""
|
||||
kind 1 is playlist, kind 2 is music list
|
||||
"""
|
||||
playlist = self.data.profile.get_profile_activity(data["userId"], 1)
|
||||
musiclist = self.data.profile.get_profile_activity(data["userId"], 2)
|
||||
playlist = await self.data.profile.get_profile_activity(data["userId"], 1)
|
||||
musiclist = await self.data.profile.get_profile_activity(data["userId"], 2)
|
||||
if playlist is None or musiclist is None:
|
||||
return
|
||||
|
||||
@ -420,7 +420,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"userActivity": {"playList": plst, "musicList": mlst}}
|
||||
|
||||
async def handle_get_user_course_api_request(self, data: Dict) -> Dict:
|
||||
user_courses = self.data.score.get_courses(data["userId"])
|
||||
user_courses = await self.data.score.get_courses(data["userId"])
|
||||
if user_courses is None:
|
||||
return {"userId": data["userId"], "nextIndex": 0, "userCourseList": []}
|
||||
|
||||
@ -438,7 +438,7 @@ class Mai2DX(Mai2Base):
|
||||
return {"length": 0, "userPortraitList": []}
|
||||
|
||||
async def handle_get_user_friend_season_ranking_api_request(self, data: Dict) -> Dict:
|
||||
friend_season_ranking = self.data.item.get_friend_season_ranking(data["userId"])
|
||||
friend_season_ranking = await self.data.item.get_friend_season_ranking(data["userId"])
|
||||
if friend_season_ranking is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -474,7 +474,7 @@ class Mai2DX(Mai2Base):
|
||||
}
|
||||
|
||||
async def handle_get_user_map_api_request(self, data: Dict) -> Dict:
|
||||
maps = self.data.item.get_maps(data["userId"])
|
||||
maps = await self.data.item.get_maps(data["userId"])
|
||||
if maps is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -507,7 +507,7 @@ class Mai2DX(Mai2Base):
|
||||
}
|
||||
|
||||
async def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
|
||||
login_bonuses = self.data.item.get_login_bonuses(data["userId"])
|
||||
login_bonuses = await self.data.item.get_login_bonuses(data["userId"])
|
||||
if login_bonuses is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -588,7 +588,7 @@ class Mai2DX(Mai2Base):
|
||||
self.logger.warning("handle_get_user_music_api_request: Could not find userid in data, or userId is 0")
|
||||
return {}
|
||||
|
||||
songs = self.data.score.get_best_scores(user_id)
|
||||
songs = await self.data.score.get_best_scores(user_id)
|
||||
if songs is None:
|
||||
self.logger.debug("handle_get_user_music_api_request: get_best_scores returned None!")
|
||||
return {
|
||||
|
@ -35,7 +35,7 @@ class Mai2Reader(BaseReader):
|
||||
self.logger.error(f"Invalid maimai DX version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
data_dirs = []
|
||||
if self.version >= Mai2Constants.VER_MAIMAI_DX:
|
||||
if self.bin_dir is not None:
|
||||
@ -46,10 +46,10 @@ class Mai2Reader(BaseReader):
|
||||
|
||||
for dir in data_dirs:
|
||||
self.logger.info(f"Read from {dir}")
|
||||
self.get_events(f"{dir}/event")
|
||||
self.disable_events(f"{dir}/information", f"{dir}/scoreRanking")
|
||||
self.read_music(f"{dir}/music")
|
||||
self.read_tickets(f"{dir}/ticket")
|
||||
await self.get_events(f"{dir}/event")
|
||||
await self.disable_events(f"{dir}/information", f"{dir}/scoreRanking")
|
||||
await self.read_music(f"{dir}/music")
|
||||
await self.read_tickets(f"{dir}/ticket")
|
||||
|
||||
else:
|
||||
if not os.path.exists(f"{self.bin_dir}/tables"):
|
||||
@ -70,16 +70,16 @@ class Mai2Reader(BaseReader):
|
||||
txt_table = self.load_table_raw(f"{self.bin_dir}/tables", "mmtextout_jp.bin", key)
|
||||
score_table = self.load_table_raw(f"{self.bin_dir}/tables", "mmScore.bin", key)
|
||||
|
||||
self.read_old_events(evt_table)
|
||||
self.read_old_music(score_table, txt_table)
|
||||
await self.read_old_events(evt_table)
|
||||
await self.read_old_music(score_table, txt_table)
|
||||
|
||||
if self.opt_dir is not None:
|
||||
evt_table = self.load_table_raw(f"{self.opt_dir}/tables", "mmEvent.bin", key)
|
||||
txt_table = self.load_table_raw(f"{self.opt_dir}/tables", "mmtextout_jp.bin", key)
|
||||
score_table = self.load_table_raw(f"{self.opt_dir}/tables", "mmScore.bin", key)
|
||||
|
||||
self.read_old_events(evt_table)
|
||||
self.read_old_music(score_table, txt_table)
|
||||
await self.read_old_events(evt_table)
|
||||
await self.read_old_music(score_table, txt_table)
|
||||
|
||||
return
|
||||
|
||||
@ -179,7 +179,7 @@ class Mai2Reader(BaseReader):
|
||||
self.logger.warning("Failed load table content, skipping")
|
||||
return
|
||||
|
||||
def get_events(self, base_dir: str) -> None:
|
||||
async def get_events(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading events from {base_dir}...")
|
||||
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
@ -192,12 +192,12 @@ class Mai2Reader(BaseReader):
|
||||
id = int(troot.find("name").find("id").text)
|
||||
event_type = int(troot.find("infoType").text)
|
||||
|
||||
self.data.static.put_game_event(
|
||||
await self.data.static.put_game_event(
|
||||
self.version, event_type, id, name
|
||||
)
|
||||
self.logger.info(f"Added event {id}...")
|
||||
|
||||
def disable_events(
|
||||
async def disable_events(
|
||||
self, base_information_dir: str, base_score_ranking_dir: str
|
||||
) -> None:
|
||||
self.logger.info(f"Reading disabled events from {base_information_dir}...")
|
||||
@ -210,7 +210,7 @@ class Mai2Reader(BaseReader):
|
||||
|
||||
event_id = int(troot.find("name").find("id").text)
|
||||
|
||||
self.data.static.toggle_game_event(
|
||||
await self.data.static.toggle_game_event(
|
||||
self.version, event_id, toggle=False
|
||||
)
|
||||
self.logger.info(f"Disabled event {event_id}...")
|
||||
@ -223,7 +223,7 @@ class Mai2Reader(BaseReader):
|
||||
|
||||
event_id = int(troot.find("eventName").find("id").text)
|
||||
|
||||
self.data.static.toggle_game_event(
|
||||
await self.data.static.toggle_game_event(
|
||||
self.version, event_id, toggle=False
|
||||
)
|
||||
self.logger.info(f"Disabled event {event_id}...")
|
||||
@ -252,10 +252,10 @@ class Mai2Reader(BaseReader):
|
||||
22091518,
|
||||
22091519,
|
||||
]:
|
||||
self.data.static.toggle_game_event(self.version, event_id, toggle=False)
|
||||
await self.data.static.toggle_game_event(self.version, event_id, toggle=False)
|
||||
self.logger.info(f"Disabled event {event_id}...")
|
||||
|
||||
def read_music(self, base_dir: str) -> None:
|
||||
async def read_music(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading music from {base_dir}...")
|
||||
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
@ -285,7 +285,7 @@ class Mai2Reader(BaseReader):
|
||||
dif.find("notesDesigner").find("str").text
|
||||
)
|
||||
|
||||
self.data.static.put_game_music(
|
||||
await self.data.static.put_game_music(
|
||||
self.version,
|
||||
song_id,
|
||||
chart_id,
|
||||
@ -302,7 +302,7 @@ class Mai2Reader(BaseReader):
|
||||
f"Added music id {song_id} chart {chart_id}"
|
||||
)
|
||||
|
||||
def read_tickets(self, base_dir: str) -> None:
|
||||
async def read_tickets(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading tickets from {base_dir}...")
|
||||
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
@ -316,12 +316,12 @@ class Mai2Reader(BaseReader):
|
||||
ticket_type = int(troot.find("ticketKind").find("id").text)
|
||||
price = int(troot.find("creditNum").text)
|
||||
|
||||
self.data.static.put_game_ticket(
|
||||
await self.data.static.put_game_ticket(
|
||||
self.version, id, ticket_type, price, name
|
||||
)
|
||||
self.logger.info(f"Added ticket {id}...")
|
||||
|
||||
def read_old_events(self, events: Optional[List[Dict[str, str]]]) -> None:
|
||||
async def read_old_events(self, events: Optional[List[Dict[str, str]]]) -> None:
|
||||
if events is None:
|
||||
return
|
||||
|
||||
@ -332,12 +332,12 @@ class Mai2Reader(BaseReader):
|
||||
is_aou = bool(int(event.get('AOU許可', '0')))
|
||||
name = event.get('comment', f'evt_{evt_id}')
|
||||
|
||||
self.data.static.put_game_event(self.version, 0, evt_id, name)
|
||||
await self.data.static.put_game_event(self.version, 0, evt_id, name)
|
||||
|
||||
if not (is_exp or is_aou):
|
||||
self.data.static.toggle_game_event(self.version, evt_id, False)
|
||||
await self.data.static.toggle_game_event(self.version, evt_id, False)
|
||||
|
||||
def read_old_music(self, scores: Optional[List[Dict[str, str]]], text: Optional[List[Dict[str, str]]]) -> None:
|
||||
async def read_old_music(self, scores: Optional[List[Dict[str, str]]], text: Optional[List[Dict[str, str]]]) -> None:
|
||||
if scores is None or text is None:
|
||||
return
|
||||
# TODO
|
||||
|
@ -186,7 +186,7 @@ print_detail = Table(
|
||||
|
||||
|
||||
class Mai2ItemData(BaseData):
|
||||
def put_item(
|
||||
async def put_item(
|
||||
self, user_id: int, item_kind: int, item_id: int, stock: int, is_valid: bool
|
||||
) -> None:
|
||||
sql = insert(item).values(
|
||||
@ -202,7 +202,7 @@ class Mai2ItemData(BaseData):
|
||||
isValid=is_valid,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_item: failed to insert item! user_id: {user_id}, item_kind: {item_kind}, item_id: {item_id}"
|
||||
@ -210,7 +210,7 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_items(self, user_id: int, item_kind: int = None) -> Optional[List[Row]]:
|
||||
async def get_items(self, user_id: int, item_kind: int = None) -> Optional[List[Row]]:
|
||||
if item_kind is None:
|
||||
sql = item.select(item.c.user == user_id)
|
||||
else:
|
||||
@ -218,12 +218,12 @@ class Mai2ItemData(BaseData):
|
||||
and_(item.c.user == user_id, item.c.itemKind == item_kind)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_item(self, user_id: int, item_kind: int, item_id: int) -> Optional[Row]:
|
||||
async def get_item(self, user_id: int, item_kind: int, item_id: int) -> Optional[Row]:
|
||||
sql = item.select(
|
||||
and_(
|
||||
item.c.user == user_id,
|
||||
@ -232,12 +232,12 @@ class Mai2ItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_login_bonus(
|
||||
async def put_login_bonus(
|
||||
self,
|
||||
user_id: int,
|
||||
bonus_id: int,
|
||||
@ -259,7 +259,7 @@ class Mai2ItemData(BaseData):
|
||||
isComplete=is_complete,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_login_bonus: failed to insert item! user_id: {user_id}, bonus_id: {bonus_id}, point: {point}"
|
||||
@ -267,25 +267,25 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_login_bonuses(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_login_bonuses(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = login_bonus.select(login_bonus.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_login_bonus(self, user_id: int, bonus_id: int) -> Optional[Row]:
|
||||
async def get_login_bonus(self, user_id: int, bonus_id: int) -> Optional[Row]:
|
||||
sql = login_bonus.select(
|
||||
and_(login_bonus.c.user == user_id, login_bonus.c.bonus_id == bonus_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_map(
|
||||
async def put_map(
|
||||
self,
|
||||
user_id: int,
|
||||
map_id: int,
|
||||
@ -310,7 +310,7 @@ class Mai2ItemData(BaseData):
|
||||
isComplete=is_complete,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_map: failed to insert item! user_id: {user_id}, map_id: {map_id}, distance: {distance}"
|
||||
@ -318,28 +318,28 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_maps(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_maps(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = map.select(map.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_map(self, user_id: int, map_id: int) -> Optional[Row]:
|
||||
async def get_map(self, user_id: int, map_id: int) -> Optional[Row]:
|
||||
sql = map.select(and_(map.c.user == user_id, map.c.mapId == map_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_character_(self, user_id: int, char_data: Dict) -> Optional[int]:
|
||||
async def put_character_(self, user_id: int, char_data: Dict) -> Optional[int]:
|
||||
char_data["user"] = user_id
|
||||
sql = insert(character).values(**char_data)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**char_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_character_: failed to insert item! user_id: {user_id}"
|
||||
@ -347,7 +347,7 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_character(
|
||||
async def put_character(
|
||||
self,
|
||||
user_id: int,
|
||||
character_id: int,
|
||||
@ -369,7 +369,7 @@ class Mai2ItemData(BaseData):
|
||||
useCount=use_count,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_character: failed to insert item! user_id: {user_id}, character_id: {character_id}, level: {level}"
|
||||
@ -377,33 +377,33 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_characters(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_characters(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = character.select(character.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_character(self, user_id: int, character_id: int) -> Optional[Row]:
|
||||
async def get_character(self, user_id: int, character_id: int) -> Optional[Row]:
|
||||
sql = character.select(
|
||||
and_(character.c.user == user_id, character.c.character_id == character_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_friend_season_ranking(self, user_id: int) -> Optional[Row]:
|
||||
async def get_friend_season_ranking(self, user_id: int) -> Optional[Row]:
|
||||
sql = friend_season_ranking.select(friend_season_ranking.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_friend_season_ranking(
|
||||
async def put_friend_season_ranking(
|
||||
self, aime_id: int, friend_season_ranking_data: Dict
|
||||
) -> Optional[int]:
|
||||
sql = insert(friend_season_ranking).values(
|
||||
@ -411,7 +411,7 @@ class Mai2ItemData(BaseData):
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**friend_season_ranking_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -421,7 +421,7 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_favorite(
|
||||
async def put_favorite(
|
||||
self, user_id: int, kind: int, item_id_list: List[int]
|
||||
) -> Optional[int]:
|
||||
sql = insert(favorite).values(
|
||||
@ -430,7 +430,7 @@ class Mai2ItemData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(item_id_list=item_id_list)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_favorite: failed to insert item! user_id: {user_id}, kind: {kind}"
|
||||
@ -438,7 +438,7 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_favorites(self, user_id: int, kind: int = None) -> Optional[Row]:
|
||||
async def get_favorites(self, user_id: int, kind: int = None) -> Optional[Row]:
|
||||
if kind is None:
|
||||
sql = favorite.select(favorite.c.user == user_id)
|
||||
else:
|
||||
@ -446,12 +446,12 @@ class Mai2ItemData(BaseData):
|
||||
and_(favorite.c.user == user_id, favorite.c.itemKind == kind)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_card(
|
||||
async def put_card(
|
||||
self,
|
||||
user_id: int,
|
||||
card_type_id: int,
|
||||
@ -475,7 +475,7 @@ class Mai2ItemData(BaseData):
|
||||
charaId=chara_id, mapId=map_id, startDate=start_date, endDate=end_date
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_card: failed to insert card! user_id: {user_id}, kind: {card_kind}"
|
||||
@ -483,7 +483,7 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_cards(self, user_id: int, kind: int = None) -> Optional[Row]:
|
||||
async def get_cards(self, user_id: int, kind: int = None) -> Optional[Row]:
|
||||
if kind is None:
|
||||
sql = card.select(card.c.user == user_id)
|
||||
else:
|
||||
@ -491,12 +491,12 @@ class Mai2ItemData(BaseData):
|
||||
|
||||
sql = sql.order_by(card.c.startDate.desc())
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_charge(
|
||||
async def put_charge(
|
||||
self,
|
||||
user_id: int,
|
||||
charge_id: int,
|
||||
@ -516,7 +516,7 @@ class Mai2ItemData(BaseData):
|
||||
stock=stock, purchaseDate=purchase_date, validDate=valid_date
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_card: failed to insert charge! user_id: {user_id}, chargeId: {charge_id}"
|
||||
@ -524,15 +524,15 @@ class Mai2ItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_charges(self, user_id: int) -> Optional[Row]:
|
||||
async def get_charges(self, user_id: int) -> Optional[Row]:
|
||||
sql = charge.select(charge.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_user_print_detail(
|
||||
async def put_user_print_detail(
|
||||
self, aime_id: int, serial_id: str, user_print_data: Dict
|
||||
) -> Optional[int]:
|
||||
sql = insert(print_detail).values(
|
||||
@ -540,7 +540,7 @@ class Mai2ItemData(BaseData):
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**user_print_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
|
@ -491,7 +491,7 @@ consec_logins = Table(
|
||||
|
||||
|
||||
class Mai2ProfileData(BaseData):
|
||||
def put_profile_detail(
|
||||
async def put_profile_detail(
|
||||
self, user_id: int, version: int, detail_data: Dict, is_dx: bool = True
|
||||
) -> Optional[Row]:
|
||||
detail_data["user"] = user_id
|
||||
@ -504,7 +504,7 @@ class Mai2ProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**detail_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile: Failed to create profile! user_id {user_id} is_dx {is_dx}"
|
||||
@ -512,7 +512,7 @@ class Mai2ProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_detail(
|
||||
async def get_profile_detail(
|
||||
self, user_id: int, version: int, is_dx: bool = True
|
||||
) -> Optional[Row]:
|
||||
if is_dx:
|
||||
@ -531,12 +531,12 @@ class Mai2ProfileData(BaseData):
|
||||
.order_by(detail_old.c.version.desc())
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_ghost(
|
||||
async def put_profile_ghost(
|
||||
self, user_id: int, version: int, ghost_data: Dict
|
||||
) -> Optional[int]:
|
||||
ghost_data["user"] = user_id
|
||||
@ -545,25 +545,25 @@ class Mai2ProfileData(BaseData):
|
||||
sql = insert(ghost).values(**ghost_data)
|
||||
conflict = sql.on_duplicate_key_update(**ghost_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_profile_ghost: failed to update! {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_ghost(self, user_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_ghost(self, user_id: int, version: int) -> Optional[Row]:
|
||||
sql = (
|
||||
select(ghost)
|
||||
.where(and_(ghost.c.user == user_id, ghost.c.version_int <= version))
|
||||
.order_by(ghost.c.version.desc())
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_extend(
|
||||
async def put_profile_extend(
|
||||
self, user_id: int, version: int, extend_data: Dict
|
||||
) -> Optional[int]:
|
||||
extend_data["user"] = user_id
|
||||
@ -572,25 +572,25 @@ class Mai2ProfileData(BaseData):
|
||||
sql = insert(extend).values(**extend_data)
|
||||
conflict = sql.on_duplicate_key_update(**extend_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_profile_extend: failed to update! {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_extend(self, user_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_extend(self, user_id: int, version: int) -> Optional[Row]:
|
||||
sql = (
|
||||
select(extend)
|
||||
.where(and_(extend.c.user == user_id, extend.c.version <= version))
|
||||
.order_by(extend.c.version.desc())
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_option(
|
||||
async def put_profile_option(
|
||||
self, user_id: int, version: int, option_data: Dict, is_dx: bool = True
|
||||
) -> Optional[int]:
|
||||
option_data["user"] = user_id
|
||||
@ -602,7 +602,7 @@ class Mai2ProfileData(BaseData):
|
||||
sql = insert(option_old).values(**option_data)
|
||||
conflict = sql.on_duplicate_key_update(**option_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_option: failed to update! {user_id} is_dx {is_dx}"
|
||||
@ -610,7 +610,7 @@ class Mai2ProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_option(
|
||||
async def get_profile_option(
|
||||
self, user_id: int, version: int, is_dx: bool = True
|
||||
) -> Optional[Row]:
|
||||
if is_dx:
|
||||
@ -628,12 +628,12 @@ class Mai2ProfileData(BaseData):
|
||||
.order_by(option_old.c.version.desc())
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_rating(
|
||||
async def put_profile_rating(
|
||||
self, user_id: int, version: int, rating_data: Dict
|
||||
) -> Optional[int]:
|
||||
rating_data["user"] = user_id
|
||||
@ -642,25 +642,25 @@ class Mai2ProfileData(BaseData):
|
||||
sql = insert(rating).values(**rating_data)
|
||||
conflict = sql.on_duplicate_key_update(**rating_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_profile_rating: failed to update! {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_rating(self, user_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_rating(self, user_id: int, version: int) -> Optional[Row]:
|
||||
sql = (
|
||||
select(rating)
|
||||
.where(and_(rating.c.user == user_id, rating.c.version <= version))
|
||||
.order_by(rating.c.version.desc())
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_profile_region(self, user_id: int, region_id: int) -> Optional[int]:
|
||||
async def put_profile_region(self, user_id: int, region_id: int) -> Optional[int]:
|
||||
sql = insert(region).values(
|
||||
user=user_id,
|
||||
regionId=region_id,
|
||||
@ -669,21 +669,21 @@ class Mai2ProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(playCount=region.c.playCount + 1)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_region: failed to update! {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_regions(self, user_id: int) -> Optional[List[Dict]]:
|
||||
async def get_regions(self, user_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(region).where(region.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_profile_activity(self, user_id: int, activity_data: Dict) -> Optional[int]:
|
||||
async def put_profile_activity(self, user_id: int, activity_data: Dict) -> Optional[int]:
|
||||
if "id" in activity_data:
|
||||
activity_data["activityId"] = activity_data["id"]
|
||||
activity_data.pop("id")
|
||||
@ -694,7 +694,7 @@ class Mai2ProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**activity_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_activity: failed to update! user_id: {user_id}"
|
||||
@ -702,7 +702,7 @@ class Mai2ProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile_activity(
|
||||
async def get_profile_activity(
|
||||
self, user_id: int, kind: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
sql = activity.select(
|
||||
@ -712,12 +712,12 @@ class Mai2ProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_web_option(
|
||||
async def put_web_option(
|
||||
self, user_id: int, version: int, web_opts: Dict
|
||||
) -> Optional[int]:
|
||||
web_opts["user"] = user_id
|
||||
@ -726,29 +726,29 @@ class Mai2ProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**web_opts)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_web_option: failed to update! user_id: {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_web_option(self, user_id: int, version: int) -> Optional[Row]:
|
||||
async def get_web_option(self, user_id: int, version: int) -> Optional[Row]:
|
||||
sql = web_opt.select(
|
||||
and_(web_opt.c.user == user_id, web_opt.c.version == version)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_grade_status(self, user_id: int, grade_stat: Dict) -> Optional[int]:
|
||||
async def put_grade_status(self, user_id: int, grade_stat: Dict) -> Optional[int]:
|
||||
grade_stat["user"] = user_id
|
||||
sql = insert(grade_status).values(**grade_stat)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**grade_stat)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_grade_status: failed to update! user_id: {user_id}"
|
||||
@ -756,40 +756,40 @@ class Mai2ProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_grade_status(self, user_id: int) -> Optional[Row]:
|
||||
async def get_grade_status(self, user_id: int) -> Optional[Row]:
|
||||
sql = grade_status.select(grade_status.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_boss_list(self, user_id: int, boss_stat: Dict) -> Optional[int]:
|
||||
async def put_boss_list(self, user_id: int, boss_stat: Dict) -> Optional[int]:
|
||||
boss_stat["user"] = user_id
|
||||
sql = insert(boss).values(**boss_stat)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**boss_stat)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_boss_list: failed to update! user_id: {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_boss_list(self, user_id: int) -> Optional[Row]:
|
||||
async def get_boss_list(self, user_id: int) -> Optional[Row]:
|
||||
sql = boss.select(boss.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_recent_rating(self, user_id: int, rr: Dict) -> Optional[int]:
|
||||
async def put_recent_rating(self, user_id: int, rr: Dict) -> Optional[int]:
|
||||
sql = insert(recent_rating).values(user=user_id, userRecentRatingList=rr)
|
||||
|
||||
conflict = sql.on_duplicate_key_update({"userRecentRatingList": rr})
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_recent_rating: failed to update! user_id: {user_id}"
|
||||
@ -797,26 +797,26 @@ class Mai2ProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_recent_rating(self, user_id: int) -> Optional[Row]:
|
||||
async def get_recent_rating(self, user_id: int) -> Optional[Row]:
|
||||
sql = recent_rating.select(recent_rating.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def add_consec_login(self, user_id: int, version: int) -> None:
|
||||
async def add_consec_login(self, user_id: int, version: int) -> None:
|
||||
sql = insert(consec_logins).values(user=user_id, version=version, logins=1)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(logins=consec_logins.c.logins + 1)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to update consecutive login count for user {user_id} version {version}"
|
||||
)
|
||||
|
||||
def get_consec_login(self, user_id: int, version: int) -> Optional[Row]:
|
||||
async def get_consec_login(self, user_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(consec_logins).where(
|
||||
and_(
|
||||
consec_logins.c.user == user_id,
|
||||
@ -824,12 +824,12 @@ class Mai2ProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def reset_consec_login(self, user_id: int, version: int) -> Optional[Row]:
|
||||
async def reset_consec_login(self, user_id: int, version: int) -> Optional[Row]:
|
||||
sql = consec_logins.update(
|
||||
and_(
|
||||
consec_logins.c.user == user_id,
|
||||
@ -837,7 +837,7 @@ class Mai2ProfileData(BaseData):
|
||||
)
|
||||
).values(logins=1)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -273,7 +273,7 @@ best_score_old = Table(
|
||||
)
|
||||
|
||||
class Mai2ScoreData(BaseData):
|
||||
def put_best_score(self, user_id: int, score_data: Dict, is_dx: bool = True) -> Optional[int]:
|
||||
async def put_best_score(self, user_id: int, score_data: Dict, is_dx: bool = True) -> Optional[int]:
|
||||
score_data["user"] = user_id
|
||||
|
||||
if is_dx:
|
||||
@ -282,7 +282,7 @@ class Mai2ScoreData(BaseData):
|
||||
sql = insert(best_score_old).values(**score_data)
|
||||
conflict = sql.on_duplicate_key_update(**score_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"put_best_score: Failed to insert best score! user_id {user_id} is_dx {is_dx}"
|
||||
@ -291,7 +291,7 @@ class Mai2ScoreData(BaseData):
|
||||
return result.lastrowid
|
||||
|
||||
@cached(2)
|
||||
def get_best_scores(self, user_id: int, song_id: int = None, is_dx: bool = True) -> Optional[List[Row]]:
|
||||
async def get_best_scores(self, user_id: int, song_id: int = None, is_dx: bool = True) -> Optional[List[Row]]:
|
||||
if is_dx:
|
||||
sql = best_score.select(
|
||||
and_(
|
||||
@ -307,12 +307,12 @@ class Mai2ScoreData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_best_score(
|
||||
async def get_best_score(
|
||||
self, user_id: int, song_id: int, chart_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = best_score.select(
|
||||
@ -323,12 +323,12 @@ class Mai2ScoreData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_playlog(self, user_id: int, playlog_data: Dict, is_dx: bool = True) -> Optional[int]:
|
||||
async def put_playlog(self, user_id: int, playlog_data: Dict, is_dx: bool = True) -> Optional[int]:
|
||||
playlog_data["user"] = user_id
|
||||
|
||||
if is_dx:
|
||||
@ -338,28 +338,28 @@ class Mai2ScoreData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**playlog_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"put_playlog: Failed to insert! user_id {user_id} is_dx {is_dx}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_course(self, user_id: int, course_data: Dict) -> Optional[int]:
|
||||
async def put_course(self, user_id: int, course_data: Dict) -> Optional[int]:
|
||||
course_data["user"] = user_id
|
||||
sql = insert(course).values(**course_data)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**course_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"put_course: Failed to insert! user_id {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_courses(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_courses(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = course.select(course.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -72,7 +72,7 @@ cards = Table(
|
||||
|
||||
|
||||
class Mai2StaticData(BaseData):
|
||||
def put_game_event(
|
||||
async def put_game_event(
|
||||
self, version: int, type: int, event_id: int, name: str
|
||||
) -> Optional[int]:
|
||||
sql = insert(event).values(
|
||||
@ -84,46 +84,46 @@ class Mai2StaticData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(eventId=event_id)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_game_event: Failed to insert event! event_id {event_id} type {type} name {name}"
|
||||
)
|
||||
return result.lastrowid
|
||||
|
||||
def get_game_events(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_game_events(self, version: int) -> Optional[List[Row]]:
|
||||
sql = event.select(event.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_enabled_events(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_events(self, version: int) -> Optional[List[Row]]:
|
||||
sql = select(event).where(
|
||||
and_(event.c.version == version, event.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def toggle_game_event(
|
||||
async def toggle_game_event(
|
||||
self, version: int, event_id: int, toggle: bool
|
||||
) -> Optional[List]:
|
||||
sql = event.update(
|
||||
and_(event.c.version == version, event.c.eventId == event_id)
|
||||
).values(enabled=int(toggle))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"toggle_game_event: Failed to update event! event_id {event_id} toggle {toggle}"
|
||||
)
|
||||
return result.last_updated_params()
|
||||
|
||||
def put_game_music(
|
||||
async def put_game_music(
|
||||
self,
|
||||
version: int,
|
||||
song_id: int,
|
||||
@ -159,13 +159,13 @@ class Mai2StaticData(BaseData):
|
||||
noteDesigner=note_designer,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert song {song_id} chart {chart_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_game_ticket(
|
||||
async def put_game_ticket(
|
||||
self,
|
||||
version: int,
|
||||
ticket_id: int,
|
||||
@ -185,13 +185,13 @@ class Mai2StaticData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(price=ticket_price)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert charge {ticket_id} type {ticket_type}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_enabled_tickets(
|
||||
async def get_enabled_tickets(
|
||||
self, version: int, kind: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
if kind is not None:
|
||||
@ -207,12 +207,12 @@ class Mai2StaticData(BaseData):
|
||||
and_(ticket.c.version == version, ticket.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_music_chart(
|
||||
async def get_music_chart(
|
||||
self, version: int, song_id: int, chart_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(music).where(
|
||||
@ -223,28 +223,28 @@ class Mai2StaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_card(self, version: int, card_id: int, card_name: str, **card_data) -> int:
|
||||
async def put_card(self, version: int, card_id: int, card_name: str, **card_data) -> int:
|
||||
sql = insert(cards).values(
|
||||
version=version, cardId=card_id, cardName=card_name, **card_data
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**card_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert card {card_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_enabled_cards(self, version: int) -> Optional[List[Row]]:
|
||||
async def get_enabled_cards(self, version: int) -> Optional[List[Row]]:
|
||||
sql = cards.select(and_(cards.c.version == version, cards.c.enabled == True))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -16,7 +16,7 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
self.version = Mai2Constants.VER_MAIMAI_DX_UNIVERSE
|
||||
|
||||
async def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
@ -32,9 +32,9 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
|
||||
async def handle_cm_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
# user already exists, because the preview checks that already
|
||||
p = self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_detail(data["userId"], self.version)
|
||||
|
||||
cards = self.data.card.get_user_cards(data["userId"])
|
||||
cards = await self.data.card.get_user_cards(data["userId"])
|
||||
if cards is None or len(cards) == 0:
|
||||
# This should never happen
|
||||
self.logger.error(
|
||||
@ -59,7 +59,7 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
return {"returnCode": 1}
|
||||
|
||||
async def handle_cm_get_selling_card_api_request(self, data: Dict) -> Dict:
|
||||
selling_cards = self.data.static.get_enabled_cards(self.version)
|
||||
selling_cards = await self.data.static.get_enabled_cards(self.version)
|
||||
if selling_cards is None:
|
||||
return {"length": 0, "sellingCardList": []}
|
||||
|
||||
@ -89,7 +89,7 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
return {"length": len(selling_card_list), "sellingCardList": selling_card_list}
|
||||
|
||||
async def handle_cm_get_user_card_api_request(self, data: Dict) -> Dict:
|
||||
user_cards = self.data.item.get_cards(data["userId"])
|
||||
user_cards = await self.data.item.get_cards(data["userId"])
|
||||
if user_cards is None:
|
||||
return {"returnCode": 1, "length": 0, "nextIndex": 0, "userCardList": []}
|
||||
|
||||
@ -128,7 +128,7 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
super().handle_get_user_item_api_request(data)
|
||||
|
||||
async def handle_cm_get_user_character_api_request(self, data: Dict) -> Dict:
|
||||
characters = self.data.item.get_characters(data["userId"])
|
||||
characters = await self.data.item.get_characters(data["userId"])
|
||||
|
||||
chara_list = []
|
||||
for chara in characters:
|
||||
@ -168,7 +168,7 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
end_date = datetime.utcnow() + timedelta(days=15)
|
||||
|
||||
user_card = upsert["userCard"]
|
||||
self.data.item.put_card(
|
||||
await self.data.item.put_card(
|
||||
user_id,
|
||||
user_card["cardId"],
|
||||
user_card["cardTypeId"],
|
||||
@ -180,7 +180,7 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
)
|
||||
|
||||
# get the profile extend to save the new bought card
|
||||
extend = self.data.profile.get_profile_extend(user_id, self.version)
|
||||
extend = await self.data.profile.get_profile_extend(user_id, self.version)
|
||||
if extend:
|
||||
extend = extend._asdict()
|
||||
# parse the selectedCardList
|
||||
@ -192,14 +192,14 @@ class Mai2Universe(Mai2SplashPlus):
|
||||
selected_cards.insert(0, user_card["cardTypeId"])
|
||||
|
||||
extend["selectedCardList"] = selected_cards
|
||||
self.data.profile.put_profile_extend(user_id, self.version, extend)
|
||||
await self.data.profile.put_profile_extend(user_id, self.version, extend)
|
||||
|
||||
# properly format userPrintDetail for the database
|
||||
upsert.pop("userCard")
|
||||
upsert.pop("serialId")
|
||||
upsert["printDate"] = datetime.strptime(upsert["printDate"], "%Y-%m-%d")
|
||||
|
||||
self.data.item.put_user_print_detail(user_id, serial_id, upsert)
|
||||
await self.data.item.put_user_print_detail(user_id, serial_id, upsert)
|
||||
|
||||
return {
|
||||
"returnCode": 1,
|
||||
|
@ -157,7 +157,7 @@ class OngekiBase:
|
||||
return {"type": data["type"], "length": 0, "gameIdlistList": []}
|
||||
|
||||
async def handle_get_game_ranking_api_request(self, data: Dict) -> Dict:
|
||||
game_ranking_list = self.data.static.get_ranking_list(self.version)
|
||||
game_ranking_list = await self.data.static.get_ranking_list(self.version)
|
||||
|
||||
ranking_list = []
|
||||
for music in game_ranking_list:
|
||||
@ -172,13 +172,13 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_game_point_api_request(self, data: Dict) -> Dict:
|
||||
get_game_point = self.data.static.get_static_game_point()
|
||||
get_game_point = await self.data.static.get_static_game_point()
|
||||
game_point = []
|
||||
|
||||
if not get_game_point:
|
||||
self.logger.info(f"GP table is empty, inserting defaults")
|
||||
self.data.static.put_static_game_point_defaults()
|
||||
get_game_point = self.data.static.get_static_game_point()
|
||||
await self.data.static.put_static_game_point_defaults()
|
||||
get_game_point = await self.data.static.get_static_game_point()
|
||||
for gp in get_game_point:
|
||||
tmp = gp._asdict()
|
||||
game_point.append(tmp)
|
||||
@ -204,7 +204,7 @@ class OngekiBase:
|
||||
return {"returnCode": 1, "apiName": "ExtendLockTimeApi"}
|
||||
|
||||
async def handle_get_game_reward_api_request(self, data: Dict) -> Dict:
|
||||
get_game_rewards = self.data.static.get_reward_list(self.version)
|
||||
get_game_rewards = await self.data.static.get_reward_list(self.version)
|
||||
|
||||
reward_list = []
|
||||
for reward in get_game_rewards:
|
||||
@ -222,7 +222,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_game_present_api_request(self, data: Dict) -> Dict:
|
||||
get_present = self.data.static.get_present_list(self.version)
|
||||
get_present = await self.data.static.get_present_list(self.version)
|
||||
|
||||
present_list = []
|
||||
for present in get_present:
|
||||
@ -245,7 +245,7 @@ class OngekiBase:
|
||||
return {"length": 0, "gameSaleList": []}
|
||||
|
||||
async def handle_get_game_tech_music_api_request(self, data: Dict) -> Dict:
|
||||
music_list = self.data.static.get_tech_music(self.version)
|
||||
music_list = await self.data.static.get_tech_music(self.version)
|
||||
|
||||
prep_music_list = []
|
||||
for music in music_list:
|
||||
@ -268,9 +268,9 @@ class OngekiBase:
|
||||
|
||||
client_id = data["clientId"]
|
||||
client_setting_data = data["clientSetting"]
|
||||
cab = self.data.arcade.get_machine(client_id)
|
||||
cab = await self.data.arcade.get_machine(client_id)
|
||||
if cab is not None:
|
||||
self.data.static.put_client_setting_data(cab['id'], client_setting_data)
|
||||
await self.data.static.put_client_setting_data(cab['id'], client_setting_data)
|
||||
return {"returnCode": 1, "apiName": "UpsertClientSettingApi"}
|
||||
|
||||
async def handle_upsert_client_testmode_api_request(self, data: Dict) -> Dict:
|
||||
@ -279,7 +279,7 @@ class OngekiBase:
|
||||
|
||||
region_id = data["regionId"]
|
||||
client_testmode_data = data["clientTestmode"]
|
||||
self.data.static.put_client_testmode_data(region_id, client_testmode_data)
|
||||
await self.data.static.put_client_testmode_data(region_id, client_testmode_data)
|
||||
return {"returnCode": 1, "apiName": "UpsertClientTestmodeApi"}
|
||||
|
||||
async def handle_upsert_client_bookkeeping_api_request(self, data: Dict) -> Dict:
|
||||
@ -296,7 +296,7 @@ class OngekiBase:
|
||||
if user >= 200000000000000: # Account for guest play
|
||||
user = None
|
||||
|
||||
self.data.log.put_gp_log(
|
||||
await self.data.log.put_gp_log(
|
||||
user,
|
||||
data["usedCredit"],
|
||||
data["placeName"],
|
||||
@ -313,7 +313,7 @@ class OngekiBase:
|
||||
return {"returnCode": 1, "apiName": "ExtendLockTimeApi"}
|
||||
|
||||
async def handle_get_game_event_api_request(self, data: Dict) -> Dict:
|
||||
evts = self.data.static.get_enabled_events(self.version)
|
||||
evts = await self.data.static.get_enabled_events(self.version)
|
||||
|
||||
if evts is None:
|
||||
return {
|
||||
@ -366,7 +366,7 @@ class OngekiBase:
|
||||
return {"userId": data["userId"], "length": 0, "userRegionList": []}
|
||||
|
||||
async def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
|
||||
profile = self.data.profile.get_profile_preview(data["userId"], self.version)
|
||||
profile = await self.data.profile.get_profile_preview(data["userId"], self.version)
|
||||
|
||||
if profile is None:
|
||||
return {
|
||||
@ -422,7 +422,7 @@ class OngekiBase:
|
||||
Gets the number of AB and ABPs a player has per-difficulty (7, 7+, 8, etc)
|
||||
The game sends this in upsert so we don't have to calculate it all out thankfully
|
||||
"""
|
||||
utcl = self.data.score.get_tech_count(data["userId"])
|
||||
utcl = await self.data.score.get_tech_count(data["userId"])
|
||||
userTechCountList = []
|
||||
|
||||
for tc in utcl:
|
||||
@ -437,7 +437,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_tech_event_api_request(self, data: Dict) -> Dict:
|
||||
user_tech_event_list = self.data.item.get_tech_event(self.version, data["userId"])
|
||||
user_tech_event_list = await self.data.item.get_tech_event(self.version, data["userId"])
|
||||
if user_tech_event_list is None:
|
||||
return {}
|
||||
|
||||
@ -456,7 +456,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_tech_event_ranking_api_request(self, data: Dict) -> Dict:
|
||||
user_tech_event_ranks = self.data.item.get_tech_event_ranking(self.version, data["userId"])
|
||||
user_tech_event_ranks = await self.data.item.get_tech_event_ranking(self.version, data["userId"])
|
||||
if user_tech_event_ranks is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -482,7 +482,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_kop_api_request(self, data: Dict) -> Dict:
|
||||
kop_list = self.data.profile.get_kop(data["userId"])
|
||||
kop_list = await self.data.profile.get_kop(data["userId"])
|
||||
if kop_list is None:
|
||||
return {}
|
||||
|
||||
@ -518,7 +518,7 @@ class OngekiBase:
|
||||
|
||||
async def handle_get_user_item_api_request(self, data: Dict) -> Dict:
|
||||
kind = data["nextIndex"] / 10000000000
|
||||
p = self.data.item.get_items(data["userId"], kind)
|
||||
p = await self.data.item.get_items(data["userId"], kind)
|
||||
|
||||
if p is None:
|
||||
return {
|
||||
@ -553,7 +553,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_option_api_request(self, data: Dict) -> Dict:
|
||||
o = self.data.profile.get_profile_options(data["userId"])
|
||||
o = await self.data.profile.get_profile_options(data["userId"])
|
||||
if o is None:
|
||||
return {}
|
||||
|
||||
@ -567,11 +567,11 @@ class OngekiBase:
|
||||
return {"userId": data["userId"], "userOption": user_opts}
|
||||
|
||||
async def handle_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
cards = self.data.card.get_user_cards(data["userId"])
|
||||
cards = await self.data.card.get_user_cards(data["userId"])
|
||||
if cards is None or len(cards) == 0:
|
||||
# This should never happen
|
||||
self.logger.error(
|
||||
@ -595,7 +595,7 @@ class OngekiBase:
|
||||
return {"userId": data["userId"], "userData": user_data}
|
||||
|
||||
async def handle_get_user_event_ranking_api_request(self, data: Dict) -> Dict:
|
||||
user_event_ranking_list = self.data.item.get_ranking_event_ranks(self.version, data["userId"])
|
||||
user_event_ranking_list = await self.data.item.get_ranking_event_ranks(self.version, data["userId"])
|
||||
if user_event_ranking_list is None:
|
||||
return {}
|
||||
|
||||
@ -618,7 +618,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
|
||||
user_login_bonus_list = self.data.item.get_login_bonuses(data["userId"])
|
||||
user_login_bonus_list = await self.data.item.get_login_bonuses(data["userId"])
|
||||
if user_login_bonus_list is None:
|
||||
return {}
|
||||
|
||||
@ -636,7 +636,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_bp_base_request(self, data: Dict) -> Dict:
|
||||
p = self.data.profile.get_profile(
|
||||
p = await self.data.profile.get_profile(
|
||||
self.game, self.version, user_id=data["userId"]
|
||||
)
|
||||
if p is None:
|
||||
@ -649,7 +649,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_recent_rating_api_request(self, data: Dict) -> Dict:
|
||||
recent_rating = self.data.profile.get_profile_recent_rating(data["userId"])
|
||||
recent_rating = await self.data.profile.get_profile_recent_rating(data["userId"])
|
||||
if recent_rating is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -666,7 +666,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_activity_api_request(self, data: Dict) -> Dict:
|
||||
activity = self.data.profile.get_profile_activity(data["userId"], data["kind"])
|
||||
activity = await self.data.profile.get_profile_activity(data["userId"], data["kind"])
|
||||
if activity is None:
|
||||
return {}
|
||||
|
||||
@ -693,7 +693,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_story_api_request(self, data: Dict) -> Dict:
|
||||
user_stories = self.data.item.get_stories(data["userId"])
|
||||
user_stories = await self.data.item.get_stories(data["userId"])
|
||||
if user_stories is None:
|
||||
return {}
|
||||
|
||||
@ -711,7 +711,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_chapter_api_request(self, data: Dict) -> Dict:
|
||||
user_chapters = self.data.item.get_chapters(data["userId"])
|
||||
user_chapters = await self.data.item.get_chapters(data["userId"])
|
||||
if user_chapters is None:
|
||||
return {}
|
||||
|
||||
@ -736,7 +736,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_character_api_request(self, data: Dict) -> Dict:
|
||||
user_characters = self.data.item.get_characters(data["userId"])
|
||||
user_characters = await self.data.item.get_characters(data["userId"])
|
||||
if user_characters is None:
|
||||
return {}
|
||||
|
||||
@ -754,7 +754,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_card_api_request(self, data: Dict) -> Dict:
|
||||
user_cards = self.data.item.get_cards(data["userId"])
|
||||
user_cards = await self.data.item.get_cards(data["userId"])
|
||||
if user_cards is None:
|
||||
return {}
|
||||
|
||||
@ -773,7 +773,7 @@ class OngekiBase:
|
||||
|
||||
async def handle_get_user_deck_by_key_api_request(self, data: Dict) -> Dict:
|
||||
# Auth key doesn't matter, it just wants all the decks
|
||||
decks = self.data.item.get_decks(data["userId"])
|
||||
decks = await self.data.item.get_decks(data["userId"])
|
||||
if decks is None:
|
||||
return {}
|
||||
|
||||
@ -791,7 +791,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_trade_item_api_request(self, data: Dict) -> Dict:
|
||||
user_trade_items = self.data.item.get_trade_items(data["userId"])
|
||||
user_trade_items = await self.data.item.get_trade_items(data["userId"])
|
||||
if user_trade_items is None:
|
||||
return {}
|
||||
|
||||
@ -809,7 +809,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_scenario_api_request(self, data: Dict) -> Dict:
|
||||
user_scenerio = self.data.item.get_scenerios(data["userId"])
|
||||
user_scenerio = await self.data.item.get_scenerios(data["userId"])
|
||||
if user_scenerio is None:
|
||||
return {}
|
||||
|
||||
@ -827,7 +827,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_ratinglog_api_request(self, data: Dict) -> Dict:
|
||||
rating_log = self.data.profile.get_profile_rating_log(data["userId"])
|
||||
rating_log = await self.data.profile.get_profile_rating_log(data["userId"])
|
||||
if rating_log is None:
|
||||
return {}
|
||||
|
||||
@ -845,7 +845,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_mission_point_api_request(self, data: Dict) -> Dict:
|
||||
user_mission_point_list = self.data.item.get_mission_points(self.version, data["userId"])
|
||||
user_mission_point_list = await self.data.item.get_mission_points(self.version, data["userId"])
|
||||
if user_mission_point_list is None:
|
||||
return {}
|
||||
|
||||
@ -865,7 +865,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_event_point_api_request(self, data: Dict) -> Dict:
|
||||
user_event_point_list = self.data.item.get_event_points(data["userId"])
|
||||
user_event_point_list = await self.data.item.get_event_points(data["userId"])
|
||||
if user_event_point_list is None:
|
||||
return {}
|
||||
|
||||
@ -887,7 +887,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_music_item_api_request(self, data: Dict) -> Dict:
|
||||
user_music_item_list = self.data.item.get_music_items(data["userId"])
|
||||
user_music_item_list = await self.data.item.get_music_items(data["userId"])
|
||||
if user_music_item_list is None:
|
||||
return {}
|
||||
|
||||
@ -905,7 +905,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_event_music_api_request(self, data: Dict) -> Dict:
|
||||
user_evt_music_list = self.data.item.get_event_music(data["userId"])
|
||||
user_evt_music_list = await self.data.item.get_event_music(data["userId"])
|
||||
if user_evt_music_list is None:
|
||||
return {}
|
||||
|
||||
@ -923,7 +923,7 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
async def handle_get_user_boss_api_request(self, data: Dict) -> Dict:
|
||||
p = self.data.item.get_bosses(data["userId"])
|
||||
p = await self.data.item.get_bosses(data["userId"])
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
@ -947,20 +947,20 @@ class OngekiBase:
|
||||
# The isNew fields are new as of Red and up. We just won't use them for now.
|
||||
|
||||
if "userData" in upsert and len(upsert["userData"]) > 0:
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
|
||||
if "userOption" in upsert and len(upsert["userOption"]) > 0:
|
||||
self.data.profile.put_profile_options(user_id, upsert["userOption"][0])
|
||||
await self.data.profile.put_profile_options(user_id, upsert["userOption"][0])
|
||||
|
||||
if "userPlaylogList" in upsert:
|
||||
for playlog in upsert["userPlaylogList"]:
|
||||
self.data.score.put_playlog(user_id, playlog)
|
||||
await self.data.score.put_playlog(user_id, playlog)
|
||||
|
||||
if "userActivityList" in upsert:
|
||||
for act in upsert["userActivityList"]:
|
||||
self.data.profile.put_profile_activity(
|
||||
await self.data.profile.put_profile_activity(
|
||||
user_id,
|
||||
act["kind"],
|
||||
act["id"],
|
||||
@ -972,101 +972,101 @@ class OngekiBase:
|
||||
)
|
||||
|
||||
if "userRecentRatingList" in upsert:
|
||||
self.data.profile.put_profile_recent_rating(
|
||||
await self.data.profile.put_profile_recent_rating(
|
||||
user_id, upsert["userRecentRatingList"]
|
||||
)
|
||||
|
||||
if "userBpBaseList" in upsert:
|
||||
self.data.profile.put_profile_bp_list(user_id, upsert["userBpBaseList"])
|
||||
await self.data.profile.put_profile_bp_list(user_id, upsert["userBpBaseList"])
|
||||
|
||||
if "userMusicDetailList" in upsert:
|
||||
for x in upsert["userMusicDetailList"]:
|
||||
self.data.score.put_best_score(user_id, x)
|
||||
await self.data.score.put_best_score(user_id, x)
|
||||
|
||||
if "userCharacterList" in upsert:
|
||||
for x in upsert["userCharacterList"]:
|
||||
self.data.item.put_character(user_id, x)
|
||||
await self.data.item.put_character(user_id, x)
|
||||
|
||||
if "userCardList" in upsert:
|
||||
for x in upsert["userCardList"]:
|
||||
self.data.item.put_card(user_id, x)
|
||||
await self.data.item.put_card(user_id, x)
|
||||
|
||||
if "userDeckList" in upsert:
|
||||
for x in upsert["userDeckList"]:
|
||||
self.data.item.put_deck(user_id, x)
|
||||
await self.data.item.put_deck(user_id, x)
|
||||
|
||||
if "userTrainingRoomList" in upsert:
|
||||
for x in upsert["userTrainingRoomList"]:
|
||||
self.data.profile.put_training_room(user_id, x)
|
||||
await self.data.profile.put_training_room(user_id, x)
|
||||
|
||||
if "userStoryList" in upsert:
|
||||
for x in upsert["userStoryList"]:
|
||||
self.data.item.put_story(user_id, x)
|
||||
await self.data.item.put_story(user_id, x)
|
||||
|
||||
if "userChapterList" in upsert:
|
||||
for x in upsert["userChapterList"]:
|
||||
self.data.item.put_chapter(user_id, x)
|
||||
await self.data.item.put_chapter(user_id, x)
|
||||
|
||||
if "userMemoryChapterList" in upsert:
|
||||
for x in upsert["userMemoryChapterList"]:
|
||||
self.data.item.put_memorychapter(user_id, x)
|
||||
await self.data.item.put_memorychapter(user_id, x)
|
||||
|
||||
if "userItemList" in upsert:
|
||||
for x in upsert["userItemList"]:
|
||||
self.data.item.put_item(user_id, x)
|
||||
await self.data.item.put_item(user_id, x)
|
||||
|
||||
if "userMusicItemList" in upsert:
|
||||
for x in upsert["userMusicItemList"]:
|
||||
self.data.item.put_music_item(user_id, x)
|
||||
await self.data.item.put_music_item(user_id, x)
|
||||
|
||||
if "userLoginBonusList" in upsert:
|
||||
for x in upsert["userLoginBonusList"]:
|
||||
self.data.item.put_login_bonus(user_id, x)
|
||||
await self.data.item.put_login_bonus(user_id, x)
|
||||
|
||||
if "userEventPointList" in upsert:
|
||||
for x in upsert["userEventPointList"]:
|
||||
self.data.item.put_event_point(user_id, self.version, x)
|
||||
await self.data.item.put_event_point(user_id, self.version, x)
|
||||
|
||||
if "userMissionPointList" in upsert:
|
||||
for x in upsert["userMissionPointList"]:
|
||||
self.data.item.put_mission_point(user_id, self.version, x)
|
||||
await self.data.item.put_mission_point(user_id, self.version, x)
|
||||
|
||||
if "userRatinglogList" in upsert:
|
||||
for x in upsert["userRatinglogList"]:
|
||||
self.data.profile.put_profile_rating_log(
|
||||
await self.data.profile.put_profile_rating_log(
|
||||
user_id, x["dataVersion"], x["highestRating"]
|
||||
)
|
||||
|
||||
if "userBossList" in upsert:
|
||||
for x in upsert["userBossList"]:
|
||||
self.data.item.put_boss(user_id, x)
|
||||
await self.data.item.put_boss(user_id, x)
|
||||
|
||||
if "userTechCountList" in upsert:
|
||||
for x in upsert["userTechCountList"]:
|
||||
self.data.score.put_tech_count(user_id, x)
|
||||
await self.data.score.put_tech_count(user_id, x)
|
||||
|
||||
if "userScenerioList" in upsert:
|
||||
for x in upsert["userScenerioList"]:
|
||||
self.data.item.put_scenerio(user_id, x)
|
||||
await self.data.item.put_scenerio(user_id, x)
|
||||
|
||||
if "userTradeItemList" in upsert:
|
||||
for x in upsert["userTradeItemList"]:
|
||||
self.data.item.put_trade_item(user_id, x)
|
||||
await self.data.item.put_trade_item(user_id, x)
|
||||
|
||||
if "userEventMusicList" in upsert:
|
||||
for x in upsert["userEventMusicList"]:
|
||||
self.data.item.put_event_music(user_id, x)
|
||||
await self.data.item.put_event_music(user_id, x)
|
||||
|
||||
if "userTechEventList" in upsert:
|
||||
for x in upsert["userTechEventList"]:
|
||||
self.data.item.put_tech_event(user_id, self.version, x)
|
||||
await self.data.item.put_tech_event(user_id, self.version, x)
|
||||
|
||||
# This should be updated once a day in maintenance window, but for time being we will push the update on each upsert
|
||||
self.data.item.put_tech_event_ranking(user_id, self.version, x)
|
||||
await self.data.item.put_tech_event_ranking(user_id, self.version, x)
|
||||
|
||||
if "userKopList" in upsert:
|
||||
for x in upsert["userKopList"]:
|
||||
self.data.profile.put_kop(user_id, x)
|
||||
await self.data.profile.put_kop(user_id, x)
|
||||
|
||||
return {"returnCode": 1, "apiName": "upsertUserAll"}
|
||||
|
||||
@ -1076,7 +1076,7 @@ class OngekiBase:
|
||||
"""
|
||||
|
||||
rival_list = []
|
||||
user_rivals = self.data.profile.get_rivals(data["userId"])
|
||||
user_rivals = await self.data.profile.get_rivals(data["userId"])
|
||||
for rival in user_rivals:
|
||||
tmp = {}
|
||||
tmp["rivalUserId"] = rival[0]
|
||||
@ -1100,7 +1100,7 @@ class OngekiBase:
|
||||
"""
|
||||
rivals = []
|
||||
for rival in data["userRivalList"]:
|
||||
name = self.data.profile.get_profile_name(
|
||||
name = await self.data.profile.get_profile_name(
|
||||
rival["rivalUserId"], self.version
|
||||
)
|
||||
if name is None:
|
||||
@ -1135,8 +1135,8 @@ class OngekiBase:
|
||||
}
|
||||
|
||||
@cached(2)
|
||||
def util_generate_music_list(self, user_id: int) -> List:
|
||||
music_detail = self.data.score.get_best_scores(user_id)
|
||||
async def util_generate_music_list(self, user_id: int) -> List:
|
||||
music_detail = await self.data.score.get_best_scores(user_id)
|
||||
song_list = []
|
||||
|
||||
for md in music_detail:
|
||||
|
@ -23,11 +23,11 @@ class OngekiBright(OngekiBase):
|
||||
|
||||
async def handle_cm_get_user_data_api_request(self, data: Dict) -> Dict:
|
||||
# check for a bright profile
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is None:
|
||||
return {}
|
||||
|
||||
cards = self.data.card.get_user_cards(data["userId"])
|
||||
cards = await self.data.card.get_user_cards(data["userId"])
|
||||
if cards is None or len(cards) == 0:
|
||||
# This should never happen
|
||||
self.logger.error(
|
||||
@ -62,7 +62,7 @@ class OngekiBright(OngekiBase):
|
||||
return {"returnCode": 1}
|
||||
|
||||
async def handle_cm_get_user_card_api_request(self, data: Dict) -> Dict:
|
||||
user_cards = self.data.item.get_cards(data["userId"])
|
||||
user_cards = await self.data.item.get_cards(data["userId"])
|
||||
if user_cards is None:
|
||||
return {}
|
||||
|
||||
@ -91,7 +91,7 @@ class OngekiBright(OngekiBase):
|
||||
}
|
||||
|
||||
async def handle_cm_get_user_character_api_request(self, data: Dict) -> Dict:
|
||||
user_characters = self.data.item.get_characters(data["userId"])
|
||||
user_characters = await self.data.item.get_characters(data["userId"])
|
||||
if user_characters is None:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
@ -125,7 +125,7 @@ class OngekiBright(OngekiBase):
|
||||
}
|
||||
|
||||
async def handle_get_user_gacha_api_request(self, data: Dict) -> Dict:
|
||||
user_gachas = self.data.item.get_user_gachas(data["userId"])
|
||||
user_gachas = await self.data.item.get_user_gachas(data["userId"])
|
||||
if user_gachas is None:
|
||||
return {"userId": data["userId"], "length": 0, "userGachaList": []}
|
||||
|
||||
@ -148,7 +148,7 @@ class OngekiBright(OngekiBase):
|
||||
|
||||
async def handle_cm_get_user_gacha_supply_api_request(self, data: Dict) -> Dict:
|
||||
# not used for now? not sure what it even does
|
||||
user_gacha_supplies = self.data.item.get_user_gacha_supplies(data["userId"])
|
||||
user_gacha_supplies = await self.data.item.get_user_gacha_supplies(data["userId"])
|
||||
if user_gacha_supplies is None:
|
||||
return {"supplyId": 1, "length": 0, "supplyCardList": []}
|
||||
|
||||
@ -168,7 +168,7 @@ class OngekiBright(OngekiBase):
|
||||
game_gachas = []
|
||||
# for every gacha_id in the OngekiConfig, grab the banner from the db
|
||||
for gacha_id in self.game_cfg.gachas.enabled_gachas:
|
||||
game_gacha = self.data.static.get_gacha(self.version, gacha_id)
|
||||
game_gacha = await self.data.static.get_gacha(self.version, gacha_id)
|
||||
if game_gacha:
|
||||
game_gachas.append(game_gacha)
|
||||
|
||||
@ -265,26 +265,26 @@ class OngekiBright(OngekiBase):
|
||||
return self.handle_roll_gacha_api_request(data)
|
||||
|
||||
# get a list of cards for each rarity
|
||||
cards_r = self.data.static.get_cards_by_rarity(self.version, 1)
|
||||
cards_r = await self.data.static.get_cards_by_rarity(self.version, 1)
|
||||
cards_sr, cards_ssr = [], []
|
||||
|
||||
# free gachas are only allowed to get their specific cards! (R irrelevant)
|
||||
if gacha_id in {1011, 1012}:
|
||||
gacha_cards = self.data.static.get_gacha_cards(gacha_id)
|
||||
gacha_cards = await self.data.static.get_gacha_cards(gacha_id)
|
||||
for card in gacha_cards:
|
||||
if card["rarity"] == 3:
|
||||
cards_sr.append({"cardId": card["cardId"], "rarity": 2})
|
||||
elif card["rarity"] == 4:
|
||||
cards_ssr.append({"cardId": card["cardId"], "rarity": 3})
|
||||
else:
|
||||
cards_sr = self.data.static.get_cards_by_rarity(self.version, 2)
|
||||
cards_ssr = self.data.static.get_cards_by_rarity(self.version, 3)
|
||||
cards_sr = await self.data.static.get_cards_by_rarity(self.version, 2)
|
||||
cards_ssr = await self.data.static.get_cards_by_rarity(self.version, 3)
|
||||
|
||||
# get the promoted cards for that gacha and add them multiple
|
||||
# times to increase chances by factor chances
|
||||
chances = 10
|
||||
|
||||
gacha_cards = self.data.static.get_gacha_cards(gacha_id)
|
||||
gacha_cards = await self.data.static.get_gacha_cards(gacha_id)
|
||||
for card in gacha_cards:
|
||||
# make sure to add the cards to the corresponding rarity
|
||||
if card["rarity"] == 2:
|
||||
@ -339,7 +339,7 @@ class OngekiBright(OngekiBase):
|
||||
daily_gacha_date = datetime.strptime("2000-01-01", "%Y-%m-%d")
|
||||
|
||||
# check if the user previously rolled the exact same gacha
|
||||
user_gacha = self.data.item.get_user_gacha(user_id, gacha_id)
|
||||
user_gacha = await self.data.item.get_user_gacha(user_id, gacha_id)
|
||||
if user_gacha:
|
||||
total_gacha_count = user_gacha["totalGachaCnt"]
|
||||
ceiling_gacha_count = user_gacha["ceilingGachaCnt"]
|
||||
@ -358,7 +358,7 @@ class OngekiBright(OngekiBase):
|
||||
daily_gacha_date = play_date
|
||||
daily_gacha_cnt = 0
|
||||
|
||||
self.data.item.put_user_gacha(
|
||||
await self.data.item.put_user_gacha(
|
||||
user_id,
|
||||
gacha_id,
|
||||
totalGachaCnt=total_gacha_count + gacha_count,
|
||||
@ -375,29 +375,29 @@ class OngekiBright(OngekiBase):
|
||||
|
||||
if "userData" in upsert and len(upsert["userData"]) > 0:
|
||||
# check if the profile is a bright memory profile
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is not None:
|
||||
# save the bright memory profile
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
else:
|
||||
# save the bright profile
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
|
||||
if "userCharacterList" in upsert:
|
||||
for x in upsert["userCharacterList"]:
|
||||
self.data.item.put_character(user_id, x)
|
||||
await self.data.item.put_character(user_id, x)
|
||||
|
||||
if "userItemList" in upsert:
|
||||
for x in upsert["userItemList"]:
|
||||
self.data.item.put_item(user_id, x)
|
||||
await self.data.item.put_item(user_id, x)
|
||||
|
||||
if "userCardList" in upsert:
|
||||
for x in upsert["userCardList"]:
|
||||
self.data.item.put_card(user_id, x)
|
||||
await self.data.item.put_card(user_id, x)
|
||||
|
||||
# TODO?
|
||||
# if "gameGachaCardList" in upsert:
|
||||
@ -411,29 +411,29 @@ class OngekiBright(OngekiBase):
|
||||
|
||||
if "userData" in upsert and len(upsert["userData"]) > 0:
|
||||
# check if the profile is a bright memory profile
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is not None:
|
||||
# save the bright memory profile
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
else:
|
||||
# save the bright profile
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
|
||||
if "userCharacterList" in upsert:
|
||||
for x in upsert["userCharacterList"]:
|
||||
self.data.item.put_character(user_id, x)
|
||||
await self.data.item.put_character(user_id, x)
|
||||
|
||||
if "userCardList" in upsert:
|
||||
for x in upsert["userCardList"]:
|
||||
self.data.item.put_card(user_id, x)
|
||||
await self.data.item.put_card(user_id, x)
|
||||
|
||||
if "selectGachaLogList" in data:
|
||||
for x in data["selectGachaLogList"]:
|
||||
self.data.item.put_user_gacha(
|
||||
await self.data.item.put_user_gacha(
|
||||
user_id,
|
||||
x["gachaId"],
|
||||
selectPoint=0,
|
||||
@ -443,7 +443,7 @@ class OngekiBright(OngekiBase):
|
||||
return {"returnCode": 1, "apiName": "cmUpsertUserSelectGacha"}
|
||||
|
||||
async def handle_get_game_gacha_card_by_id_api_request(self, data: Dict) -> Dict:
|
||||
game_gacha_cards = self.data.static.get_gacha_cards(data["gachaId"])
|
||||
game_gacha_cards = await self.data.static.get_gacha_cards(data["gachaId"])
|
||||
if game_gacha_cards == []:
|
||||
# fallback to be at least able to select that gacha
|
||||
return {
|
||||
@ -579,7 +579,7 @@ class OngekiBright(OngekiBase):
|
||||
)
|
||||
|
||||
# add the entry to the user print table with the random serialId
|
||||
self.data.item.put_user_print_detail(
|
||||
await self.data.item.put_user_print_detail(
|
||||
data["userId"], serial_id, user_print_detail
|
||||
)
|
||||
|
||||
@ -595,21 +595,21 @@ class OngekiBright(OngekiBase):
|
||||
|
||||
if "userData" in upsert and len(upsert["userData"]) > 0:
|
||||
# check if the profile is a bright memory profile
|
||||
p = self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
p = await self.data.profile.get_profile_data(data["userId"], self.version)
|
||||
if p is not None:
|
||||
# save the bright memory profile
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
else:
|
||||
# save the bright profile
|
||||
self.data.profile.put_profile_data(
|
||||
await self.data.profile.put_profile_data(
|
||||
user_id, self.version, upsert["userData"][0]
|
||||
)
|
||||
|
||||
if "userActivityList" in upsert:
|
||||
for act in upsert["userActivityList"]:
|
||||
self.data.profile.put_profile_activity(
|
||||
await self.data.profile.put_profile_activity(
|
||||
user_id,
|
||||
act["kind"],
|
||||
act["id"],
|
||||
@ -622,10 +622,10 @@ class OngekiBright(OngekiBase):
|
||||
|
||||
if "userItemList" in upsert:
|
||||
for x in upsert["userItemList"]:
|
||||
self.data.item.put_item(user_id, x)
|
||||
await self.data.item.put_item(user_id, x)
|
||||
|
||||
if "userCardList" in upsert:
|
||||
for x in upsert["userCardList"]:
|
||||
self.data.item.put_card(user_id, x)
|
||||
await self.data.item.put_card(user_id, x)
|
||||
|
||||
return {"returnCode": 1, "apiName": "cmUpsertUserAll"}
|
||||
|
@ -28,7 +28,7 @@ class OngekiBrightMemory(OngekiBright):
|
||||
return ret
|
||||
|
||||
async def handle_get_user_memory_chapter_api_request(self, data: Dict) -> Dict:
|
||||
memories = self.data.item.get_memorychapters(data["userId"])
|
||||
memories = await self.data.item.get_memorychapters(data["userId"])
|
||||
if not memories:
|
||||
return {
|
||||
"userId": data["userId"],
|
||||
|
@ -28,7 +28,7 @@ class OngekiFrontend(FE_Base):
|
||||
self.nav_name = "O.N.G.E.K.I."
|
||||
self.version_list = OngekiConstants.VERSION_NAMES
|
||||
|
||||
def render_GET(self, request: Request) -> bytes:
|
||||
async def render_GET(self, request: Request) -> bytes:
|
||||
template = self.environment.get_template(
|
||||
"titles/ongeki/frontend/ongeki_index.jinja"
|
||||
)
|
||||
@ -37,7 +37,7 @@ class OngekiFrontend(FE_Base):
|
||||
self.version = usr_sesh.ongeki_version
|
||||
if getattr(usr_sesh, "userId", 0) != 0:
|
||||
profile_data =self.data.profile.get_profile_data(usr_sesh.userId, self.version)
|
||||
rival_list = self.data.profile.get_rivals(usr_sesh.userId)
|
||||
rival_list = await self.data.profile.get_rivals(usr_sesh.userId)
|
||||
rival_data = {
|
||||
"userRivalList": rival_list,
|
||||
"userId": usr_sesh.userId
|
||||
@ -58,20 +58,20 @@ class OngekiFrontend(FE_Base):
|
||||
else:
|
||||
return redirectTo(b"/gate/", request)
|
||||
|
||||
def render_POST(self, request: Request):
|
||||
async def render_POST(self, request: Request):
|
||||
uri = request.uri.decode()
|
||||
sesh: Session = request.getSession()
|
||||
usr_sesh = IUserSession(sesh)
|
||||
if hasattr(usr_sesh, "userId"):
|
||||
if uri == "/game/ongeki/rival.add":
|
||||
rival_id = request.args[b"rivalUserId"][0].decode()
|
||||
self.data.profile.put_rival(usr_sesh.userId, rival_id)
|
||||
await self.data.profile.put_rival(usr_sesh.userId, rival_id)
|
||||
# self.logger.info(f"{usr_sesh.userId} added a rival")
|
||||
return redirectTo(b"/game/ongeki/", request)
|
||||
|
||||
elif uri == "/game/ongeki/rival.delete":
|
||||
rival_id = request.args[b"rivalUserId"][0].decode()
|
||||
self.data.profile.delete_rival(usr_sesh.userId, rival_id)
|
||||
await self.data.profile.delete_rival(usr_sesh.userId, rival_id)
|
||||
# self.logger.info(f"{response}")
|
||||
return redirectTo(b"/game/ongeki/", request)
|
||||
|
||||
|
@ -1,16 +1,11 @@
|
||||
from decimal import Decimal
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import xml.etree.ElementTree as ET
|
||||
from typing import Any, Dict, List, Optional
|
||||
from typing import Optional
|
||||
|
||||
from read import BaseReader
|
||||
from core.config import CoreConfig
|
||||
from titles.ongeki.database import OngekiData
|
||||
from titles.ongeki.const import OngekiConstants
|
||||
from titles.ongeki.config import OngekiConfig
|
||||
|
||||
|
||||
class OngekiReader(BaseReader):
|
||||
def __init__(
|
||||
@ -32,7 +27,7 @@ class OngekiReader(BaseReader):
|
||||
self.logger.error(f"Invalid ongeki version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
data_dirs = []
|
||||
if self.bin_dir is not None:
|
||||
data_dirs += self.get_data_directories(self.bin_dir)
|
||||
@ -41,12 +36,12 @@ class OngekiReader(BaseReader):
|
||||
data_dirs += self.get_data_directories(self.opt_dir)
|
||||
|
||||
for dir in data_dirs:
|
||||
self.read_events(f"{dir}/event")
|
||||
self.read_music(f"{dir}/music")
|
||||
self.read_card(f"{dir}/card")
|
||||
self.read_reward(f"{dir}/reward")
|
||||
await self.read_events(f"{dir}/event")
|
||||
await self.read_music(f"{dir}/music")
|
||||
await self.read_card(f"{dir}/card")
|
||||
await self.read_reward(f"{dir}/reward")
|
||||
|
||||
def read_card(self, base_dir: str) -> None:
|
||||
async def read_card(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading cards from {base_dir}...")
|
||||
|
||||
version_ids = {
|
||||
@ -70,7 +65,7 @@ class OngekiReader(BaseReader):
|
||||
|
||||
# skip already existing cards
|
||||
if (
|
||||
self.data.static.get_card(
|
||||
await self.data.static.get_card(
|
||||
OngekiConstants.VER_ONGEKI_BRIGHT_MEMORY, card_id
|
||||
)
|
||||
is not None
|
||||
@ -100,7 +95,7 @@ class OngekiReader(BaseReader):
|
||||
version = version_ids[troot.find("VersionID").find("id").text]
|
||||
card_number = troot.find("CardNumberString").text
|
||||
|
||||
self.data.static.put_card(
|
||||
await self.data.static.put_card(
|
||||
version,
|
||||
card_id,
|
||||
name=name,
|
||||
@ -117,7 +112,7 @@ class OngekiReader(BaseReader):
|
||||
)
|
||||
self.logger.info(f"Added card {card_id}")
|
||||
|
||||
def read_events(self, base_dir: str) -> None:
|
||||
async def read_events(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading events from {base_dir}...")
|
||||
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
@ -132,10 +127,10 @@ class OngekiReader(BaseReader):
|
||||
troot.find("EventType").text
|
||||
].value
|
||||
|
||||
self.data.static.put_event(self.version, id, event_type, name)
|
||||
await self.data.static.put_event(self.version, id, event_type, name)
|
||||
self.logger.info(f"Added event {id}")
|
||||
|
||||
def read_music(self, base_dir: str) -> None:
|
||||
async def read_music(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading music from {base_dir}...")
|
||||
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
@ -168,12 +163,12 @@ class OngekiReader(BaseReader):
|
||||
f"{fumens_data.find('FumenConstIntegerPart').text}.{fumens_data.find('FumenConstFractionalPart').text}"
|
||||
)
|
||||
|
||||
self.data.static.put_chart(
|
||||
await self.data.static.put_chart(
|
||||
self.version, song_id, chart_id, title, artist, genre, level
|
||||
)
|
||||
self.logger.info(f"Added song {song_id} chart {chart_id}")
|
||||
|
||||
def read_reward(self, base_dir: str) -> None:
|
||||
async def read_reward(self, base_dir: str) -> None:
|
||||
self.logger.info(f"Reading rewards from {base_dir}...")
|
||||
|
||||
for root, dirs, files in os.walk(base_dir):
|
||||
@ -195,5 +190,5 @@ class OngekiReader(BaseReader):
|
||||
itemKind = OngekiConstants.REWARD_TYPES[troot.find("ItemType").text].value
|
||||
itemId = troot.find("RewardItem").find("ItemName").find("id").text
|
||||
|
||||
self.data.static.put_reward(self.version, rewardId, rewardname, itemKind, itemId)
|
||||
await self.data.static.put_reward(self.version, rewardId, rewardname, itemKind, itemId)
|
||||
self.logger.info(f"Added reward {rewardId}")
|
||||
|
@ -339,147 +339,147 @@ print_detail = Table(
|
||||
)
|
||||
|
||||
class OngekiItemData(BaseData):
|
||||
def put_card(self, aime_id: int, card_data: Dict) -> Optional[int]:
|
||||
async def put_card(self, aime_id: int, card_data: Dict) -> Optional[int]:
|
||||
card_data["user"] = aime_id
|
||||
|
||||
sql = insert(card).values(**card_data)
|
||||
conflict = sql.on_duplicate_key_update(**card_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_card: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_cards(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_cards(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(card).where(card.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_character(self, aime_id: int, character_data: Dict) -> Optional[int]:
|
||||
async def put_character(self, aime_id: int, character_data: Dict) -> Optional[int]:
|
||||
character_data["user"] = aime_id
|
||||
|
||||
sql = insert(character).values(**character_data)
|
||||
conflict = sql.on_duplicate_key_update(**character_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_character: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_characters(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_characters(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(character).where(character.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_deck(self, aime_id: int, deck_data: Dict) -> Optional[int]:
|
||||
async def put_deck(self, aime_id: int, deck_data: Dict) -> Optional[int]:
|
||||
deck_data["user"] = aime_id
|
||||
|
||||
sql = insert(deck).values(**deck_data)
|
||||
conflict = sql.on_duplicate_key_update(**deck_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_deck: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_deck(self, aime_id: int, deck_id: int) -> Optional[Dict]:
|
||||
async def get_deck(self, aime_id: int, deck_id: int) -> Optional[Dict]:
|
||||
sql = select(deck).where(and_(deck.c.user == aime_id, deck.c.deckId == deck_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_decks(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_decks(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(deck).where(deck.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_boss(self, aime_id: int, boss_data: Dict) -> Optional[int]:
|
||||
async def put_boss(self, aime_id: int, boss_data: Dict) -> Optional[int]:
|
||||
boss_data["user"] = aime_id
|
||||
|
||||
sql = insert(boss).values(**boss_data)
|
||||
conflict = sql.on_duplicate_key_update(**boss_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_boss: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_story(self, aime_id: int, story_data: Dict) -> Optional[int]:
|
||||
async def put_story(self, aime_id: int, story_data: Dict) -> Optional[int]:
|
||||
story_data["user"] = aime_id
|
||||
|
||||
sql = insert(story).values(**story_data)
|
||||
conflict = sql.on_duplicate_key_update(**story_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_story: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_stories(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_stories(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(story).where(story.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_chapter(self, aime_id: int, chapter_data: Dict) -> Optional[int]:
|
||||
async def put_chapter(self, aime_id: int, chapter_data: Dict) -> Optional[int]:
|
||||
chapter_data["user"] = aime_id
|
||||
|
||||
sql = insert(chapter).values(**chapter_data)
|
||||
conflict = sql.on_duplicate_key_update(**chapter_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_chapter: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_chapters(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_chapters(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(chapter).where(chapter.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_item(self, aime_id: int, item_data: Dict) -> Optional[int]:
|
||||
async def put_item(self, aime_id: int, item_data: Dict) -> Optional[int]:
|
||||
item_data["user"] = aime_id
|
||||
|
||||
sql = insert(item).values(**item_data)
|
||||
conflict = sql.on_duplicate_key_update(**item_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_item: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_item(self, aime_id: int, item_id: int, item_kind: int) -> Optional[Dict]:
|
||||
async def get_item(self, aime_id: int, item_id: int, item_kind: int) -> Optional[Dict]:
|
||||
sql = select(item).where(and_(item.c.user == aime_id, item.c.itemId == item_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_items(self, aime_id: int, item_kind: int = None) -> Optional[List[Dict]]:
|
||||
async def get_items(self, aime_id: int, item_kind: int = None) -> Optional[List[Dict]]:
|
||||
if item_kind is None:
|
||||
sql = select(item).where(item.c.user == aime_id)
|
||||
else:
|
||||
@ -487,73 +487,73 @@ class OngekiItemData(BaseData):
|
||||
and_(item.c.user == aime_id, item.c.itemKind == item_kind)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_music_item(self, aime_id: int, music_item_data: Dict) -> Optional[int]:
|
||||
async def put_music_item(self, aime_id: int, music_item_data: Dict) -> Optional[int]:
|
||||
music_item_data["user"] = aime_id
|
||||
|
||||
sql = insert(music_item).values(**music_item_data)
|
||||
conflict = sql.on_duplicate_key_update(**music_item_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_music_item: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_music_items(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_music_items(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(music_item).where(music_item.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_login_bonus(self, aime_id: int, login_bonus_data: Dict) -> Optional[int]:
|
||||
async def put_login_bonus(self, aime_id: int, login_bonus_data: Dict) -> Optional[int]:
|
||||
login_bonus_data["user"] = aime_id
|
||||
|
||||
sql = insert(login_bonus).values(**login_bonus_data)
|
||||
conflict = sql.on_duplicate_key_update(**login_bonus_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_login_bonus: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_login_bonuses(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_login_bonuses(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(login_bonus).where(login_bonus.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_mission_point(self, aime_id: int, version: int, mission_point_data: Dict) -> Optional[int]:
|
||||
async def put_mission_point(self, aime_id: int, version: int, mission_point_data: Dict) -> Optional[int]:
|
||||
mission_point_data["version"] = version
|
||||
mission_point_data["user"] = aime_id
|
||||
|
||||
sql = insert(mission_point).values(**mission_point_data)
|
||||
conflict = sql.on_duplicate_key_update(**mission_point_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_mission_point: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_mission_points(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_mission_points(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(mission_point).where(and_(mission_point.c.user == aime_id, mission_point.c.version == version))
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_event_point(self, aime_id: int, version: int, event_point_data: Dict) -> Optional[int]:
|
||||
async def put_event_point(self, aime_id: int, version: int, event_point_data: Dict) -> Optional[int]:
|
||||
# We update only the newest (type: 1) entry, in official spec game watches for both latest(type:1) and previous (type:2) entries to give an additional info how many ranks has player moved up or down
|
||||
# This fully featured is on TODO list, at the moment we just update the tables as data comes and give out rank as request comes
|
||||
event_point_data["user"] = aime_id
|
||||
@ -564,95 +564,95 @@ class OngekiItemData(BaseData):
|
||||
|
||||
sql = insert(event_point).values(**event_point_data)
|
||||
conflict = sql.on_duplicate_key_update(**event_point_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_event_point: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_event_points(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_event_points(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(event_point).where(event_point.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_scenerio(self, aime_id: int, scenerio_data: Dict) -> Optional[int]:
|
||||
async def put_scenerio(self, aime_id: int, scenerio_data: Dict) -> Optional[int]:
|
||||
scenerio_data["user"] = aime_id
|
||||
|
||||
sql = insert(scenerio).values(**scenerio_data)
|
||||
conflict = sql.on_duplicate_key_update(**scenerio_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_scenerio: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_scenerios(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_scenerios(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(scenerio).where(scenerio.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_trade_item(self, aime_id: int, trade_item_data: Dict) -> Optional[int]:
|
||||
async def put_trade_item(self, aime_id: int, trade_item_data: Dict) -> Optional[int]:
|
||||
trade_item_data["user"] = aime_id
|
||||
|
||||
sql = insert(trade_item).values(**trade_item_data)
|
||||
conflict = sql.on_duplicate_key_update(**trade_item_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_trade_item: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_trade_items(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_trade_items(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(trade_item).where(trade_item.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_event_music(self, aime_id: int, event_music_data: Dict) -> Optional[int]:
|
||||
async def put_event_music(self, aime_id: int, event_music_data: Dict) -> Optional[int]:
|
||||
event_music_data["user"] = aime_id
|
||||
|
||||
sql = insert(event_music).values(**event_music_data)
|
||||
conflict = sql.on_duplicate_key_update(**event_music_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_event_music: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_event_music(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_event_music(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(event_music).where(event_music.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_tech_event(self, aime_id: int, version: int, tech_event_data: Dict) -> Optional[int]:
|
||||
async def put_tech_event(self, aime_id: int, version: int, tech_event_data: Dict) -> Optional[int]:
|
||||
tech_event_data["user"] = aime_id
|
||||
tech_event_data["version"] = version
|
||||
|
||||
sql = insert(tech_event).values(**tech_event_data)
|
||||
conflict = sql.on_duplicate_key_update(**tech_event_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_tech_event: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_tech_event_ranking(self, aime_id: int, version: int, tech_event_data: Dict) -> Optional[int]:
|
||||
async def put_tech_event_ranking(self, aime_id: int, version: int, tech_event_data: Dict) -> Optional[int]:
|
||||
tech_event_data["user"] = aime_id
|
||||
tech_event_data["version"] = version
|
||||
tech_event_data.pop("isRankingRewarded")
|
||||
@ -662,87 +662,87 @@ class OngekiItemData(BaseData):
|
||||
|
||||
sql = insert(tech_ranking).values(**tech_event_data)
|
||||
conflict = sql.on_duplicate_key_update(**tech_event_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_tech_event_ranking: Failed to update ranking! aime_id {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_tech_event(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_tech_event(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(tech_event).where(and_(tech_event.c.user == aime_id, tech_event.c.version == version))
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_bosses(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_bosses(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(boss).where(boss.c.user == aime_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_memorychapter(
|
||||
async def put_memorychapter(
|
||||
self, aime_id: int, memorychapter_data: Dict
|
||||
) -> Optional[int]:
|
||||
memorychapter_data["user"] = aime_id
|
||||
|
||||
sql = insert(memorychapter).values(**memorychapter_data)
|
||||
conflict = sql.on_duplicate_key_update(**memorychapter_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_memorychapter: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_memorychapters(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_memorychapters(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(memorychapter).where(memorychapter.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_user_gacha(self, aime_id: int, gacha_id: int) -> Optional[Row]:
|
||||
async def get_user_gacha(self, aime_id: int, gacha_id: int) -> Optional[Row]:
|
||||
sql = gacha.select(and_(gacha.c.user == aime_id, gacha.c.gachaId == gacha_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_user_gachas(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_user_gachas(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = gacha.select(gacha.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_user_gacha_supplies(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_user_gacha_supplies(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = gacha_supply.select(gacha_supply.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_user_gacha(self, aime_id: int, gacha_id: int, **data) -> Optional[int]:
|
||||
async def put_user_gacha(self, aime_id: int, gacha_id: int, **data) -> Optional[int]:
|
||||
sql = insert(gacha).values(user=aime_id, gachaId=gacha_id, **data)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(user=aime_id, gachaId=gacha_id, **data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_user_gacha: Failed to insert! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_user_print_detail(
|
||||
async def put_user_print_detail(
|
||||
self, aime_id: int, serial_id: str, user_print_data: Dict
|
||||
) -> Optional[int]:
|
||||
sql = insert(print_detail).values(
|
||||
@ -750,7 +750,7 @@ class OngekiItemData(BaseData):
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(user=aime_id, **user_print_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -760,18 +760,18 @@ class OngekiItemData(BaseData):
|
||||
return result.lastrowid
|
||||
|
||||
|
||||
def get_ranking_event_ranks(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_ranking_event_ranks(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
# Calculates player rank on GameRequest from server, and sends it back, official spec would rank players in maintenance period, on TODO list
|
||||
sql = select(event_point.c.id, event_point.c.user, event_point.c.eventId, event_point.c.type, func.row_number().over(partition_by=event_point.c.eventId, order_by=event_point.c.point.desc()).label('rank'), event_point.c.date, event_point.c.point).where(event_point.c.version == version)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(f"failed to rank aime_id: {aime_id} ranking event positions")
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_tech_event_ranking(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_tech_event_ranking(self, version: int, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(tech_ranking.c.id, tech_ranking.c.user, tech_ranking.c.date, tech_ranking.c.eventId, func.row_number().over(partition_by=tech_ranking.c.eventId, order_by=[tech_ranking.c.totalTechScore.desc(),tech_ranking.c.totalPlatinumScore.desc()]).label('rank'), tech_ranking.c.totalTechScore, tech_ranking.c.totalPlatinumScore).where(tech_ranking.c.version == version)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"aime_id: {aime_id} has no tech ranking ranks")
|
||||
return None
|
||||
|
@ -39,7 +39,7 @@ session_log = Table(
|
||||
|
||||
|
||||
class OngekiLogData(BaseData):
|
||||
def put_gp_log(
|
||||
async def put_gp_log(
|
||||
self,
|
||||
aime_id: Optional[int],
|
||||
used_credit: int,
|
||||
@ -61,7 +61,7 @@ class OngekiLogData(BaseData):
|
||||
currentGP=current_gp,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_gp_log: Failed to insert GP log! aime_id: {aime_id} kind {kind} pattern {pattern} current_gp {current_gp}"
|
||||
|
@ -255,12 +255,12 @@ class OngekiProfileData(BaseData):
|
||||
)
|
||||
self.date_time_format_short = "%Y-%m-%d"
|
||||
|
||||
def get_profile_name(self, aime_id: int, version: int) -> Optional[str]:
|
||||
async def get_profile_name(self, aime_id: int, version: int) -> Optional[str]:
|
||||
sql = select(profile.c.userName).where(
|
||||
and_(profile.c.user == aime_id, profile.c.version == version)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
|
||||
@ -270,19 +270,19 @@ class OngekiProfileData(BaseData):
|
||||
|
||||
return row["userName"]
|
||||
|
||||
def get_profile_preview(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_preview(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = (
|
||||
select([profile, option])
|
||||
.join(option, profile.c.user == option.c.user)
|
||||
.filter(and_(profile.c.user == aime_id, profile.c.version == version))
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_data(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
async def get_profile_data(self, aime_id: int, version: int) -> Optional[Row]:
|
||||
sql = select(profile).where(
|
||||
and_(
|
||||
profile.c.user == aime_id,
|
||||
@ -290,40 +290,40 @@ class OngekiProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_options(self, aime_id: int) -> Optional[Row]:
|
||||
async def get_profile_options(self, aime_id: int) -> Optional[Row]:
|
||||
sql = select(option).where(
|
||||
and_(
|
||||
option.c.user == aime_id,
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_recent_rating(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_profile_recent_rating(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(recent_rating).where(recent_rating.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_profile_rating_log(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_profile_rating_log(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(rating_log).where(rating_log.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_profile_activity(
|
||||
async def get_profile_activity(
|
||||
self, aime_id: int, kind: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(activity).where(
|
||||
@ -333,47 +333,47 @@ class OngekiProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_kop(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_kop(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(kop).where(kop.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_rivals(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_rivals(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(rival.c.rivalUserId).where(rival.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_profile_data(self, aime_id: int, version: int, data: Dict) -> Optional[int]:
|
||||
async def put_profile_data(self, aime_id: int, version: int, data: Dict) -> Optional[int]:
|
||||
data["user"] = aime_id
|
||||
data["version"] = version
|
||||
data.pop("accessCode")
|
||||
|
||||
sql = insert(profile).values(**data)
|
||||
conflict = sql.on_duplicate_key_update(**data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_profile_data: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_options(self, aime_id: int, options_data: Dict) -> Optional[int]:
|
||||
async def put_profile_options(self, aime_id: int, options_data: Dict) -> Optional[int]:
|
||||
options_data["user"] = aime_id
|
||||
|
||||
sql = insert(option).values(**options_data)
|
||||
conflict = sql.on_duplicate_key_update(**options_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
@ -382,7 +382,7 @@ class OngekiProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_recent_rating(
|
||||
async def put_profile_recent_rating(
|
||||
self, aime_id: int, recent_rating_data: List[Dict]
|
||||
) -> Optional[int]:
|
||||
sql = insert(recent_rating).values(
|
||||
@ -391,7 +391,7 @@ class OngekiProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(recentRating=recent_rating_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_recent_rating: failed to update recent rating! aime_id {aime_id}"
|
||||
@ -399,12 +399,12 @@ class OngekiProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_bp_list(
|
||||
async def put_profile_bp_list(
|
||||
self, aime_id: int, bp_base_list: List[Dict]
|
||||
) -> Optional[int]:
|
||||
pass
|
||||
|
||||
def put_profile_rating_log(
|
||||
async def put_profile_rating_log(
|
||||
self, aime_id: int, data_version: str, highest_rating: int
|
||||
) -> Optional[int]:
|
||||
sql = insert(rating_log).values(
|
||||
@ -413,7 +413,7 @@ class OngekiProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(highestRating=highest_rating)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_rating_log: failed to update rating log! aime_id {aime_id} data_version {data_version} highest_rating {highest_rating}"
|
||||
@ -421,7 +421,7 @@ class OngekiProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_activity(
|
||||
async def put_profile_activity(
|
||||
self,
|
||||
aime_id: int,
|
||||
kind: int,
|
||||
@ -447,7 +447,7 @@ class OngekiProfileData(BaseData):
|
||||
sortNumber=sort_num, param1=p1, param2=p2, param3=p3, param4=p4
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_activity: failed to put activity! aime_id {aime_id} kind {kind} activity_id {activity_id}"
|
||||
@ -455,7 +455,7 @@ class OngekiProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile_region(self, aime_id: int, region: int, date: str) -> Optional[int]:
|
||||
async def put_profile_region(self, aime_id: int, region: int, date: str) -> Optional[int]:
|
||||
sql = insert(activity).values(
|
||||
user=aime_id, region=region, playCount=1, created=date
|
||||
)
|
||||
@ -464,7 +464,7 @@ class OngekiProfileData(BaseData):
|
||||
playCount=activity.c.playCount + 1,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_profile_region: failed to update! aime_id {aime_id} region {region}"
|
||||
@ -472,45 +472,45 @@ class OngekiProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_training_room(self, aime_id: int, room_detail: Dict) -> Optional[int]:
|
||||
async def put_training_room(self, aime_id: int, room_detail: Dict) -> Optional[int]:
|
||||
room_detail["user"] = aime_id
|
||||
|
||||
sql = insert(training_room).values(**room_detail)
|
||||
conflict = sql.on_duplicate_key_update(**room_detail)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_best_score: Failed to add score! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_kop(self, aime_id: int, kop_data: Dict) -> Optional[int]:
|
||||
async def put_kop(self, aime_id: int, kop_data: Dict) -> Optional[int]:
|
||||
kop_data["user"] = aime_id
|
||||
|
||||
sql = insert(kop).values(**kop_data)
|
||||
conflict = sql.on_duplicate_key_update(**kop_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_kop: Failed to add score! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_rival(self, aime_id: int, rival_id: int) -> Optional[int]:
|
||||
async def put_rival(self, aime_id: int, rival_id: int) -> Optional[int]:
|
||||
sql = insert(rival).values(user=aime_id, rivalUserId=rival_id)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(rivalUserId=rival_id)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_rival: failed to update! aime_id: {aime_id}, rival_id: {rival_id}"
|
||||
)
|
||||
return None
|
||||
return result.lastrowid
|
||||
def delete_rival(self, aime_id: int, rival_id: int) -> Optional[int]:
|
||||
async def delete_rival(self, aime_id: int, rival_id: int) -> Optional[int]:
|
||||
sql = delete(rival).where(rival.c.user==aime_id, rival.c.rivalUserId==rival_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(f"delete_rival: failed to delete! aime_id: {aime_id}, rival_id: {rival_id}")
|
||||
else:
|
||||
|
@ -128,52 +128,52 @@ tech_count = Table(
|
||||
|
||||
|
||||
class OngekiScoreData(BaseData):
|
||||
def get_tech_count(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_tech_count(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
return []
|
||||
|
||||
def put_tech_count(self, aime_id: int, tech_count_data: Dict) -> Optional[int]:
|
||||
async def put_tech_count(self, aime_id: int, tech_count_data: Dict) -> Optional[int]:
|
||||
tech_count_data["user"] = aime_id
|
||||
|
||||
sql = insert(tech_count).values(**tech_count_data)
|
||||
conflict = sql.on_duplicate_key_update(**tech_count_data)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_tech_count: Failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_best_scores(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
async def get_best_scores(self, aime_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(score_best).where(score_best.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_best_score(
|
||||
async def get_best_score(
|
||||
self, aime_id: int, song_id: int, chart_id: int = None
|
||||
) -> Optional[List[Dict]]:
|
||||
return []
|
||||
|
||||
def put_best_score(self, aime_id: int, music_detail: Dict) -> Optional[int]:
|
||||
async def put_best_score(self, aime_id: int, music_detail: Dict) -> Optional[int]:
|
||||
music_detail["user"] = aime_id
|
||||
|
||||
sql = insert(score_best).values(**music_detail)
|
||||
conflict = sql.on_duplicate_key_update(**music_detail)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
|
||||
if result is None:
|
||||
self.logger.warning(f"put_best_score: Failed to add score! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_playlog(self, aime_id: int, playlog_data: Dict) -> Optional[int]:
|
||||
async def put_playlog(self, aime_id: int, playlog_data: Dict) -> Optional[int]:
|
||||
playlog_data["user"] = aime_id
|
||||
|
||||
sql = insert(playlog).values(**playlog_data)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"put_playlog: Failed to add playlog! aime_id: {aime_id}")
|
||||
return None
|
||||
|
@ -188,26 +188,26 @@ game_point = Table(
|
||||
)
|
||||
|
||||
class OngekiStaticData(BaseData):
|
||||
def put_card(self, version: int, card_id: int, **card_data) -> Optional[int]:
|
||||
async def put_card(self, version: int, card_id: int, **card_data) -> Optional[int]:
|
||||
sql = insert(cards).values(version=version, cardId=card_id, **card_data)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(**card_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert card! card_id {card_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_card(self, version: int, card_id: int) -> Optional[Dict]:
|
||||
async def get_card(self, version: int, card_id: int) -> Optional[Dict]:
|
||||
sql = cards.select(and_(cards.c.version <= version, cards.c.cardId == card_id))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_card_by_card_number(self, version: int, card_number: str) -> Optional[Dict]:
|
||||
async def get_card_by_card_number(self, version: int, card_number: str) -> Optional[Dict]:
|
||||
if not card_number.startswith("[O.N.G.E.K.I.]"):
|
||||
card_number = f"[O.N.G.E.K.I.]{card_number}"
|
||||
|
||||
@ -215,36 +215,36 @@ class OngekiStaticData(BaseData):
|
||||
and_(cards.c.version <= version, cards.c.cardNumber == card_number)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_card_by_name(self, version: int, name: str) -> Optional[Dict]:
|
||||
async def get_card_by_name(self, version: int, name: str) -> Optional[Dict]:
|
||||
sql = cards.select(and_(cards.c.version <= version, cards.c.name == name))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_cards(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_cards(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = cards.select(cards.c.version <= version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_cards_by_rarity(self, version: int, rarity: int) -> Optional[List[Dict]]:
|
||||
async def get_cards_by_rarity(self, version: int, rarity: int) -> Optional[List[Dict]]:
|
||||
sql = cards.select(and_(cards.c.version <= version, cards.c.rarity == rarity))
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_gacha(
|
||||
async def put_gacha(
|
||||
self,
|
||||
version: int,
|
||||
gacha_id: int,
|
||||
@ -268,33 +268,33 @@ class OngekiStaticData(BaseData):
|
||||
**gacha_data,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert gacha! gacha_id {gacha_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_gacha(self, version: int, gacha_id: int) -> Optional[Dict]:
|
||||
async def get_gacha(self, version: int, gacha_id: int) -> Optional[Dict]:
|
||||
sql = gachas.select(
|
||||
and_(gachas.c.version <= version, gachas.c.gachaId == gacha_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_gachas(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_gachas(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = gachas.select(gachas.c.version == version).order_by(
|
||||
gachas.c.gachaId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_gacha_card(
|
||||
async def put_gacha_card(
|
||||
self, gacha_id: int, card_id: int, **gacha_card
|
||||
) -> Optional[int]:
|
||||
sql = insert(gacha_cards).values(gachaId=gacha_id, cardId=card_id, **gacha_card)
|
||||
@ -303,21 +303,21 @@ class OngekiStaticData(BaseData):
|
||||
gachaId=gacha_id, cardId=card_id, **gacha_card
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert gacha card! gacha_id {gacha_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_gacha_cards(self, gacha_id: int) -> Optional[List[Dict]]:
|
||||
async def get_gacha_cards(self, gacha_id: int) -> Optional[List[Dict]]:
|
||||
sql = gacha_cards.select(gacha_cards.c.gachaId == gacha_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_event(
|
||||
async def put_event(
|
||||
self, version: int, event_id: int, event_type: int, event_name: str
|
||||
) -> Optional[int]:
|
||||
sql = insert(events).values(
|
||||
@ -332,41 +332,41 @@ class OngekiStaticData(BaseData):
|
||||
name=event_name,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert event! event_id {event_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_event(self, version: int, event_id: int) -> Optional[List[Dict]]:
|
||||
async def get_event(self, version: int, event_id: int) -> Optional[List[Dict]]:
|
||||
sql = select(events).where(
|
||||
and_(events.c.version == version, events.c.eventId == event_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_events(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_events(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = select(events).where(events.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_enabled_events(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_enabled_events(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = select(events).where(
|
||||
and_(events.c.version == version, events.c.enabled == True)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_chart(
|
||||
async def put_chart(
|
||||
self,
|
||||
version: int,
|
||||
song_id: int,
|
||||
@ -393,7 +393,7 @@ class OngekiStaticData(BaseData):
|
||||
level=level,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"Failed to insert chart! song_id: {song_id}, chart_id: {chart_id}"
|
||||
@ -401,15 +401,15 @@ class OngekiStaticData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_chart(
|
||||
async def get_chart(
|
||||
self, version: int, song_id: int, chart_id: int = None
|
||||
) -> Optional[List[Dict]]:
|
||||
pass
|
||||
|
||||
def get_music(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_music(self, version: int) -> Optional[List[Dict]]:
|
||||
pass
|
||||
|
||||
def get_music_chart(
|
||||
async def get_music_chart(
|
||||
self, version: int, song_id: int, chart_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(music).where(
|
||||
@ -420,19 +420,19 @@ class OngekiStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_ranking_list(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_ranking_list(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = select(music_ranking.c.musicId.label('id'), music_ranking.c.point, music_ranking.c.userName).where(music_ranking.c.version == version)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_reward(self, version: int, rewardId: int, rewardname: str, itemKind: int, itemId: int) -> Optional[int]:
|
||||
async def put_reward(self, version: int, rewardId: int, rewardname: str, itemKind: int, itemId: int) -> Optional[int]:
|
||||
sql = insert(rewards).values(
|
||||
version=version,
|
||||
rewardId=rewardId,
|
||||
@ -443,70 +443,70 @@ class OngekiStaticData(BaseData):
|
||||
conflict = sql.on_duplicate_key_update(
|
||||
rewardname=rewardname,
|
||||
)
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert reward! reward_id: {rewardId}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_reward_list(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_reward_list(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = select(rewards).where(rewards.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to load reward list")
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_present_list(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_present_list(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = select(present).where(present.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to load present list")
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_tech_music(self, version: int) -> Optional[List[Dict]]:
|
||||
async def get_tech_music(self, version: int) -> Optional[List[Dict]]:
|
||||
sql = select(tech_music).where(tech_music.c.version == version)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_client_testmode_data(self, region_id: int, client_testmode_data: Dict) -> Optional[List[Dict]]:
|
||||
async def put_client_testmode_data(self, region_id: int, client_testmode_data: Dict) -> Optional[List[Dict]]:
|
||||
sql = insert(client_testmode).values(regionId=region_id, **client_testmode_data)
|
||||
conflict = sql.on_duplicate_key_update(regionId=region_id, **client_testmode_data)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"region_id: {region_id} Failed to update ClientTestMode data"),
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_client_setting_data(self, machine_id: int, client_setting_data: Dict) -> Optional[List[Dict]]:
|
||||
async def put_client_setting_data(self, machine_id: int, client_setting_data: Dict) -> Optional[List[Dict]]:
|
||||
sql = machine.update(machine.c.id == machine_id).values(data=client_setting_data)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"machine_id: {machine_id} Failed to update ClientSetting data"),
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_static_game_point_defaults(self) -> Optional[List[Dict]]:
|
||||
async def put_static_game_point_defaults(self) -> Optional[List[Dict]]:
|
||||
game_point_defaults = [{"type": 0, "cost": 100},{"type": 1, "cost": 230},{"type": 2, "cost": 370},{"type": 3, "cost": 120},{"type": 4, "cost": 240},{"type": 5, "cost": 360}]
|
||||
sql = insert(game_point).values(game_point_defaults)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert default GP table!")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_static_game_point(self) -> Optional[List[Dict]]:
|
||||
async def get_static_game_point(self) -> Optional[List[Dict]]:
|
||||
sql = select(game_point.c.type, game_point.c.cost, game_point.c.startDate, game_point.c.endDate)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
@ -132,11 +132,11 @@ class PokkenBase:
|
||||
res.type = jackal_pb2.MessageType.LOAD_USER
|
||||
access_code = request.load_user.access_code
|
||||
load_usr = jackal_pb2.LoadUserResponseData()
|
||||
user_id = self.data.card.get_user_id_from_card(access_code)
|
||||
user_id = await self.data.card.get_user_id_from_card(access_code)
|
||||
|
||||
if user_id is None and self.game_cfg.server.auto_register:
|
||||
user_id = self.data.user.create_user()
|
||||
card_id = self.data.card.create_card(user_id, access_code)
|
||||
user_id = await self.data.user.create_user()
|
||||
card_id = await self.data.card.create_card(user_id, access_code)
|
||||
|
||||
self.logger.info(
|
||||
f"Register new card {access_code} (UserId {user_id}, CardId {card_id})"
|
||||
@ -160,7 +160,7 @@ class PokkenBase:
|
||||
event_achievement_flag
|
||||
event_achievement_param
|
||||
"""
|
||||
profile = self.data.profile.get_profile(user_id)
|
||||
profile = await self.data.profile.get_profile(user_id)
|
||||
load_usr.commidserv_result = 1
|
||||
load_usr.load_hash = 1
|
||||
load_usr.cardlock_status = False
|
||||
@ -169,7 +169,7 @@ class PokkenBase:
|
||||
load_usr.precedent_release_flag = 0xFFFFFFFF
|
||||
|
||||
if profile is None:
|
||||
profile_id = self.data.profile.create_profile(user_id)
|
||||
profile_id = await self.data.profile.create_profile(user_id)
|
||||
profile_dict = {"id": profile_id, "user": user_id}
|
||||
pokemon_data = []
|
||||
tutorial_progress = []
|
||||
@ -184,7 +184,7 @@ class PokkenBase:
|
||||
self.logger.info(
|
||||
f"Card-in user {user_id} (Trainer name {profile_dict.get('trainer_name', '')})"
|
||||
)
|
||||
pokemon_data = self.data.profile.get_all_pokemon_data(user_id)
|
||||
pokemon_data = await self.data.profile.get_all_pokemon_data(user_id)
|
||||
tutorial_progress = []
|
||||
rankmatch_progress = []
|
||||
achievement_flag = []
|
||||
@ -324,22 +324,22 @@ class PokkenBase:
|
||||
battle = req.battle_data
|
||||
mon = req.pokemon_data
|
||||
|
||||
p = self.data.profile.touch_profile(user_id)
|
||||
p = await self.data.profile.touch_profile(user_id)
|
||||
if p is None or not p:
|
||||
self.data.profile.create_profile(user_id)
|
||||
await self.data.profile.create_profile(user_id)
|
||||
|
||||
if req.trainer_name_pending is not None and req.trainer_name_pending: # we're saving for the first time
|
||||
self.data.profile.set_profile_name(user_id, req.trainer_name_pending, req.avatar_gender if req.avatar_gender else None)
|
||||
await self.data.profile.set_profile_name(user_id, req.trainer_name_pending, req.avatar_gender if req.avatar_gender else None)
|
||||
|
||||
for tut_flg in req.tutorial_progress_flag:
|
||||
tut_flgs.append(tut_flg)
|
||||
|
||||
self.data.profile.update_profile_tutorial_flags(user_id, tut_flgs)
|
||||
await self.data.profile.update_profile_tutorial_flags(user_id, tut_flgs)
|
||||
|
||||
for ach_flg in req.achievement_flag:
|
||||
ach_flgs.append(ach_flg)
|
||||
|
||||
self.data.profile.update_profile_tutorial_flags(user_id, ach_flg)
|
||||
await self.data.profile.update_profile_tutorial_flags(user_id, ach_flg)
|
||||
|
||||
for evt_flg in req.event_achievement_flag:
|
||||
evt_flgs.append(evt_flg)
|
||||
@ -347,29 +347,29 @@ class PokkenBase:
|
||||
for evt_param in req.event_achievement_param:
|
||||
evt_params.append(evt_param)
|
||||
|
||||
self.data.profile.update_profile_event(user_id, evt_state, evt_flgs, evt_params, req.last_play_event_id)
|
||||
await self.data.profile.update_profile_event(user_id, evt_state, evt_flgs, evt_params, req.last_play_event_id)
|
||||
|
||||
for reward in req.reward_data:
|
||||
self.data.item.add_reward(user_id, reward.get_category_id, reward.get_content_id, reward.get_type_id)
|
||||
await self.data.item.add_reward(user_id, reward.get_category_id, reward.get_content_id, reward.get_type_id)
|
||||
|
||||
self.data.profile.add_profile_points(user_id, get_rank_pts, get_money, get_score_pts, grade_max)
|
||||
await self.data.profile.add_profile_points(user_id, get_rank_pts, get_money, get_score_pts, grade_max)
|
||||
|
||||
self.data.profile.update_support_team(user_id, 1, req.support_set_1[0], req.support_set_1[1])
|
||||
self.data.profile.update_support_team(user_id, 2, req.support_set_2[0], req.support_set_2[1])
|
||||
self.data.profile.update_support_team(user_id, 3, req.support_set_3[0], req.support_set_3[1])
|
||||
await self.data.profile.update_support_team(user_id, 1, req.support_set_1[0], req.support_set_1[1])
|
||||
await self.data.profile.update_support_team(user_id, 2, req.support_set_2[0], req.support_set_2[1])
|
||||
await self.data.profile.update_support_team(user_id, 3, req.support_set_3[0], req.support_set_3[1])
|
||||
|
||||
self.data.profile.put_pokemon(user_id, mon.char_id, mon.illustration_book_no, mon.bp_point_atk, mon.bp_point_res, mon.bp_point_def, mon.bp_point_sp)
|
||||
self.data.profile.add_pokemon_xp(user_id, mon.char_id, mon.get_pokemon_exp)
|
||||
await self.data.profile.put_pokemon(user_id, mon.char_id, mon.illustration_book_no, mon.bp_point_atk, mon.bp_point_res, mon.bp_point_def, mon.bp_point_sp)
|
||||
await self.data.profile.add_pokemon_xp(user_id, mon.char_id, mon.get_pokemon_exp)
|
||||
|
||||
for x in range(len(battle.play_mode)):
|
||||
self.data.profile.put_pokemon_battle_result(
|
||||
await self.data.profile.put_pokemon_battle_result(
|
||||
user_id,
|
||||
mon.char_id,
|
||||
PokkenConstants.BATTLE_TYPE(battle.play_mode[x]),
|
||||
PokkenConstants.BATTLE_RESULT(battle.result[x])
|
||||
)
|
||||
|
||||
self.data.profile.put_stats(
|
||||
await self.data.profile.put_stats(
|
||||
user_id,
|
||||
battle.ex_ko_num,
|
||||
battle.wko_num,
|
||||
@ -379,7 +379,7 @@ class PokkenBase:
|
||||
num_continues
|
||||
)
|
||||
|
||||
self.data.profile.put_extra(
|
||||
await self.data.profile.put_extra(
|
||||
user_id,
|
||||
extra_counter,
|
||||
evt_reward_get_flg,
|
||||
|
@ -31,7 +31,7 @@ class PokkenItemData(BaseData):
|
||||
Items obtained as rewards
|
||||
"""
|
||||
|
||||
def add_reward(self, user_id: int, category: int, content: int, item_type: int) -> Optional[int]:
|
||||
async def add_reward(self, user_id: int, category: int, content: int, item_type: int) -> Optional[int]:
|
||||
sql = insert(item).values(
|
||||
user=user_id,
|
||||
category=category,
|
||||
@ -43,7 +43,7 @@ class PokkenItemData(BaseData):
|
||||
content=content,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert reward for user {user_id}: {category}-{content}-{item_type}")
|
||||
return None
|
||||
|
@ -39,14 +39,14 @@ class PokkenMatchData(BaseData):
|
||||
Match logs
|
||||
"""
|
||||
|
||||
def save_match(self, user_id: int, match_data: Dict) -> Optional[int]:
|
||||
async def save_match(self, user_id: int, match_data: Dict) -> Optional[int]:
|
||||
pass
|
||||
|
||||
def get_match(self, match_id: int) -> Optional[Row]:
|
||||
async def get_match(self, match_id: int) -> Optional[Row]:
|
||||
pass
|
||||
|
||||
def get_matches_by_user(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_matches_by_user(self, user_id: int) -> Optional[List[Row]]:
|
||||
pass
|
||||
|
||||
def get_matches(self, limit: int = 20) -> Optional[List[Row]]:
|
||||
async def get_matches(self, limit: int = 20) -> Optional[List[Row]]:
|
||||
pass
|
||||
|
@ -138,36 +138,36 @@ pokemon_data = Table(
|
||||
|
||||
|
||||
class PokkenProfileData(BaseData):
|
||||
def touch_profile(self, user_id: int) -> Optional[int]:
|
||||
async def touch_profile(self, user_id: int) -> Optional[int]:
|
||||
sql = select([profile.c.id]).where(profile.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()['id']
|
||||
|
||||
def create_profile(self, user_id: int) -> Optional[int]:
|
||||
async def create_profile(self, user_id: int) -> Optional[int]:
|
||||
sql = insert(profile).values(user=user_id)
|
||||
conflict = sql.on_duplicate_key_update(user=user_id)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to create pokken profile for user {user_id}!")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def set_profile_name(self, user_id: int, new_name: str, gender: Union[int, None] = None) -> None:
|
||||
async def set_profile_name(self, user_id: int, new_name: str, gender: Union[int, None] = None) -> None:
|
||||
sql = update(profile).where(profile.c.user == user_id).values(
|
||||
trainer_name=new_name,
|
||||
avatar_gender=gender if gender is not None else profile.c.avatar_gender
|
||||
)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to update pokken profile name for user {user_id}!"
|
||||
)
|
||||
|
||||
def put_extra(
|
||||
async def put_extra(
|
||||
self,
|
||||
user_id: int,
|
||||
extra_counter: int,
|
||||
@ -190,44 +190,44 @@ class PokkenProfileData(BaseData):
|
||||
last_play_event_id=last_evt
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to put extra data for user {user_id}")
|
||||
|
||||
def update_profile_tutorial_flags(self, user_id: int, tutorial_flags: List) -> None:
|
||||
async def update_profile_tutorial_flags(self, user_id: int, tutorial_flags: List) -> None:
|
||||
sql = update(profile).where(profile.c.user == user_id).values(
|
||||
tutorial_progress_flag=tutorial_flags,
|
||||
)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to update pokken profile tutorial flags for user {user_id}!"
|
||||
)
|
||||
|
||||
def update_profile_achievement_flags(self, user_id: int, achievement_flags: List) -> None:
|
||||
async def update_profile_achievement_flags(self, user_id: int, achievement_flags: List) -> None:
|
||||
sql = update(profile).where(profile.c.user == user_id).values(
|
||||
achievement_flag=achievement_flags,
|
||||
)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to update pokken profile achievement flags for user {user_id}!"
|
||||
)
|
||||
|
||||
def update_profile_event(self, user_id: int, event_state: List, event_flags: List[int], event_param: List[int], last_evt: int = None) -> None:
|
||||
async def update_profile_event(self, user_id: int, event_state: List, event_flags: List[int], event_param: List[int], last_evt: int = None) -> None:
|
||||
sql = update(profile).where(profile.c.user == user_id).values(
|
||||
event_state=event_state,
|
||||
event_achievement_flag=event_flags,
|
||||
event_achievement_param=event_param,
|
||||
last_play_event_id=last_evt if last_evt is not None else profile.c.last_play_event_id,
|
||||
)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to update pokken profile event state for user {user_id}!"
|
||||
)
|
||||
|
||||
def add_profile_points(
|
||||
async def add_profile_points(
|
||||
self, user_id: int, rank_pts: int, money: int, score_pts: int, grade_max: int
|
||||
) -> None:
|
||||
sql = update(profile).where(profile.c.user == user_id).values(
|
||||
@ -237,14 +237,14 @@ class PokkenProfileData(BaseData):
|
||||
grade_max_num = grade_max
|
||||
)
|
||||
|
||||
def get_profile(self, user_id: int) -> Optional[Row]:
|
||||
async def get_profile(self, user_id: int) -> Optional[Row]:
|
||||
sql = profile.select(profile.c.user == user_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def put_pokemon(
|
||||
async def put_pokemon(
|
||||
self,
|
||||
user_id: int,
|
||||
pokemon_id: int,
|
||||
@ -281,13 +281,13 @@ class PokkenProfileData(BaseData):
|
||||
bp_point_sp=pokemon_data.c.bp_point_sp + sp,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert pokemon ID {pokemon_id} for user {user_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def add_pokemon_xp(
|
||||
async def add_pokemon_xp(
|
||||
self,
|
||||
user_id: int,
|
||||
pokemon_id: int,
|
||||
@ -297,25 +297,25 @@ class PokkenProfileData(BaseData):
|
||||
pokemon_exp=coalesce(pokemon_data.c.pokemon_exp, 0) + xp
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to add {xp} XP to pokemon ID {pokemon_id} for user {user_id}")
|
||||
|
||||
def get_pokemon_data(self, user_id: int, pokemon_id: int) -> Optional[Row]:
|
||||
async def get_pokemon_data(self, user_id: int, pokemon_id: int) -> Optional[Row]:
|
||||
sql = pokemon_data.select(and_(pokemon_data.c.user == user_id, pokemon_data.c.char_id == pokemon_id))
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_all_pokemon_data(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_all_pokemon_data(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = pokemon_data.select(pokemon_data.c.user == user_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def put_pokemon_battle_result(
|
||||
async def put_pokemon_battle_result(
|
||||
self, user_id: int, pokemon_id: int, match_type: PokkenConstants.BATTLE_TYPE, match_result: PokkenConstants.BATTLE_RESULT
|
||||
) -> None:
|
||||
"""
|
||||
@ -336,11 +336,11 @@ class PokkenProfileData(BaseData):
|
||||
win_vs_wan=coalesce(pokemon_data.c.win_vs_wan, 0) + 1 if match_type==PokkenConstants.BATTLE_TYPE.WAN and match_result==PokkenConstants.BATTLE_RESULT.WIN else coalesce(pokemon_data.c.win_vs_wan, 0),
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to record match stats for user {user_id}'s pokemon {pokemon_id} (type {match_type.name} | result {match_result.name})")
|
||||
|
||||
def put_stats(
|
||||
async def put_stats(
|
||||
self,
|
||||
user_id: int,
|
||||
exkos: int,
|
||||
@ -362,11 +362,11 @@ class PokkenProfileData(BaseData):
|
||||
continue_num=continues,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to update stats for user {user_id}")
|
||||
|
||||
def update_support_team(self, user_id: int, support_id: int, support1: int = None, support2: int = None) -> None:
|
||||
async def update_support_team(self, user_id: int, support_id: int, support1: int = None, support2: int = None) -> None:
|
||||
sql = update(profile).where(profile.c.user==user_id).values(
|
||||
support_set_1_1=support1 if support_id == 1 else profile.c.support_set_1_1,
|
||||
support_set_1_2=support2 if support_id == 1 else profile.c.support_set_1_2,
|
||||
@ -376,6 +376,6 @@ class PokkenProfileData(BaseData):
|
||||
support_set_3_2=support2 if support_id == 3 else profile.c.support_set_3_2,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to update support team {support_id} for user {user_id}")
|
||||
|
@ -16,7 +16,7 @@ class SaoRequestHeader:
|
||||
self.game_id: int = collection[4]
|
||||
self.version_id: int = collection[5]
|
||||
self.hash: str = collection[6]
|
||||
self.data_len: str = collection[7]
|
||||
self.data._len: str = collection[7]
|
||||
|
||||
class SaoBaseRequest:
|
||||
def __init__(self, header: SaoRequestHeader, data: bytes) -> None:
|
||||
@ -118,7 +118,7 @@ class SaoMasterDataVersionCheckResponse(SaoBaseResponse):
|
||||
super().__init__(cmd)
|
||||
self.result = 1
|
||||
self.update_flag = 0
|
||||
self.data_version = 100
|
||||
self.data._version = 100
|
||||
|
||||
def make(self) -> bytes:
|
||||
# create a resp struct
|
||||
@ -131,7 +131,7 @@ class SaoMasterDataVersionCheckResponse(SaoBaseResponse):
|
||||
resp_data = resp_struct.build(dict(
|
||||
result=self.result,
|
||||
update_flag=self.update_flag,
|
||||
data_version=self.data_version,
|
||||
data_version=self.data._version,
|
||||
))
|
||||
|
||||
self.length = len(resp_data)
|
||||
@ -145,7 +145,7 @@ class SaoCommonGetAppVersionsRequest(SaoBaseResponse):
|
||||
def __init__(self, cmd) -> None:
|
||||
super().__init__(cmd)
|
||||
self.result = 1
|
||||
self.data_list_size = 1 # Number of arrays
|
||||
self.data._list_size = 1 # Number of arrays
|
||||
|
||||
self.version_app_id = 1
|
||||
self.applying_start_date = "20230520193000"
|
||||
@ -163,7 +163,7 @@ class SaoCommonGetAppVersionsRequest(SaoBaseResponse):
|
||||
|
||||
resp_data = resp_struct.build(dict(
|
||||
result=self.result,
|
||||
data_list_size=self.data_list_size,
|
||||
data_list_size=self.data._list_size,
|
||||
|
||||
version_app_id=self.version_app_id,
|
||||
applying_start_date_size=len(self.applying_start_date) * 2,
|
||||
@ -2121,7 +2121,7 @@ class SaoGetYuiMedalBonusUserDataResponse(SaoBaseResponse):
|
||||
def __init__(self, cmd) -> None:
|
||||
super().__init__(cmd)
|
||||
self.result = 1
|
||||
self.data_size = 1 # number of arrays
|
||||
self.data._size = 1 # number of arrays
|
||||
|
||||
self.elapsed_days = 1
|
||||
self.loop_num = 1
|
||||
@ -2144,7 +2144,7 @@ class SaoGetYuiMedalBonusUserDataResponse(SaoBaseResponse):
|
||||
|
||||
resp_data = resp_struct.build(dict(
|
||||
result=self.result,
|
||||
data_size=self.data_size,
|
||||
data_size=self.data._size,
|
||||
|
||||
elapsed_days=self.elapsed_days,
|
||||
loop_num=self.loop_num,
|
||||
@ -3150,11 +3150,11 @@ class GetGashaMedalShopUserDataListResponse(SaoBaseResponse):
|
||||
def __init__(self, cmd_id: int) -> None:
|
||||
super().__init__(cmd_id)
|
||||
self.result = 1 # byte
|
||||
self.data_list: List[GashaMedalShopUserData] = []
|
||||
self.data._list: List[GashaMedalShopUserData] = []
|
||||
|
||||
def make(self) -> bytes:
|
||||
ret = encode_byte(self.result)
|
||||
ret += encode_arr_cls(self.data_list)
|
||||
ret += encode_arr_cls(self.data._list)
|
||||
|
||||
self.header.length = len(ret)
|
||||
return super().make() + ret
|
||||
@ -3168,11 +3168,11 @@ class GetMYuiMedalShopDataResponse(SaoBaseResponse):
|
||||
def __init__(self, cmd_id: int) -> None:
|
||||
super().__init__(cmd_id)
|
||||
self.result = 1 # byte
|
||||
self.data_list: List[YuiMedalShopData] = []
|
||||
self.data._list: List[YuiMedalShopData] = []
|
||||
|
||||
def make(self) -> bytes:
|
||||
ret = encode_byte(self.result)
|
||||
ret += encode_arr_cls(self.data_list)
|
||||
ret += encode_arr_cls(self.data._list)
|
||||
|
||||
self.header.length = len(ret)
|
||||
return super().make() + ret
|
||||
@ -3186,11 +3186,11 @@ class GetMYuiMedalShopItemsResponse(SaoBaseResponse):
|
||||
def __init__(self, cmd_id: int) -> None:
|
||||
super().__init__(cmd_id)
|
||||
self.result = 1 # byte
|
||||
self.data_list: List[YuiMedalShopItemData] = []
|
||||
self.data._list: List[YuiMedalShopItemData] = []
|
||||
|
||||
def make(self) -> bytes:
|
||||
ret = encode_byte(self.result)
|
||||
ret += encode_arr_cls(self.data_list)
|
||||
ret += encode_arr_cls(self.data._list)
|
||||
|
||||
self.header.length = len(ret)
|
||||
return super().make() + ret
|
||||
@ -3204,11 +3204,11 @@ class GetMGashaMedalShopsResponse(SaoBaseResponse):
|
||||
def __init__(self, cmd_id: int) -> None:
|
||||
super().__init__(cmd_id)
|
||||
self.result = 1 # byte
|
||||
self.data_list: List[GashaMedalShop] = []
|
||||
self.data._list: List[GashaMedalShop] = []
|
||||
|
||||
def make(self) -> bytes:
|
||||
ret = encode_byte(self.result)
|
||||
ret += encode_arr_cls(self.data_list)
|
||||
ret += encode_arr_cls(self.data._list)
|
||||
|
||||
self.header.length = len(ret)
|
||||
return super().make() + ret
|
||||
@ -3222,11 +3222,11 @@ class GetMResEarnCampaignShopsResponse(SaoBaseResponse):
|
||||
def __init__(self, cmd_id: int) -> None:
|
||||
super().__init__(cmd_id)
|
||||
self.result = 1 # byte
|
||||
self.data_list: List[ResEarnCampaignShop] = []
|
||||
self.data._list: List[ResEarnCampaignShop] = []
|
||||
|
||||
def make(self) -> bytes:
|
||||
ret = encode_byte(self.result)
|
||||
ret += encode_arr_cls(self.data_list)
|
||||
ret += encode_arr_cls(self.data._list)
|
||||
|
||||
self.header.length = len(ret)
|
||||
return super().make() + ret
|
||||
|
@ -29,17 +29,15 @@ class SaoReader(BaseReader):
|
||||
self.logger.error(f"Invalid project SAO version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
pull_bin_ram = True
|
||||
async def read(self) -> None:
|
||||
if path.exists(self.bin_dir):
|
||||
await self.read_csv(f"{self.bin_dir}")
|
||||
|
||||
if not path.exists(f"{self.bin_dir}"):
|
||||
self.logger.warning(f"Couldn't find csv file in {self.bin_dir}, skipping")
|
||||
pull_bin_ram = False
|
||||
else:
|
||||
self.logger.warn("Directory not found, nothing to import")
|
||||
|
||||
|
||||
if pull_bin_ram:
|
||||
self.read_csv(f"{self.bin_dir}")
|
||||
|
||||
def read_csv(self, bin_dir: str) -> None:
|
||||
async def read_csv(self, bin_dir: str) -> None:
|
||||
self.logger.info(f"Read csv from {bin_dir}")
|
||||
|
||||
self.logger.info("Now reading QuestScene.csv")
|
||||
@ -56,7 +54,7 @@ class SaoReader(BaseReader):
|
||||
self.logger.info(f"Added quest {questSceneId} | Name: {name}")
|
||||
|
||||
try:
|
||||
self.data.static.put_quest(
|
||||
await self.data.static.put_quest(
|
||||
questSceneId,
|
||||
0,
|
||||
sortNo,
|
||||
@ -86,7 +84,7 @@ class SaoReader(BaseReader):
|
||||
self.logger.info(f"Added hero {heroLogId} | Name: {name}")
|
||||
|
||||
try:
|
||||
self.data.static.put_hero(
|
||||
await self.data.static.put_hero(
|
||||
0,
|
||||
heroLogId,
|
||||
name,
|
||||
@ -119,7 +117,7 @@ class SaoReader(BaseReader):
|
||||
self.logger.info(f"Added equipment {equipmentId} | Name: {name}")
|
||||
|
||||
try:
|
||||
self.data.static.put_equipment(
|
||||
await self.data.static.put_equipment(
|
||||
0,
|
||||
equipmentId,
|
||||
name,
|
||||
@ -150,7 +148,7 @@ class SaoReader(BaseReader):
|
||||
self.logger.info(f"Added item {itemId} | Name: {name}")
|
||||
|
||||
try:
|
||||
self.data.static.put_item(
|
||||
await self.data.static.put_item(
|
||||
0,
|
||||
itemId,
|
||||
name,
|
||||
@ -181,7 +179,7 @@ class SaoReader(BaseReader):
|
||||
self.logger.info(f"Added support log {supportLogId} | Name: {name}")
|
||||
|
||||
try:
|
||||
self.data.static.put_support_log(
|
||||
await self.data.static.put_support_log(
|
||||
0,
|
||||
supportLogId,
|
||||
charaId,
|
||||
@ -213,7 +211,7 @@ class SaoReader(BaseReader):
|
||||
|
||||
if len(titleId) > 5:
|
||||
try:
|
||||
self.data.static.put_title(
|
||||
await self.data.static.put_title(
|
||||
0,
|
||||
titleId,
|
||||
displayName,
|
||||
@ -242,7 +240,7 @@ class SaoReader(BaseReader):
|
||||
self.logger.info(f"Added rare drop {questRareDropId} | Reward: {commonRewardId}")
|
||||
|
||||
try:
|
||||
self.data.static.put_rare_drop(
|
||||
await self.data.static.put_rare_drop(
|
||||
0,
|
||||
questRareDropId,
|
||||
commonRewardId,
|
||||
|
@ -139,7 +139,7 @@ end_sessions = Table(
|
||||
)
|
||||
|
||||
class SaoItemData(BaseData):
|
||||
def create_session(self, user_id: int, user_party_team_id: int, episode_id: int, play_mode: int, quest_drop_boost_apply_flag: int) -> Optional[int]:
|
||||
async def create_session(self, user_id: int, user_party_team_id: int, episode_id: int, play_mode: int, quest_drop_boost_apply_flag: int) -> Optional[int]:
|
||||
sql = insert(sessions).values(
|
||||
user=user_id,
|
||||
user_party_team_id=user_party_team_id,
|
||||
@ -150,13 +150,13 @@ class SaoItemData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(user=user_id)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to create SAO session for user {user_id}!")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def create_end_session(self, user_id: int, quest_id: int, play_result_flag: bool, reward_data: JSON) -> Optional[int]:
|
||||
async def create_end_session(self, user_id: int, quest_id: int, play_result_flag: bool, reward_data: JSON) -> Optional[int]:
|
||||
sql = insert(end_sessions).values(
|
||||
user=user_id,
|
||||
quest_id=quest_id,
|
||||
@ -166,13 +166,13 @@ class SaoItemData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(user=user_id)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to create SAO end session for user {user_id}!")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_item(self, user_id: int, item_id: int) -> Optional[int]:
|
||||
async def put_item(self, user_id: int, item_id: int) -> Optional[int]:
|
||||
sql = insert(item_data).values(
|
||||
user=user_id,
|
||||
item_id=item_id,
|
||||
@ -182,7 +182,7 @@ class SaoItemData(BaseData):
|
||||
item_id=item_id,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert item! user: {user_id}, item_id: {item_id}"
|
||||
@ -191,7 +191,7 @@ class SaoItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_equipment_data(self, user_id: int, equipment_id: int, enhancement_value: int, enhancement_exp: int, awakening_exp: int, awakening_stage: int, possible_awakening_flag: int) -> Optional[int]:
|
||||
async def put_equipment_data(self, user_id: int, equipment_id: int, enhancement_value: int, enhancement_exp: int, awakening_exp: int, awakening_stage: int, possible_awakening_flag: int) -> Optional[int]:
|
||||
sql = insert(equipment_data).values(
|
||||
user=user_id,
|
||||
equipment_id=equipment_id,
|
||||
@ -210,7 +210,7 @@ class SaoItemData(BaseData):
|
||||
possible_awakening_flag=possible_awakening_flag,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert equipment! user: {user_id}, equipment_id: {equipment_id}"
|
||||
@ -219,7 +219,7 @@ class SaoItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_hero_log(self, user_id: int, user_hero_log_id: int, log_level: int, log_exp: int, main_weapon: int, sub_equipment: int, skill_slot1_skill_id: int, skill_slot2_skill_id: int, skill_slot3_skill_id: int, skill_slot4_skill_id: int, skill_slot5_skill_id: int) -> Optional[int]:
|
||||
async def put_hero_log(self, user_id: int, user_hero_log_id: int, log_level: int, log_exp: int, main_weapon: int, sub_equipment: int, skill_slot1_skill_id: int, skill_slot2_skill_id: int, skill_slot3_skill_id: int, skill_slot4_skill_id: int, skill_slot5_skill_id: int) -> Optional[int]:
|
||||
sql = insert(hero_log_data).values(
|
||||
user=user_id,
|
||||
user_hero_log_id=user_hero_log_id,
|
||||
@ -246,7 +246,7 @@ class SaoItemData(BaseData):
|
||||
skill_slot5_skill_id=skill_slot5_skill_id,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert hero! user: {user_id}, user_hero_log_id: {user_hero_log_id}"
|
||||
@ -255,7 +255,7 @@ class SaoItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_hero_party(self, user_id: int, user_party_team_id: int, user_hero_log_id_1: int, user_hero_log_id_2: int, user_hero_log_id_3: int) -> Optional[int]:
|
||||
async def put_hero_party(self, user_id: int, user_party_team_id: int, user_hero_log_id_1: int, user_hero_log_id_2: int, user_hero_log_id_3: int) -> Optional[int]:
|
||||
sql = insert(hero_party).values(
|
||||
user=user_id,
|
||||
user_party_team_id=user_party_team_id,
|
||||
@ -270,7 +270,7 @@ class SaoItemData(BaseData):
|
||||
user_hero_log_id_3=user_hero_log_id_3,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert hero party! user: {user_id}, user_party_team_id: {user_party_team_id}"
|
||||
@ -279,7 +279,7 @@ class SaoItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_player_quest(self, user_id: int, episode_id: int, quest_clear_flag: bool, clear_time: int, combo_num: int, total_damage: int, concurrent_destroying_num: int) -> Optional[int]:
|
||||
async def put_player_quest(self, user_id: int, episode_id: int, quest_clear_flag: bool, clear_time: int, combo_num: int, total_damage: int, concurrent_destroying_num: int) -> Optional[int]:
|
||||
sql = insert(quest).values(
|
||||
user=user_id,
|
||||
episode_id=episode_id,
|
||||
@ -298,7 +298,7 @@ class SaoItemData(BaseData):
|
||||
concurrent_destroying_num=concurrent_destroying_num
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert quest! user: {user_id}, episode_id: {episode_id}"
|
||||
@ -307,15 +307,15 @@ class SaoItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_user_equipment(self, user_id: int, equipment_id: int) -> Optional[Dict]:
|
||||
async def get_user_equipment(self, user_id: int, equipment_id: int) -> Optional[Dict]:
|
||||
sql = equipment_data.select(equipment_data.c.user == user_id and equipment_data.c.equipment_id == equipment_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_user_equipments(
|
||||
async def get_user_equipments(
|
||||
self, user_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -327,12 +327,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_user_items(
|
||||
async def get_user_items(
|
||||
self, user_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -344,12 +344,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_hero_log(
|
||||
async def get_hero_log(
|
||||
self, user_id: int, user_hero_log_id: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -362,12 +362,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_hero_logs(
|
||||
async def get_hero_logs(
|
||||
self, user_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -379,12 +379,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_hero_party(
|
||||
async def get_hero_party(
|
||||
self, user_id: int, user_party_team_id: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
sql = hero_party.select(
|
||||
@ -394,12 +394,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_quest_log(
|
||||
async def get_quest_log(
|
||||
self, user_id: int, episode_id: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -412,12 +412,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_quest_logs(
|
||||
async def get_quest_logs(
|
||||
self, user_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -429,12 +429,12 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_session(
|
||||
async def get_session(
|
||||
self, user_id: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
sql = sessions.select(
|
||||
@ -445,12 +445,12 @@ class SaoItemData(BaseData):
|
||||
sessions.c.play_date.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_end_session(
|
||||
async def get_end_session(
|
||||
self, user_id: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
sql = end_sessions.select(
|
||||
@ -461,12 +461,12 @@ class SaoItemData(BaseData):
|
||||
end_sessions.c.play_date.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def remove_hero_log(self, user_id: int, user_hero_log_id: int) -> None:
|
||||
async def remove_hero_log(self, user_id: int, user_hero_log_id: int) -> None:
|
||||
sql = hero_log_data.delete(
|
||||
and_(
|
||||
hero_log_data.c.user == user_id,
|
||||
@ -474,31 +474,31 @@ class SaoItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to remove hero log! profile: {user_id}, user_hero_log_id: {user_hero_log_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def remove_equipment(self, user_id: int, equipment_id: int) -> None:
|
||||
async def remove_equipment(self, user_id: int, equipment_id: int) -> None:
|
||||
sql = equipment_data.delete(
|
||||
and_(equipment_data.c.user == user_id, equipment_data.c.equipment_id == equipment_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to remove equipment! profile: {user_id}, equipment_id: {equipment_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def remove_item(self, user_id: int, item_id: int) -> None:
|
||||
async def remove_item(self, user_id: int, item_id: int) -> None:
|
||||
sql = item_data.delete(
|
||||
and_(item_data.c.user == user_id, item_data.c.item_id == item_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to remove item! profile: {user_id}, item_id: {item_id}"
|
||||
|
@ -30,17 +30,17 @@ profile = Table(
|
||||
)
|
||||
|
||||
class SaoProfileData(BaseData):
|
||||
def create_profile(self, user_id: int) -> Optional[int]:
|
||||
async def create_profile(self, user_id: int) -> Optional[int]:
|
||||
sql = insert(profile).values(user=user_id)
|
||||
conflict = sql.on_duplicate_key_update(user=user_id)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to create SAO profile for user {user_id}!")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_profile(self, user_id: int, user_type: int, nick_name: str, rank_num: int, rank_exp: int, own_col: int, own_vp: int, own_yui_medal: int, setting_title_id: int) -> Optional[int]:
|
||||
async def put_profile(self, user_id: int, user_type: int, nick_name: str, rank_num: int, rank_exp: int, own_col: int, own_vp: int, own_yui_medal: int, setting_title_id: int) -> Optional[int]:
|
||||
sql = insert(profile).values(
|
||||
user=user_id,
|
||||
user_type=user_type,
|
||||
@ -62,7 +62,7 @@ class SaoProfileData(BaseData):
|
||||
setting_title_id=setting_title_id
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert profile! user: {user_id}"
|
||||
@ -71,9 +71,9 @@ class SaoProfileData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile(self, user_id: int) -> Optional[Row]:
|
||||
async def get_profile(self, user_id: int) -> Optional[Row]:
|
||||
sql = profile.select(profile.c.user == user_id)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
@ -128,25 +128,25 @@ title = Table(
|
||||
)
|
||||
|
||||
class SaoStaticData(BaseData):
|
||||
def put_quest( self, questSceneId: int, version: int, sortNo: int, name: str, enabled: bool ) -> Optional[int]:
|
||||
async def put_quest( self, questSceneId: int, version: int, sortNo: int, name: str, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(quest).values(
|
||||
questSceneId=questSceneId,
|
||||
version=version,
|
||||
sortNo=sortNo,
|
||||
name=name,
|
||||
tutorial=tutorial,
|
||||
enabled=enabled,
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(
|
||||
name=name, questSceneId=questSceneId, version=version
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_hero( self, version: int, heroLogId: int, name: str, nickname: str, rarity: int, skillTableSubId: int, awakeningExp: int, flavorText: str, enabled: bool ) -> Optional[int]:
|
||||
async def put_hero( self, version: int, heroLogId: int, name: str, nickname: str, rarity: int, skillTableSubId: int, awakeningExp: int, flavorText: str, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(hero).values(
|
||||
version=version,
|
||||
heroLogId=heroLogId,
|
||||
@ -163,12 +163,12 @@ class SaoStaticData(BaseData):
|
||||
name=name, heroLogId=heroLogId
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_equipment( self, version: int, equipmentId: int, name: str, equipmentType: int, weaponTypeId:int, rarity: int, flavorText: str, enabled: bool ) -> Optional[int]:
|
||||
async def put_equipment( self, version: int, equipmentId: int, name: str, equipmentType: int, weaponTypeId:int, rarity: int, flavorText: str, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(equipment).values(
|
||||
version=version,
|
||||
equipmentId=equipmentId,
|
||||
@ -184,12 +184,12 @@ class SaoStaticData(BaseData):
|
||||
name=name, equipmentId=equipmentId
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_item( self, version: int, itemId: int, name: str, itemTypeId: int, rarity: int, flavorText: str, enabled: bool ) -> Optional[int]:
|
||||
async def put_item( self, version: int, itemId: int, name: str, itemTypeId: int, rarity: int, flavorText: str, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(item).values(
|
||||
version=version,
|
||||
itemId=itemId,
|
||||
@ -204,12 +204,12 @@ class SaoStaticData(BaseData):
|
||||
name=name, itemId=itemId
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_support_log( self, version: int, supportLogId: int, charaId: int, name: str, rarity: int, salePrice: int, skillName: str, enabled: bool ) -> Optional[int]:
|
||||
async def put_support_log( self, version: int, supportLogId: int, charaId: int, name: str, rarity: int, salePrice: int, skillName: str, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(support).values(
|
||||
version=version,
|
||||
supportLogId=supportLogId,
|
||||
@ -225,12 +225,12 @@ class SaoStaticData(BaseData):
|
||||
name=name, supportLogId=supportLogId
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_rare_drop( self, version: int, questRareDropId: int, commonRewardId: int, enabled: bool ) -> Optional[int]:
|
||||
async def put_rare_drop( self, version: int, questRareDropId: int, commonRewardId: int, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(rare_drop).values(
|
||||
version=version,
|
||||
questRareDropId=questRareDropId,
|
||||
@ -242,12 +242,12 @@ class SaoStaticData(BaseData):
|
||||
questRareDropId=questRareDropId, commonRewardId=commonRewardId, version=version
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def put_title( self, version: int, titleId: int, displayName: str, requirement: int, rank: int, imageFilePath: str, enabled: bool ) -> Optional[int]:
|
||||
async def put_title( self, version: int, titleId: int, displayName: str, requirement: int, rank: int, imageFilePath: str, enabled: bool ) -> Optional[int]:
|
||||
sql = insert(title).values(
|
||||
version=version,
|
||||
titleId=titleId,
|
||||
@ -262,107 +262,107 @@ class SaoStaticData(BaseData):
|
||||
displayName=displayName, titleId=titleId
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_quests_id(self, sortNo: int) -> Optional[Dict]:
|
||||
async def get_quests_id(self, sortNo: int) -> Optional[Dict]:
|
||||
sql = quest.select(quest.c.sortNo == sortNo)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_quests_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
async def get_quests_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
sql = quest.select(quest.c.version == version and quest.c.enabled == enabled).order_by(
|
||||
quest.c.questSceneId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return [list[2] for list in result.fetchall()]
|
||||
|
||||
def get_hero_id(self, heroLogId: int) -> Optional[Dict]:
|
||||
async def get_hero_id(self, heroLogId: int) -> Optional[Dict]:
|
||||
sql = hero.select(hero.c.heroLogId == heroLogId)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_hero_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
async def get_hero_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
sql = hero.select(hero.c.version == version and hero.c.enabled == enabled).order_by(
|
||||
hero.c.heroLogId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return [list[2] for list in result.fetchall()]
|
||||
|
||||
def get_equipment_id(self, equipmentId: int) -> Optional[Dict]:
|
||||
async def get_equipment_id(self, equipmentId: int) -> Optional[Dict]:
|
||||
sql = equipment.select(equipment.c.equipmentId == equipmentId)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_equipment_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
async def get_equipment_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
sql = equipment.select(equipment.c.version == version and equipment.c.enabled == enabled).order_by(
|
||||
equipment.c.equipmentId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return [list[2] for list in result.fetchall()]
|
||||
|
||||
def get_item_id(self, itemId: int) -> Optional[Dict]:
|
||||
async def get_item_id(self, itemId: int) -> Optional[Dict]:
|
||||
sql = item.select(item.c.itemId == itemId)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_rare_drop_id(self, questRareDropId: int) -> Optional[Dict]:
|
||||
async def get_rare_drop_id(self, questRareDropId: int) -> Optional[Dict]:
|
||||
sql = rare_drop.select(rare_drop.c.questRareDropId == questRareDropId)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_item_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
async def get_item_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
sql = item.select(item.c.version == version and item.c.enabled == enabled).order_by(
|
||||
item.c.itemId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return [list[2] for list in result.fetchall()]
|
||||
|
||||
def get_support_log_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
async def get_support_log_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
sql = support.select(support.c.version == version and support.c.enabled == enabled).order_by(
|
||||
support.c.supportLogId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return [list[2] for list in result.fetchall()]
|
||||
|
||||
def get_title_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
async def get_title_ids(self, version: int, enabled: bool) -> Optional[List[Dict]]:
|
||||
sql = title.select(title.c.version == version and title.c.enabled == enabled).order_by(
|
||||
title.c.titleId.asc()
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return [list[2] for list in result.fetchall()]
|
@ -98,9 +98,9 @@ class WaccaBase:
|
||||
req = HousingStartRequestV1(data)
|
||||
allnet_region_id = None
|
||||
|
||||
machine = self.data.arcade.get_machine(req.chipId)
|
||||
machine = await self.data.arcade.get_machine(req.chipId)
|
||||
if machine is not None:
|
||||
arcade = self.data.arcade.get_arcade(machine["arcade"])
|
||||
arcade = await self.data.arcade.get_arcade(machine["arcade"])
|
||||
allnet_region_id = arcade["region_id"]
|
||||
|
||||
if req.appVersion.country == AllnetCountryCode.JAPAN.value:
|
||||
@ -139,7 +139,7 @@ class WaccaBase:
|
||||
req = UserStatusGetRequest(data)
|
||||
resp = UserStatusGetV1Response()
|
||||
|
||||
profile = self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
profile = await self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
if profile is None:
|
||||
self.logger.info(f"No user exists for aime id {req.aimeId}")
|
||||
resp.profileStatus = ProfileStatus.ProfileRegister
|
||||
@ -159,14 +159,14 @@ class WaccaBase:
|
||||
resp.userStatus.wp = profile["wp"]
|
||||
resp.userStatus.useCount = profile["login_count"]
|
||||
|
||||
set_title_id = self.data.profile.get_options(
|
||||
set_title_id = await self.data.profile.get_options(
|
||||
WaccaConstants.OPTIONS["set_title_id"], profile["user"]
|
||||
)
|
||||
if set_title_id is None:
|
||||
set_title_id = self.OPTIONS_DEFAULTS["set_title_id"]
|
||||
resp.setTitleId = set_title_id
|
||||
|
||||
set_icon_id = self.data.profile.get_options(
|
||||
set_icon_id = await self.data.profile.get_options(
|
||||
WaccaConstants.OPTIONS["set_title_id"], profile["user"]
|
||||
)
|
||||
if set_icon_id is None:
|
||||
@ -191,7 +191,7 @@ class WaccaBase:
|
||||
resp.lastLoginDate = 0
|
||||
|
||||
else:
|
||||
profile = self.data.profile.get_profile(req.userId)
|
||||
profile = await self.data.profile.get_profile(req.userId)
|
||||
if profile is None:
|
||||
self.logger.warning(
|
||||
f"Unknown user id {req.userId} attempted login from {req.chipId}"
|
||||
@ -215,7 +215,7 @@ class WaccaBase:
|
||||
if midnight_today_ts - last_login_time > 86400:
|
||||
is_consec_day = False
|
||||
|
||||
self.data.profile.session_login(
|
||||
await self.data.profile.session_login(
|
||||
req.userId, resp.firstLoginDaily, is_consec_day
|
||||
)
|
||||
|
||||
@ -230,7 +230,7 @@ class WaccaBase:
|
||||
async def handle_user_status_create_request(self, data: Dict) -> Dict:
|
||||
req = UserStatusCreateRequest(data)
|
||||
|
||||
profileId = self.data.profile.create_profile(
|
||||
profileId = await self.data.profile.create_profile(
|
||||
req.aimeId, req.username, self.version
|
||||
)
|
||||
|
||||
@ -239,30 +239,30 @@ class WaccaBase:
|
||||
|
||||
if profileId == 0:
|
||||
# We've already made this profile, just return success
|
||||
new_user = self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
new_user = await self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
profileId = new_user['id']
|
||||
|
||||
# Insert starting items
|
||||
self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104001)
|
||||
self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104002)
|
||||
self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104003)
|
||||
self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104005)
|
||||
await self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104001)
|
||||
await self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104002)
|
||||
await self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104003)
|
||||
await self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["title"], 104005)
|
||||
|
||||
self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["icon"], 102001)
|
||||
self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["icon"], 102002)
|
||||
await self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["icon"], 102001)
|
||||
await self.data.item.put_item(req.aimeId, WaccaConstants.ITEM_TYPES["icon"], 102002)
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["note_color"], 103001
|
||||
)
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["note_color"], 203001
|
||||
)
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["note_sound"], 105001
|
||||
)
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210001
|
||||
)
|
||||
|
||||
@ -272,7 +272,7 @@ class WaccaBase:
|
||||
req = UserStatusGetDetailRequest(data)
|
||||
resp = UserStatusGetDetailResponseV1()
|
||||
|
||||
profile = self.data.profile.get_profile(req.userId)
|
||||
profile = await self.data.profile.get_profile(req.userId)
|
||||
if profile is None:
|
||||
self.logger.warning(f"Unknown profile {req.userId}")
|
||||
return resp.make()
|
||||
@ -280,12 +280,12 @@ class WaccaBase:
|
||||
self.logger.info(f"Get detail for profile {req.userId}")
|
||||
user_id = profile["user"]
|
||||
|
||||
profile_scores = self.data.score.get_best_scores(user_id)
|
||||
profile_items = self.data.item.get_items(user_id)
|
||||
profile_song_unlocks = self.data.item.get_song_unlocks(user_id)
|
||||
profile_options = self.data.profile.get_options(user_id)
|
||||
profile_trophies = self.data.item.get_trophies(user_id)
|
||||
profile_tickets = self.data.item.get_tickets(user_id)
|
||||
profile_scores = await self.data.score.get_best_scores(user_id)
|
||||
profile_items = await self.data.item.get_items(user_id)
|
||||
profile_song_unlocks = await self.data.item.get_song_unlocks(user_id)
|
||||
profile_options = await self.data.profile.get_options(user_id)
|
||||
profile_trophies = await self.data.item.get_trophies(user_id)
|
||||
profile_tickets = await self.data.item.get_tickets(user_id)
|
||||
|
||||
resp.songUpdateTime = int(profile["last_login_date"].timestamp())
|
||||
resp.songPlayStatus = [profile["last_song_id"], 1]
|
||||
@ -437,7 +437,7 @@ class WaccaBase:
|
||||
req = UserTrialGetRequest(data)
|
||||
resp = UserTrialGetResponse()
|
||||
|
||||
user_id = self.data.profile.profile_to_aime_user(req.profileId)
|
||||
user_id = await self.data.profile.profile_to_aime_user(req.profileId)
|
||||
if user_id is None:
|
||||
self.logger.error(
|
||||
f"handle_user_trial_get_request: No profile with id {req.profileId}"
|
||||
@ -445,7 +445,7 @@ class WaccaBase:
|
||||
return resp.make()
|
||||
|
||||
self.logger.info(f"Get trial info for user {req.profileId}")
|
||||
stages = self.data.score.get_stageup(user_id, self.version)
|
||||
stages = await self.data.score.get_stageup(user_id, self.version)
|
||||
if stages is None:
|
||||
stages = []
|
||||
|
||||
@ -485,15 +485,15 @@ class WaccaBase:
|
||||
while len(req.songScores) < 3:
|
||||
req.songScores.append(0)
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
|
||||
user_id = profile["user"]
|
||||
old_stage = self.data.score.get_stageup_stage(
|
||||
old_stage = await self.data.score.get_stageup_stage(
|
||||
user_id, self.version, req.stageId
|
||||
)
|
||||
|
||||
if old_stage is None:
|
||||
self.data.score.put_stageup(
|
||||
await self.data.score.put_stageup(
|
||||
user_id,
|
||||
self.version,
|
||||
req.stageId,
|
||||
@ -519,7 +519,7 @@ class WaccaBase:
|
||||
best_score2 = old_stage["song2_score"]
|
||||
best_score3 = old_stage["song3_score"]
|
||||
|
||||
self.data.score.put_stageup(
|
||||
await self.data.score.put_stageup(
|
||||
user_id,
|
||||
self.version,
|
||||
req.stageId,
|
||||
@ -537,17 +537,17 @@ class WaccaBase:
|
||||
req.stageLevel == profile["dan_level"]
|
||||
and req.clearType.value > profile["dan_type"]
|
||||
):
|
||||
self.data.profile.update_profile_dan(
|
||||
await self.data.profile.update_profile_dan(
|
||||
req.profileId, req.stageLevel, req.clearType.value
|
||||
)
|
||||
|
||||
self.util_put_items(req.profileId, user_id, req.itemsObtained)
|
||||
await self.util_put_items(req.profileId, user_id, req.itemsObtained)
|
||||
|
||||
# user/status/update isn't called after stageup so we have to do some things now
|
||||
current_icon = self.data.profile.get_options(
|
||||
current_icon = await self.data.profile.get_options(
|
||||
user_id, WaccaConstants.OPTIONS["set_icon_id"]
|
||||
)
|
||||
current_nav = self.data.profile.get_options(
|
||||
current_nav = await self.data.profile.get_options(
|
||||
user_id, WaccaConstants.OPTIONS["set_nav_id"]
|
||||
)
|
||||
|
||||
@ -560,13 +560,13 @@ class WaccaBase:
|
||||
else:
|
||||
current_nav = current_nav["value"]
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id, WaccaConstants.ITEM_TYPES["icon"], current_icon
|
||||
)
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id, WaccaConstants.ITEM_TYPES["navigator"], current_nav
|
||||
)
|
||||
self.data.profile.update_profile_playtype(
|
||||
await self.data.profile.update_profile_playtype(
|
||||
req.profileId, 4, data["appVersion"][:7]
|
||||
)
|
||||
return BaseResponse().make()
|
||||
@ -583,16 +583,16 @@ class WaccaBase:
|
||||
req = UserSugarokuUpdateRequestV2(data)
|
||||
mission_flg = req.mission_flag
|
||||
|
||||
user_id = self.data.profile.profile_to_aime_user(req.profileId)
|
||||
user_id = await self.data.profile.profile_to_aime_user(req.profileId)
|
||||
if user_id is None:
|
||||
self.logger.info(
|
||||
f"handle_user_sugoroku_update_request unknwon profile ID {req.profileId}"
|
||||
)
|
||||
return resp.make()
|
||||
|
||||
self.util_put_items(req.profileId, user_id, req.itemsObtainted)
|
||||
await self.util_put_items(req.profileId, user_id, req.itemsObtainted)
|
||||
|
||||
self.data.profile.update_gate(
|
||||
await self.data.profile.update_gate(
|
||||
user_id,
|
||||
req.gateId,
|
||||
req.page,
|
||||
@ -609,13 +609,13 @@ class WaccaBase:
|
||||
async def handle_user_music_unlock_request(self, data: Dict) -> Dict:
|
||||
req = UserMusicUnlockRequest(data)
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
if profile is None:
|
||||
return BaseResponse().make()
|
||||
user_id = profile["user"]
|
||||
current_wp = profile["wp"]
|
||||
|
||||
tickets = self.data.item.get_tickets(user_id)
|
||||
tickets = await self.data.item.get_tickets(user_id)
|
||||
new_tickets: List[TicketItem] = []
|
||||
|
||||
for ticket in tickets:
|
||||
@ -628,7 +628,7 @@ class WaccaBase:
|
||||
):
|
||||
if current_wp >= item.quantity:
|
||||
current_wp -= item.quantity
|
||||
self.data.profile.spend_wp(req.profileId, item.quantity)
|
||||
await self.data.profile.spend_wp(req.profileId, item.quantity)
|
||||
else:
|
||||
return BaseResponse().make()
|
||||
|
||||
@ -641,21 +641,21 @@ class WaccaBase:
|
||||
self.logger.debug(
|
||||
f"Remove ticket ID {new_tickets[x].userTicketId} type {new_tickets[x].ticketId} from {user_id}"
|
||||
)
|
||||
self.data.item.spend_ticket(new_tickets[x].userTicketId)
|
||||
await self.data.item.spend_ticket(new_tickets[x].userTicketId)
|
||||
new_tickets.pop(x)
|
||||
break
|
||||
|
||||
# wp, ticket info
|
||||
if req.difficulty > WaccaConstants.Difficulty.HARD.value:
|
||||
old_score = self.data.score.get_best_score(
|
||||
old_score = await self.data.score.get_best_score(
|
||||
user_id, req.songId, req.difficulty
|
||||
)
|
||||
if not old_score:
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
user_id, req.songId, req.difficulty, 0, [0] * 5, [0] * 13, 0, 0
|
||||
)
|
||||
|
||||
self.data.item.unlock_song(
|
||||
await self.data.item.unlock_song(
|
||||
user_id,
|
||||
req.songId,
|
||||
req.difficulty
|
||||
@ -698,7 +698,7 @@ class WaccaBase:
|
||||
)
|
||||
return resp.make()
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
|
||||
if profile is None:
|
||||
self.logger.warning(
|
||||
@ -707,7 +707,7 @@ class WaccaBase:
|
||||
return resp.make()
|
||||
|
||||
user_id = profile["user"]
|
||||
self.util_put_items(req.profileId, user_id, req.itemsObtained)
|
||||
await self.util_put_items(req.profileId, user_id, req.itemsObtained)
|
||||
|
||||
playlog_clear_status = (
|
||||
req.songDetail.flagCleared
|
||||
@ -716,7 +716,7 @@ class WaccaBase:
|
||||
+ req.songDetail.flagAllMarvelous
|
||||
)
|
||||
|
||||
self.data.score.put_playlog(
|
||||
await self.data.score.put_playlog(
|
||||
user_id,
|
||||
req.songDetail.songId,
|
||||
req.songDetail.difficulty,
|
||||
@ -733,7 +733,7 @@ class WaccaBase:
|
||||
self.season,
|
||||
)
|
||||
|
||||
old_score = self.data.score.get_best_score(
|
||||
old_score = await self.data.score.get_best_score(
|
||||
user_id, req.songDetail.songId, req.songDetail.difficulty
|
||||
)
|
||||
|
||||
@ -749,7 +749,7 @@ class WaccaBase:
|
||||
|
||||
grades[req.songDetail.grade.value - 1] = 1
|
||||
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
user_id,
|
||||
req.songDetail.songId,
|
||||
req.songDetail.difficulty,
|
||||
@ -805,7 +805,7 @@ class WaccaBase:
|
||||
old_score["rating"],
|
||||
)
|
||||
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
user_id,
|
||||
req.songDetail.songId,
|
||||
req.songDetail.difficulty,
|
||||
@ -846,17 +846,17 @@ class WaccaBase:
|
||||
req = UserMissionUpdateRequest(data)
|
||||
page_status = req.params[1][1]
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
if profile is None:
|
||||
return BaseResponse().make()
|
||||
|
||||
if len(req.itemsObtained) > 0:
|
||||
self.util_put_items(req.profileId, profile["user"], req.itemsObtained)
|
||||
await self.util_put_items(req.profileId, profile["user"], req.itemsObtained)
|
||||
|
||||
self.data.profile.update_bingo(
|
||||
await self.data.profile.update_bingo(
|
||||
profile["user"], req.bingoDetail.pageNumber, page_status
|
||||
)
|
||||
self.data.profile.update_tutorial_flags(req.profileId, req.params[3])
|
||||
await self.data.profile.update_tutorial_flags(req.profileId, req.params[3])
|
||||
|
||||
return BaseResponse().make()
|
||||
|
||||
@ -864,7 +864,7 @@ class WaccaBase:
|
||||
req = UserGoodsPurchaseRequest(data)
|
||||
resp = UserGoodsPurchaseResponse()
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
if profile is None:
|
||||
return BaseResponse().make()
|
||||
|
||||
@ -876,20 +876,20 @@ class WaccaBase:
|
||||
and not self.game_config.mods.infinite_wp
|
||||
):
|
||||
resp.currentWp -= req.cost
|
||||
self.data.profile.spend_wp(req.profileId, req.cost)
|
||||
await self.data.profile.spend_wp(req.profileId, req.cost)
|
||||
|
||||
elif req.purchaseType == PurchaseType.PurchaseTypeCredit:
|
||||
self.logger.info(
|
||||
f"User {req.profileId} Purchased item {req.itemObtained.itemType} id {req.itemObtained.itemId} for {req.cost} credits on machine {req.chipId}"
|
||||
)
|
||||
|
||||
self.util_put_items(req.profileId, user_id, [req.itemObtained])
|
||||
await self.util_put_items(req.profileId, user_id, [req.itemObtained])
|
||||
|
||||
if self.game_config.mods.infinite_tickets:
|
||||
for x in range(5):
|
||||
resp.tickets.append(TicketItem(x, 106002, 0))
|
||||
else:
|
||||
tickets = self.data.item.get_tickets(user_id)
|
||||
tickets = await self.data.item.get_tickets(user_id)
|
||||
|
||||
for ticket in tickets:
|
||||
resp.tickets.append(
|
||||
@ -914,7 +914,7 @@ class WaccaBase:
|
||||
async def handle_user_rating_update_request(self, data: Dict) -> Dict:
|
||||
req = UserRatingUpdateRequest(data)
|
||||
|
||||
user_id = self.data.profile.profile_to_aime_user(req.profileId)
|
||||
user_id = await self.data.profile.profile_to_aime_user(req.profileId)
|
||||
|
||||
if user_id is None:
|
||||
self.logger.error(
|
||||
@ -923,33 +923,33 @@ class WaccaBase:
|
||||
return BaseResponse().make()
|
||||
|
||||
for song in req.songs:
|
||||
self.data.score.update_song_rating(
|
||||
await self.data.score.update_song_rating(
|
||||
user_id, song.songId, song.difficulty, song.rating
|
||||
)
|
||||
|
||||
self.data.profile.update_user_rating(req.profileId, req.totalRating)
|
||||
await self.data.profile.update_user_rating(req.profileId, req.totalRating)
|
||||
|
||||
return BaseResponse().make()
|
||||
|
||||
async def handle_user_status_update_request(self, data: Dict) -> Dict:
|
||||
req = UserStatusUpdateRequestV1(data)
|
||||
|
||||
user_id = self.data.profile.profile_to_aime_user(req.profileId)
|
||||
user_id = await self.data.profile.profile_to_aime_user(req.profileId)
|
||||
if user_id is None:
|
||||
self.logger.info(
|
||||
f"handle_user_status_update_request: No profile with ID {req.profileId}"
|
||||
)
|
||||
return BaseResponse().make()
|
||||
|
||||
self.util_put_items(req.profileId, user_id, req.itemsRecieved)
|
||||
self.data.profile.update_profile_playtype(
|
||||
await self.util_put_items(req.profileId, user_id, req.itemsRecieved)
|
||||
await self.data.profile.update_profile_playtype(
|
||||
req.profileId, req.playType.value, data["appVersion"][:7]
|
||||
)
|
||||
|
||||
current_icon = self.data.profile.get_options(
|
||||
current_icon = await self.data.profile.get_options(
|
||||
user_id, WaccaConstants.OPTIONS["set_icon_id"]
|
||||
)
|
||||
current_nav = self.data.profile.get_options(
|
||||
current_nav = await self.data.profile.get_options(
|
||||
user_id, WaccaConstants.OPTIONS["set_nav_id"]
|
||||
)
|
||||
|
||||
@ -962,10 +962,10 @@ class WaccaBase:
|
||||
else:
|
||||
current_nav = current_nav["value"]
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id, WaccaConstants.ITEM_TYPES["icon"], current_icon
|
||||
)
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
user_id, WaccaConstants.ITEM_TYPES["navigator"], current_nav
|
||||
)
|
||||
return BaseResponse().make()
|
||||
@ -973,19 +973,19 @@ class WaccaBase:
|
||||
async def handle_user_info_update_request(self, data: Dict) -> Dict:
|
||||
req = UserInfoUpdateRequest(data)
|
||||
|
||||
user_id = self.data.profile.profile_to_aime_user(req.profileId)
|
||||
user_id = await self.data.profile.profile_to_aime_user(req.profileId)
|
||||
|
||||
for opt in req.optsUpdated:
|
||||
self.data.profile.update_option(user_id, opt.optId, opt.optVal)
|
||||
await self.data.profile.update_option(user_id, opt.optId, opt.optVal)
|
||||
|
||||
for update in req.datesUpdated:
|
||||
pass
|
||||
|
||||
for fav in req.favoritesAdded:
|
||||
self.data.profile.add_favorite_song(user_id, fav)
|
||||
await self.data.profile.add_favorite_song(user_id, fav)
|
||||
|
||||
for unfav in req.favoritesRemoved:
|
||||
self.data.profile.remove_favorite_song(user_id, unfav)
|
||||
await self.data.profile.remove_favorite_song(user_id, unfav)
|
||||
|
||||
return BaseResponse().make()
|
||||
|
||||
@ -993,7 +993,7 @@ class WaccaBase:
|
||||
req = UserVipGetRequest(data)
|
||||
resp = UserVipGetResponse()
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
if profile is None:
|
||||
self.logger.warning(
|
||||
f"handle_user_vip_get_request no profile with ID {req.profileId}"
|
||||
@ -1024,7 +1024,7 @@ class WaccaBase:
|
||||
async def handle_user_vip_start_request(self, data: Dict) -> Dict:
|
||||
req = UserVipStartRequest(data)
|
||||
|
||||
profile = self.data.profile.get_profile(req.profileId)
|
||||
profile = await self.data.profile.get_profile(req.profileId)
|
||||
if profile is None:
|
||||
return BaseResponse().make()
|
||||
|
||||
@ -1040,10 +1040,10 @@ class WaccaBase:
|
||||
).make()
|
||||
|
||||
vip_exp_time = self.srvtime + timedelta(days=req.days)
|
||||
self.data.profile.update_vip_time(req.profileId, vip_exp_time)
|
||||
await self.data.profile.update_vip_time(req.profileId, vip_exp_time)
|
||||
return UserVipStartResponse(int(vip_exp_time.timestamp())).make()
|
||||
|
||||
def util_put_items(
|
||||
async def util_put_items(
|
||||
self, profile_id: int, user_id: int, items_obtained: List[GenericItemRecv]
|
||||
) -> None:
|
||||
if user_id is None or profile_id <= 0:
|
||||
@ -1052,10 +1052,10 @@ class WaccaBase:
|
||||
if items_obtained:
|
||||
for item in items_obtained:
|
||||
if item.itemType == WaccaConstants.ITEM_TYPES["xp"]:
|
||||
self.data.profile.add_xp(profile_id, item.quantity)
|
||||
await self.data.profile.add_xp(profile_id, item.quantity)
|
||||
|
||||
elif item.itemType == WaccaConstants.ITEM_TYPES["wp"]:
|
||||
self.data.profile.add_wp(profile_id, item.quantity)
|
||||
await self.data.profile.add_wp(profile_id, item.quantity)
|
||||
|
||||
elif (
|
||||
item.itemType
|
||||
@ -1063,11 +1063,11 @@ class WaccaBase:
|
||||
or item.itemType == WaccaConstants.ITEM_TYPES["music_unlock"]
|
||||
):
|
||||
if item.quantity > WaccaConstants.Difficulty.HARD.value:
|
||||
old_score = self.data.score.get_best_score(
|
||||
old_score = await self.data.score.get_best_score(
|
||||
user_id, item.itemId, item.quantity
|
||||
)
|
||||
if not old_score:
|
||||
self.data.score.put_best_score(
|
||||
await self.data.score.put_best_score(
|
||||
user_id,
|
||||
item.itemId,
|
||||
item.quantity,
|
||||
@ -1080,18 +1080,18 @@ class WaccaBase:
|
||||
|
||||
if item.quantity == 0:
|
||||
item.quantity = WaccaConstants.Difficulty.HARD.value
|
||||
self.data.item.unlock_song(user_id, item.itemId, item.quantity)
|
||||
await self.data.item.unlock_song(user_id, item.itemId, item.quantity)
|
||||
|
||||
elif item.itemType == WaccaConstants.ITEM_TYPES["ticket"]:
|
||||
self.data.item.add_ticket(user_id, item.itemId)
|
||||
await self.data.item.add_ticket(user_id, item.itemId)
|
||||
|
||||
elif item.itemType == WaccaConstants.ITEM_TYPES["trophy"]:
|
||||
self.data.item.update_trophy(
|
||||
await self.data.item.update_trophy(
|
||||
user_id, item.itemId, self.season, item.quantity, 0
|
||||
)
|
||||
|
||||
else:
|
||||
self.data.item.put_item(user_id, item.itemType, item.itemId)
|
||||
await self.data.item.put_item(user_id, item.itemType, item.itemId)
|
||||
|
||||
def util_calc_song_rating(self, score: int, difficulty: float) -> int:
|
||||
if score >= 990000:
|
||||
|
@ -24,7 +24,7 @@ class WaccaFrontend(FE_Base):
|
||||
)
|
||||
self.nav_name = "Wacca"
|
||||
|
||||
def render_GET(self, request: Request) -> bytes:
|
||||
async def render_GET(self, request: Request) -> bytes:
|
||||
template = self.environment.get_template(
|
||||
"titles/wacca/frontend/wacca_index.jinja"
|
||||
)
|
||||
|
@ -45,20 +45,20 @@ class WaccaLily(WaccaS):
|
||||
req = UserStatusCreateRequest(data)
|
||||
ret = await super().handle_user_status_create_request(data)
|
||||
|
||||
new_user = self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
new_user = await self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
|
||||
if new_user is None:
|
||||
return BaseResponse().make()
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["user_plate"], 211001
|
||||
) # Added lily
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["note_sound"], 205005
|
||||
) # Added lily
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210002
|
||||
) # Lily, Added Lily
|
||||
|
||||
@ -68,13 +68,13 @@ class WaccaLily(WaccaS):
|
||||
req = UserStatusGetRequest(data)
|
||||
resp = UserStatusGetV2Response()
|
||||
|
||||
profile = self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
profile = await self.data.profile.get_profile(aime_id=req.aimeId)
|
||||
if profile is None:
|
||||
self.logger.info(f"No user exists for aime id {req.aimeId}")
|
||||
resp.profileStatus = ProfileStatus.ProfileRegister
|
||||
return resp.make()
|
||||
|
||||
opts = self.data.profile.get_options(req.aimeId)
|
||||
opts = await self.data.profile.get_options(req.aimeId)
|
||||
|
||||
self.logger.info(f"User preview for {req.aimeId} from {req.chipId}")
|
||||
if profile["last_game_ver"] is None:
|
||||
@ -94,14 +94,14 @@ class WaccaLily(WaccaS):
|
||||
resp.userStatus.loginsToday = profile["login_count_today"]
|
||||
resp.userStatus.rating = profile["rating"]
|
||||
|
||||
set_title_id = self.data.profile.get_options(
|
||||
set_title_id = await self.data.profile.get_options(
|
||||
WaccaConstants.OPTIONS["set_title_id"], profile["user"]
|
||||
)
|
||||
if set_title_id is None:
|
||||
set_title_id = self.OPTIONS_DEFAULTS["set_title_id"]
|
||||
resp.setTitleId = set_title_id
|
||||
|
||||
set_icon_id = self.data.profile.get_options(
|
||||
set_icon_id = await self.data.profile.get_options(
|
||||
WaccaConstants.OPTIONS["set_title_id"], profile["user"]
|
||||
)
|
||||
if set_icon_id is None:
|
||||
@ -155,7 +155,7 @@ class WaccaLily(WaccaS):
|
||||
resp.lastLoginDate = 0
|
||||
|
||||
else:
|
||||
profile = self.data.profile.get_profile(req.userId)
|
||||
profile = await self.data.profile.get_profile(req.userId)
|
||||
if profile is None:
|
||||
self.logger.warning(
|
||||
f"Unknown user id {req.userId} attempted login from {req.chipId}"
|
||||
@ -179,7 +179,7 @@ class WaccaLily(WaccaS):
|
||||
if midnight_today_ts - last_login_time > 86400:
|
||||
is_consec_day = False
|
||||
|
||||
self.data.profile.session_login(
|
||||
await self.data.profile.session_login(
|
||||
req.userId, resp.firstLoginDaily, is_consec_day
|
||||
)
|
||||
resp.vipInfo.pageYear = datetime.now().year
|
||||
@ -196,7 +196,7 @@ class WaccaLily(WaccaS):
|
||||
else:
|
||||
resp = UserStatusGetDetailResponseV2()
|
||||
|
||||
profile = self.data.profile.get_profile(req.userId)
|
||||
profile = await self.data.profile.get_profile(req.userId)
|
||||
if profile is None:
|
||||
self.logger.warning(f"Unknown profile {req.userId}")
|
||||
return resp.make()
|
||||
@ -204,14 +204,14 @@ class WaccaLily(WaccaS):
|
||||
self.logger.info(f"Get detail for profile {req.userId}")
|
||||
user_id = profile["user"]
|
||||
|
||||
profile_scores = self.data.score.get_best_scores(user_id)
|
||||
profile_items = self.data.item.get_items(user_id)
|
||||
profile_song_unlocks = self.data.item.get_song_unlocks(user_id)
|
||||
profile_options = self.data.profile.get_options(user_id)
|
||||
profile_favorites = self.data.profile.get_favorite_songs(user_id)
|
||||
profile_gates = self.data.profile.get_gates(user_id)
|
||||
profile_trophies = self.data.item.get_trophies(user_id)
|
||||
profile_tickets = self.data.item.get_tickets(user_id)
|
||||
profile_scores = await self.data.score.get_best_scores(user_id)
|
||||
profile_items = await self.data.item.get_items(user_id)
|
||||
profile_song_unlocks = await self.data.item.get_song_unlocks(user_id)
|
||||
profile_options = await self.data.profile.get_options(user_id)
|
||||
profile_favorites = await self.data.profile.get_favorite_songs(user_id)
|
||||
profile_gates = await self.data.profile.get_gates(user_id)
|
||||
profile_trophies = await self.data.item.get_trophies(user_id)
|
||||
profile_tickets = await self.data.item.get_tickets(user_id)
|
||||
|
||||
if profile["vip_expire_time"] is None:
|
||||
resp.userStatus.vipExpireTime = 0
|
||||
@ -446,7 +446,7 @@ class WaccaLily(WaccaS):
|
||||
async def handle_user_status_update_request(self, data: Dict) -> Dict:
|
||||
super().handle_user_status_update_request(data)
|
||||
req = UserStatusUpdateRequestV2(data)
|
||||
self.data.profile.update_profile_lastplayed(
|
||||
await self.data.profile.update_profile_lastplayed(
|
||||
req.profileId,
|
||||
req.lastSongInfo.lastSongId,
|
||||
req.lastSongInfo.lastSongDiff,
|
||||
|
@ -43,9 +43,9 @@ class WaccaLilyR(WaccaLily):
|
||||
req = HousingStartRequestV2(data)
|
||||
allnet_region_id = None
|
||||
|
||||
machine = self.data.arcade.get_machine(req.chipId)
|
||||
machine = await self.data.arcade.get_machine(req.chipId)
|
||||
if machine is not None:
|
||||
arcade = self.data.arcade.get_arcade(machine["arcade"])
|
||||
arcade = await self.data.arcade.get_arcade(machine["arcade"])
|
||||
allnet_region_id = arcade["region_id"]
|
||||
|
||||
if req.appVersion.country == AllnetCountryCode.JAPAN.value:
|
||||
@ -75,28 +75,28 @@ class WaccaLilyR(WaccaLily):
|
||||
req = UserStatusCreateRequest(data)
|
||||
resp = await super().handle_user_status_create_request(data)
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210054
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210055
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210056
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210057
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210058
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210059
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210060
|
||||
) # Added lily r
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 210061
|
||||
) # Added lily r
|
||||
|
||||
|
@ -29,7 +29,7 @@ class WaccaReader(BaseReader):
|
||||
self.logger.error(f"Invalid wacca version {version}")
|
||||
exit(1)
|
||||
|
||||
def read(self) -> None:
|
||||
async def read(self) -> None:
|
||||
if not (
|
||||
path.exists(f"{self.bin_dir}/Table")
|
||||
and path.exists(f"{self.bin_dir}/Message")
|
||||
@ -37,9 +37,9 @@ class WaccaReader(BaseReader):
|
||||
self.logger.error("Could not find Table or Message folder, nothing to read")
|
||||
return
|
||||
|
||||
self.read_music(f"{self.bin_dir}/Table", "MusicParameterTable")
|
||||
await self.read_music(f"{self.bin_dir}/Table", "MusicParameterTable")
|
||||
|
||||
def read_music(self, base_dir: str, table: str) -> None:
|
||||
async def read_music(self, base_dir: str, table: str) -> None:
|
||||
if not self.check_valid_pair(base_dir, table):
|
||||
self.logger.warning(
|
||||
f"Cannot find {table} uasset/uexp pair at {base_dir}, music will not be read"
|
||||
@ -67,7 +67,7 @@ class WaccaReader(BaseReader):
|
||||
designer = wacca_data[str(key)]["NotesDesignerNormal"]
|
||||
|
||||
if diff > 0:
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
1,
|
||||
@ -84,7 +84,7 @@ class WaccaReader(BaseReader):
|
||||
designer = wacca_data[str(key)]["NotesDesignerHard"]
|
||||
|
||||
if diff > 0:
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
2,
|
||||
@ -101,7 +101,7 @@ class WaccaReader(BaseReader):
|
||||
designer = wacca_data[str(key)]["NotesDesignerExpert"]
|
||||
|
||||
if diff > 0:
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
3,
|
||||
@ -118,7 +118,7 @@ class WaccaReader(BaseReader):
|
||||
designer = wacca_data[str(key)]["NotesDesignerInferno"]
|
||||
|
||||
if diff > 0:
|
||||
self.data.static.put_music(
|
||||
await self.data.static.put_music(
|
||||
self.version,
|
||||
song_id,
|
||||
4,
|
||||
|
@ -56,7 +56,7 @@ class WaccaReverse(WaccaLilyR):
|
||||
req = UserStatusGetDetailRequest(data)
|
||||
resp = UserStatusGetDetailResponseV4()
|
||||
|
||||
profile = self.data.profile.get_profile(req.userId)
|
||||
profile = await self.data.profile.get_profile(req.userId)
|
||||
if profile is None:
|
||||
self.logger.warning(f"Unknown profile {req.userId}")
|
||||
return resp.make()
|
||||
@ -64,15 +64,15 @@ class WaccaReverse(WaccaLilyR):
|
||||
self.logger.info(f"Get detail for profile {req.userId}")
|
||||
user_id = profile["user"]
|
||||
|
||||
profile_scores = self.data.score.get_best_scores(user_id)
|
||||
profile_items = self.data.item.get_items(user_id)
|
||||
profile_song_unlocks = self.data.item.get_song_unlocks(user_id)
|
||||
profile_options = self.data.profile.get_options(user_id)
|
||||
profile_favorites = self.data.profile.get_favorite_songs(user_id)
|
||||
profile_gates = self.data.profile.get_gates(user_id)
|
||||
profile_bingo = self.data.profile.get_bingo(user_id)
|
||||
profile_trophies = self.data.item.get_trophies(user_id)
|
||||
profile_tickets = self.data.item.get_tickets(user_id)
|
||||
profile_scores = await self.data.score.get_best_scores(user_id)
|
||||
profile_items = await self.data.item.get_items(user_id)
|
||||
profile_song_unlocks = await self.data.item.get_song_unlocks(user_id)
|
||||
profile_options = await self.data.profile.get_options(user_id)
|
||||
profile_favorites = await self.data.profile.get_favorite_songs(user_id)
|
||||
profile_gates = await self.data.profile.get_gates(user_id)
|
||||
profile_bingo = await self.data.profile.get_bingo(user_id)
|
||||
profile_trophies = await self.data.item.get_trophies(user_id)
|
||||
profile_tickets = await self.data.item.get_tickets(user_id)
|
||||
|
||||
if profile["gate_tutorial_flags"] is not None:
|
||||
for x in profile["gate_tutorial_flags"]:
|
||||
@ -309,17 +309,17 @@ class WaccaReverse(WaccaLilyR):
|
||||
req = UserStatusCreateRequest(data)
|
||||
resp = await super().handle_user_status_create_request(data)
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 310001
|
||||
) # Added reverse
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["navigator"], 310002
|
||||
) # Added reverse
|
||||
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["touch_effect"], 312000
|
||||
) # Added reverse
|
||||
self.data.item.put_item(
|
||||
await self.data.item.put_item(
|
||||
req.aimeId, WaccaConstants.ITEM_TYPES["touch_effect"], 312001
|
||||
) # Added reverse
|
||||
|
||||
|
@ -75,16 +75,16 @@ trophy = Table(
|
||||
|
||||
|
||||
class WaccaItemData(BaseData):
|
||||
def get_song_unlocks(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_song_unlocks(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = song_unlock.select(song_unlock.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
|
||||
return result.fetchall()
|
||||
|
||||
def unlock_song(self, user_id: int, song_id: int, difficulty: int) -> Optional[int]:
|
||||
async def unlock_song(self, user_id: int, song_id: int, difficulty: int) -> Optional[int]:
|
||||
sql = insert(song_unlock).values(
|
||||
user=user_id, song_id=song_id, highest_difficulty=difficulty
|
||||
)
|
||||
@ -99,7 +99,7 @@ class WaccaItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to unlock song! user: {user_id}, song_id: {song_id}, difficulty: {difficulty}"
|
||||
@ -108,7 +108,7 @@ class WaccaItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_item(self, user_id: int, item_type: int, item_id: int) -> Optional[int]:
|
||||
async def put_item(self, user_id: int, item_type: int, item_id: int) -> Optional[int]:
|
||||
sql = insert(item).values(
|
||||
user=user_id,
|
||||
item_id=item_id,
|
||||
@ -117,7 +117,7 @@ class WaccaItemData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(use_count=item.c.use_count + 1)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert item! user: {user_id}, item_id: {item_id}, item_type: {item_type}"
|
||||
@ -126,7 +126,7 @@ class WaccaItemData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_items(
|
||||
async def get_items(
|
||||
self, user_id: int, item_type: int = None, item_id: int = None
|
||||
) -> Optional[List[Row]]:
|
||||
"""
|
||||
@ -140,23 +140,23 @@ class WaccaItemData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_tickets(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_tickets(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(ticket).where(ticket.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def add_ticket(self, user_id: int, ticket_id: int) -> None:
|
||||
async def add_ticket(self, user_id: int, ticket_id: int) -> None:
|
||||
sql = insert(ticket).values(user=user_id, ticket_id=ticket_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"add_ticket: Failed to insert wacca ticket! user_id: {user_id} ticket_id {ticket_id}"
|
||||
@ -164,15 +164,15 @@ class WaccaItemData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def spend_ticket(self, id: int) -> None:
|
||||
async def spend_ticket(self, id: int) -> None:
|
||||
sql = delete(ticket).where(ticket.c.id == id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to delete ticket id {id}")
|
||||
return None
|
||||
|
||||
def get_trophies(self, user_id: int, season: int = None) -> Optional[List[Row]]:
|
||||
async def get_trophies(self, user_id: int, season: int = None) -> Optional[List[Row]]:
|
||||
if season is None:
|
||||
sql = select(trophy).where(trophy.c.user == user_id)
|
||||
else:
|
||||
@ -180,12 +180,12 @@ class WaccaItemData(BaseData):
|
||||
and_(trophy.c.user == user_id, trophy.c.season == season)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def update_trophy(
|
||||
async def update_trophy(
|
||||
self, user_id: int, trophy_id: int, season: int, progress: int, badge_type: int
|
||||
) -> Optional[int]:
|
||||
sql = insert(trophy).values(
|
||||
@ -198,7 +198,7 @@ class WaccaItemData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(progress=progress)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"update_trophy: Failed to insert wacca trophy! user_id: {user_id} trophy_id: {trophy_id} progress {progress}"
|
||||
|
@ -139,7 +139,7 @@ gate = Table(
|
||||
|
||||
|
||||
class WaccaProfileData(BaseData):
|
||||
def create_profile(
|
||||
async def create_profile(
|
||||
self, aime_id: int, username: str, version: int
|
||||
) -> Optional[int]:
|
||||
"""
|
||||
@ -149,7 +149,7 @@ class WaccaProfileData(BaseData):
|
||||
|
||||
conflict = sql.on_duplicate_key_update(username=sql.inserted.username)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} Failed to insert wacca profile! aime id: {aime_id} username: {username}"
|
||||
@ -157,7 +157,7 @@ class WaccaProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def update_profile_playtype(
|
||||
async def update_profile_playtype(
|
||||
self, profile_id: int, play_type: int, game_version: str
|
||||
) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
@ -179,14 +179,14 @@ class WaccaProfileData(BaseData):
|
||||
last_game_ver=game_version,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"update_profile: failed to update profile! profile: {profile_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def update_profile_lastplayed(
|
||||
async def update_profile_lastplayed(
|
||||
self,
|
||||
profile_id: int,
|
||||
last_song_id: int,
|
||||
@ -202,21 +202,21 @@ class WaccaProfileData(BaseData):
|
||||
last_folder_id=last_folder_id,
|
||||
last_song_order=last_song_order,
|
||||
)
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"update_profile_lastplayed: failed to update profile! profile: {profile_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def update_profile_dan(
|
||||
async def update_profile_dan(
|
||||
self, profile_id: int, dan_level: int, dan_type: int
|
||||
) -> Optional[int]:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
dan_level=dan_level, dan_type=dan_type
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"update_profile_dan: Failed to update! profile {profile_id}"
|
||||
@ -224,7 +224,7 @@ class WaccaProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_profile(self, profile_id: int = 0, aime_id: int = None) -> Optional[Row]:
|
||||
async def get_profile(self, profile_id: int = 0, aime_id: int = None) -> Optional[Row]:
|
||||
"""
|
||||
Given a game version and either a profile or aime id, return the profile
|
||||
"""
|
||||
@ -238,12 +238,12 @@ class WaccaProfileData(BaseData):
|
||||
)
|
||||
return None
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_options(self, user_id: int, option_id: int = None) -> Optional[List[Row]]:
|
||||
async def get_options(self, user_id: int, option_id: int = None) -> Optional[List[Row]]:
|
||||
"""
|
||||
Get a specific user option for a profile, or all of them if none specified
|
||||
"""
|
||||
@ -254,7 +254,7 @@ class WaccaProfileData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
if option_id is not None:
|
||||
@ -262,12 +262,12 @@ class WaccaProfileData(BaseData):
|
||||
else:
|
||||
return result.fetchall()
|
||||
|
||||
def update_option(self, user_id: int, option_id: int, value: int) -> Optional[int]:
|
||||
async def update_option(self, user_id: int, option_id: int, value: int) -> Optional[int]:
|
||||
sql = insert(option).values(user=user_id, opt_id=option_id, value=value)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(value=value)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert option! profile: {user_id}, option: {option_id}, value: {value}"
|
||||
@ -276,10 +276,10 @@ class WaccaProfileData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def add_favorite_song(self, user_id: int, song_id: int) -> Optional[int]:
|
||||
async def add_favorite_song(self, user_id: int, song_id: int) -> Optional[int]:
|
||||
sql = favorite.insert().values(user=user_id, song_id=song_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert favorite! profile: {user_id}, song_id: {song_id}"
|
||||
@ -287,35 +287,35 @@ class WaccaProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def remove_favorite_song(self, user_id: int, song_id: int) -> None:
|
||||
async def remove_favorite_song(self, user_id: int, song_id: int) -> None:
|
||||
sql = favorite.delete(
|
||||
and_(favorite.c.user == user_id, favorite.c.song_id == song_id)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to remove favorite! profile: {user_id}, song_id: {song_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def get_favorite_songs(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_favorite_songs(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = favorite.select(favorite.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_gates(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_gates(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = select(gate).where(gate.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def update_gate(
|
||||
async def update_gate(
|
||||
self,
|
||||
user_id: int,
|
||||
gate_id: int,
|
||||
@ -343,7 +343,7 @@ class WaccaProfileData(BaseData):
|
||||
total_points=sql.inserted.total_points,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to update gate! user: {user_id}, gate_id: {gate_id}"
|
||||
@ -351,18 +351,18 @@ class WaccaProfileData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_friends(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_friends(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = friend.select(friend.c.profile_sender == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def profile_to_aime_user(self, profile_id: int) -> Optional[int]:
|
||||
async def profile_to_aime_user(self, profile_id: int) -> Optional[int]:
|
||||
sql = select(profile.c.user).where(profile.c.id == profile_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.info(
|
||||
f"profile_to_aime_user: No user found for profile {profile_id}"
|
||||
@ -378,7 +378,7 @@ class WaccaProfileData(BaseData):
|
||||
|
||||
return this_profile["user"]
|
||||
|
||||
def session_login(
|
||||
async def session_login(
|
||||
self, profile_id: int, is_new_day: bool, is_consec_day: bool
|
||||
) -> None:
|
||||
# TODO: Reset consec days counter
|
||||
@ -395,127 +395,127 @@ class WaccaProfileData(BaseData):
|
||||
last_login_date=func.now(),
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"session_login: failed to update profile! profile: {profile_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def session_logout(self, profile_id: int) -> None:
|
||||
async def session_logout(self, profile_id: int) -> None:
|
||||
sql = profile.update(profile.c.id == id).values(login_count_consec=0)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to update profile! profile: {profile_id}"
|
||||
)
|
||||
return None
|
||||
|
||||
def add_xp(self, profile_id: int, xp: int) -> None:
|
||||
async def add_xp(self, profile_id: int, xp: int) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(xp=profile.c.xp + xp)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"add_xp: Failed to update profile! profile_id {profile_id} xp {xp}"
|
||||
)
|
||||
return None
|
||||
|
||||
def add_wp(self, profile_id: int, wp: int) -> None:
|
||||
async def add_wp(self, profile_id: int, wp: int) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
wp=profile.c.wp + wp,
|
||||
wp_total=profile.c.wp_total + wp,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"add_wp: Failed to update profile! profile_id {profile_id} wp {wp}"
|
||||
)
|
||||
return None
|
||||
|
||||
def spend_wp(self, profile_id: int, wp: int) -> None:
|
||||
async def spend_wp(self, profile_id: int, wp: int) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
wp=profile.c.wp - wp,
|
||||
wp_spent=profile.c.wp_spent + wp,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"spend_wp: Failed to update profile! profile_id {profile_id} wp {wp}"
|
||||
)
|
||||
return None
|
||||
|
||||
def activate_vip(self, profile_id: int, expire_time) -> None:
|
||||
async def activate_vip(self, profile_id: int, expire_time) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
vip_expire_time=expire_time
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"activate_vip: Failed to update profile! profile_id {profile_id} expire_time {expire_time}"
|
||||
)
|
||||
return None
|
||||
|
||||
def update_user_rating(self, profile_id: int, new_rating: int) -> None:
|
||||
async def update_user_rating(self, profile_id: int, new_rating: int) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(rating=new_rating)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"update_user_rating: Failed to update profile! profile_id {profile_id} new_rating {new_rating}"
|
||||
)
|
||||
return None
|
||||
|
||||
def update_bingo(self, aime_id: int, page: int, progress: int) -> Optional[int]:
|
||||
async def update_bingo(self, aime_id: int, page: int, progress: int) -> Optional[int]:
|
||||
sql = insert(bingo).values(
|
||||
user=aime_id, page_number=page, page_progress=progress
|
||||
)
|
||||
|
||||
conflict = sql.on_duplicate_key_update(page_number=page, page_progress=progress)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(f"put_bingo: failed to update! aime_id: {aime_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_bingo(self, aime_id: int) -> Optional[List[Row]]:
|
||||
async def get_bingo(self, aime_id: int) -> Optional[List[Row]]:
|
||||
sql = select(bingo).where(bingo.c.user == aime_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_bingo_page(self, aime_id: int, page: Dict) -> Optional[List[Row]]:
|
||||
async def get_bingo_page(self, aime_id: int, page: Dict) -> Optional[List[Row]]:
|
||||
sql = select(bingo).where(
|
||||
and_(bingo.c.user == aime_id, bingo.c.page_number == page)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def update_vip_time(self, profile_id: int, time_left) -> None:
|
||||
async def update_vip_time(self, profile_id: int, time_left) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
vip_expire_time=time_left
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(f"Failed to update VIP time for profile {profile_id}")
|
||||
|
||||
def update_tutorial_flags(self, profile_id: int, flags: Dict) -> None:
|
||||
async def update_tutorial_flags(self, profile_id: int, flags: Dict) -> None:
|
||||
sql = profile.update(profile.c.id == profile_id).values(
|
||||
gate_tutorial_flags=flags
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"Failed to update tutorial flags for profile {profile_id}"
|
||||
|
@ -95,7 +95,7 @@ stageup = Table(
|
||||
|
||||
|
||||
class WaccaScoreData(BaseData):
|
||||
def put_best_score(
|
||||
async def put_best_score(
|
||||
self,
|
||||
user_id: int,
|
||||
song_id: int,
|
||||
@ -164,7 +164,7 @@ class WaccaScoreData(BaseData):
|
||||
lowest_miss_ct=lowest_miss_ct,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__}: failed to insert best score! profile: {user_id}, song: {song_id}, chart: {chart_id}"
|
||||
@ -173,7 +173,7 @@ class WaccaScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def put_playlog(
|
||||
async def put_playlog(
|
||||
self,
|
||||
user_id: int,
|
||||
song_id: int,
|
||||
@ -210,7 +210,7 @@ class WaccaScoreData(BaseData):
|
||||
season=season,
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"{__name__} failed to insert playlog! profile: {user_id}, song: {song_id}, chart: {chart_id}"
|
||||
@ -219,7 +219,7 @@ class WaccaScoreData(BaseData):
|
||||
|
||||
return result.lastrowid
|
||||
|
||||
def get_best_score(
|
||||
async def get_best_score(
|
||||
self, user_id: int, song_id: int, chart_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = best_score.select(
|
||||
@ -230,20 +230,20 @@ class WaccaScoreData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
||||
def get_best_scores(self, user_id: int) -> Optional[List[Row]]:
|
||||
async def get_best_scores(self, user_id: int) -> Optional[List[Row]]:
|
||||
sql = best_score.select(best_score.c.user == user_id)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def update_song_rating(
|
||||
async def update_song_rating(
|
||||
self, user_id: int, song_id: int, chart_id: int, new_rating: int
|
||||
) -> None:
|
||||
sql = best_score.update(
|
||||
@ -254,14 +254,14 @@ class WaccaScoreData(BaseData):
|
||||
)
|
||||
).values(rating=new_rating)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
self.logger.error(
|
||||
f"update_song_rating: failed to update rating! user_id: {user_id} song_id: {song_id} chart_id {chart_id} new_rating {new_rating}"
|
||||
)
|
||||
return None
|
||||
|
||||
def put_stageup(
|
||||
async def put_stageup(
|
||||
self,
|
||||
user_id: int,
|
||||
version: int,
|
||||
@ -292,7 +292,7 @@ class WaccaScoreData(BaseData):
|
||||
play_ct=stageup.c.play_ct + 1,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(
|
||||
f"put_stageup: failed to update! user_id: {user_id} version: {version} stage_id: {stage_id}"
|
||||
@ -300,17 +300,17 @@ class WaccaScoreData(BaseData):
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_stageup(self, user_id: int, version: int) -> Optional[List[Row]]:
|
||||
async def get_stageup(self, user_id: int, version: int) -> Optional[List[Row]]:
|
||||
sql = select(stageup).where(
|
||||
and_(stageup.c.user == user_id, stageup.c.version == version)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchall()
|
||||
|
||||
def get_stageup_stage(
|
||||
async def get_stageup_stage(
|
||||
self, user_id: int, version: int, stage_id: int
|
||||
) -> Optional[Row]:
|
||||
sql = select(stageup).where(
|
||||
@ -321,7 +321,7 @@ class WaccaScoreData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
@ -28,7 +28,7 @@ music = Table(
|
||||
|
||||
|
||||
class WaccaStaticData(BaseData):
|
||||
def put_music(
|
||||
async def put_music(
|
||||
self,
|
||||
version: int,
|
||||
song_id: int,
|
||||
@ -61,13 +61,13 @@ class WaccaStaticData(BaseData):
|
||||
jacketFile=jacket,
|
||||
)
|
||||
|
||||
result = self.execute(conflict)
|
||||
result = await self.execute(conflict)
|
||||
if result is None:
|
||||
self.logger.warning(f"Failed to insert music {song_id} chart {chart_id}")
|
||||
return None
|
||||
return result.lastrowid
|
||||
|
||||
def get_music_chart(
|
||||
async def get_music_chart(
|
||||
self, version: int, song_id: int, chart_id: int
|
||||
) -> Optional[List[Row]]:
|
||||
sql = select(music).where(
|
||||
@ -78,7 +78,7 @@ class WaccaStaticData(BaseData):
|
||||
)
|
||||
)
|
||||
|
||||
result = self.execute(sql)
|
||||
result = await self.execute(sql)
|
||||
if result is None:
|
||||
return None
|
||||
return result.fetchone()
|
||||
|
Loading…
Reference in New Issue
Block a user