Merge branch 'develop' into finale

titles/chuni/__init__.py

@@ -7,4 +7,4 @@ index = ChuniServlet
 database = ChuniData
 reader = ChuniReader
 game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW]
-current_schema_version = 3
+current_schema_version = 4

titles/chuni/base.py

@@ -44,13 +44,15 @@ class ChuniBase:
             # 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_id, self.version, preset["id"]
+                user_id, self.version, preset["presetId"]
             )
             if user_login_bonus is None:
-                self.data.item.put_login_bonus(user_id, self.version, preset["id"])
+                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_id, self.version, preset["id"]
+                    user_id, self.version, preset["presetId"]
                 )
 
             # skip the login bonus entirely if its already finished
@@ -66,13 +68,13 @@ class ChuniBase:
                 last_update_date = datetime.now()
 
                 all_login_boni = self.data.static.get_login_bonus(
-                    self.version, preset["id"]
+                    self.version, preset["presetId"]
                 )
 
                 # skip the current bonus preset if no boni were found
                 if all_login_boni is None or len(all_login_boni) < 1:
                     self.logger.warn(
-                        f"No bonus entries found for bonus preset {preset['id']}"
+                        f"No bonus entries found for bonus preset {preset['presetId']}"
                     )
                     continue
 
@@ -83,14 +85,14 @@ class ChuniBase:
                 if bonus_count > max_needed_days:
                     # assume that all login preset ids under 3000 needs to be
                     # looped, like 30 and 40 are looped, 40 does not work?
-                    if preset["id"] < 3000:
+                    if preset["presetId"] < 3000:
                         bonus_count = 1
                     else:
                         is_finished = True
 
                 # grab the item for the corresponding day
                 login_item = self.data.static.get_login_bonus_by_required_days(
-                    self.version, preset["id"], bonus_count
+                    self.version, preset["presetId"], bonus_count
                 )
                 if login_item is not None:
                     # now add the present to the database so the
@@ -108,7 +110,7 @@ class ChuniBase:
                 self.data.item.put_login_bonus(
                     user_id,
                     self.version,
-                    preset["id"],
+                    preset["presetId"],
                     bonusCount=bonus_count,
                     lastUpdateDate=last_update_date,
                     isWatched=False,
@@ -156,12 +158,18 @@ class ChuniBase:
 
         event_list = []
         for evt_row in game_events:
-            tmp = {}
-            tmp["id"] = evt_row["eventId"]
-            tmp["type"] = evt_row["type"]
-            tmp["startDate"] = "2017-12-05 07:00:00.0"
-            tmp["endDate"] = "2099-12-31 00:00:00.0"
-            event_list.append(tmp)
+            event_list.append(
+                {
+                    "id": evt_row["eventId"],
+                    "type": evt_row["type"],
+                    # actually use the startDate from the import so it
+                    # properly shows all the events when new ones are imported
+                    "startDate": datetime.strftime(
+                        evt_row["startDate"], "%Y-%m-%d %H:%M:%S"
+                    ),
+                    "endDate": "2099-12-31 00:00:00",
+                }
+            )
 
         return {
             "type": data["type"],
@@ -228,29 +236,36 @@ class ChuniBase:
     def handle_get_user_character_api_request(self, data: Dict) -> Dict:
         characters = self.data.item.get_characters(data["userId"])
         if characters is None:
-            return {}
-        next_idx = -1
+            return {
+                "userId": data["userId"],
+                "length": 0,
+                "nextIndex": -1,
+                "userCharacterList": [],
+            }
 
-        characterList = []
-        for x in range(int(data["nextIndex"]), len(characters)):
+        character_list = []
+        next_idx = int(data["nextIndex"])
+        max_ct = int(data["maxCount"])
+
+        for x in range(next_idx, len(characters)):
             tmp = characters[x]._asdict()
             tmp.pop("user")
             tmp.pop("id")
-            characterList.append(tmp)
+            character_list.append(tmp)
 
-            if len(characterList) >= int(data["maxCount"]):
+            if len(character_list) >= max_ct:
                 break
 
-        if len(characterList) >= int(data["maxCount"]) and len(characters) > int(
-            data["maxCount"]
-        ) + int(data["nextIndex"]):
-            next_idx = int(data["maxCount"]) + int(data["nextIndex"]) + 1
+        if len(characters) >= next_idx + max_ct:
+            next_idx += max_ct
+        else:
+            next_idx = -1
 
         return {
             "userId": data["userId"],
-            "length": len(characterList),
+            "length": len(character_list),
             "nextIndex": next_idx,
-            "userCharacterList": characterList,
+            "userCharacterList": character_list,
         }
 
     def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
@@ -292,8 +307,8 @@ class ChuniBase:
             if len(user_course_list) >= max_ct:
                 break
 
-        if len(user_course_list) >= max_ct:
-            next_idx = next_idx + max_ct
+        if len(user_course_list) >= next_idx + max_ct:
+            next_idx += max_ct
         else:
             next_idx = -1
 
@@ -347,12 +362,23 @@ class ChuniBase:
         }
 
     def handle_get_user_favorite_item_api_request(self, data: Dict) -> Dict:
+        user_fav_item_list = []
+
+        # still needs to be implemented on WebUI
+        # 1: Music, 3: Character
+        fav_list = self.data.item.get_all_favorites(
+            data["userId"], self.version, fav_kind=int(data["kind"])
+        )
+        if fav_list is not None:
+            for fav in fav_list:
+                user_fav_item_list.append({"id": fav["favId"]})
+
         return {
             "userId": data["userId"],
-            "length": 0,
+            "length": len(user_fav_item_list),
             "kind": data["kind"],
             "nextIndex": -1,
-            "userFavoriteItemList": [],
+            "userFavoriteItemList": user_fav_item_list,
         }
 
     def handle_get_user_favorite_music_api_request(self, data: Dict) -> Dict:
@@ -387,13 +413,13 @@ class ChuniBase:
         xout = kind * 10000000000 + next_idx + len(items)
 
         if len(items) < int(data["maxCount"]):
-            nextIndex = 0
+            next_idx = 0
         else:
-            nextIndex = xout
+            next_idx = xout
 
         return {
             "userId": data["userId"],
-            "nextIndex": nextIndex,
+            "nextIndex": next_idx,
             "itemKind": kind,
             "length": len(items),
             "userItemList": items,
@@ -452,6 +478,7 @@ class ChuniBase:
                 "nextIndex": -1,
                 "userMusicList": [],  # 240
             }
+
         song_list = []
         next_idx = int(data["nextIndex"])
         max_ct = int(data["maxCount"])
@@ -474,10 +501,10 @@ class ChuniBase:
             if len(song_list) >= max_ct:
                 break
 
-        if len(song_list) >= max_ct:
+        if len(song_list) >= next_idx + max_ct:
             next_idx += max_ct
         else:
-            next_idx = 0
+            next_idx = -1
 
         return {
             "userId": data["userId"],
@@ -623,12 +650,15 @@ class ChuniBase:
             self.data.profile.put_profile_data(
                 user_id, self.version, upsert["userData"][0]
             )
+
         if "userDataEx" in upsert:
             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])
+
         if "userGameOptionEx" in upsert:
             self.data.profile.put_profile_option_ex(
                 user_id, upsert["userGameOptionEx"][0]
@@ -672,6 +702,10 @@ class ChuniBase:
 
         if "userPlaylogList" in upsert:
             for playlog in upsert["userPlaylogList"]:
+                # convert the player names to utf-8
+                playlog["playedUserName1"] = self.read_wtf8(playlog["playedUserName1"])
+                playlog["playedUserName2"] = self.read_wtf8(playlog["playedUserName2"])
+                playlog["playedUserName3"] = self.read_wtf8(playlog["playedUserName3"])
                 self.data.score.put_playlog(user_id, playlog)
 
         if "userTeamPoint" in upsert:

titles/chuni/const.py

@@ -17,21 +17,23 @@ class ChuniConstants:
     VER_CHUNITHM_PARADISE = 10
     VER_CHUNITHM_NEW = 11
     VER_CHUNITHM_NEW_PLUS = 12
+    VER_CHUNITHM_SUN = 13
 
     VERSION_NAMES = [
-        "Chunithm",
-        "Chunithm+",
-        "Chunithm Air",
-        "Chunithm Air+",
-        "Chunithm Star",
-        "Chunithm Star+",
-        "Chunithm Amazon",
-        "Chunithm Amazon+",
-        "Chunithm Crystal",
-        "Chunithm Crystal+",
-        "Chunithm Paradise",
-        "Chunithm New!!",
-        "Chunithm New!!+",
+        "CHUNITHM",
+        "CHUNITHM PLUS",
+        "CHUNITHM AIR",
+        "CHUNITHM AIR PLUS",
+        "CHUNITHM STAR",
+        "CHUNITHM STAR  PLUS",
+        "CHUNITHM AMAZON",
+        "CHUNITHM AMAZON PLUS",
+        "CHUNITHM CRYSTAL",
+        "CHUNITHM CRYSTAL PLUS",
+        "CHUNITHM PARADISE",
+        "CHUNITHM NEW!!",
+        "CHUNITHM NEW PLUS!!",
+        "CHUNITHM SUN"
     ]
 
     @classmethod

titles/chuni/index.py

@@ -29,6 +29,7 @@ from titles.chuni.crystalplus import ChuniCrystalPlus
 from titles.chuni.paradise import ChuniParadise
 from titles.chuni.new import ChuniNew
 from titles.chuni.newplus import ChuniNewPlus
+from titles.chuni.sun import ChuniSun
 
 
 class ChuniServlet:
@@ -55,6 +56,7 @@ class ChuniServlet:
             ChuniParadise,
             ChuniNew,
             ChuniNewPlus,
+            ChuniSun,
         ]
 
         self.logger = logging.getLogger("chuni")
@@ -96,15 +98,18 @@ class ChuniServlet:
             ]
             for method in method_list:
                 method_fixed = inflection.camelize(method)[6:-7]
+                # number of iterations was changed to 70 in SUN
+                iter_count = 70 if version >= ChuniConstants.VER_CHUNITHM_SUN else 44
                 hash = PBKDF2(
                     method_fixed,
                     bytes.fromhex(keys[2]),
                     128,
-                    count=44,
+                    count=iter_count,
                     hmac_hash_module=SHA1,
                 )
 
-                self.hash_table[version][hash.hex()] = method_fixed
+                hashed_name = hash.hex()[:32] # truncate unused bytes like the game does
+                self.hash_table[version][hashed_name] = method_fixed
 
                 self.logger.debug(
                     f"Hashed v{version} method {method_fixed} with {bytes.fromhex(keys[2])} to get {hash.hex()}"
@@ -145,30 +150,32 @@ class ChuniServlet:
 
         if version < 105:  # 1.0
             internal_ver = ChuniConstants.VER_CHUNITHM
-        elif version >= 105 and version < 110:  # Plus
+        elif version >= 105 and version < 110:  # PLUS
             internal_ver = ChuniConstants.VER_CHUNITHM_PLUS
-        elif version >= 110 and version < 115:  # Air
+        elif version >= 110 and version < 115:  # AIR
             internal_ver = ChuniConstants.VER_CHUNITHM_AIR
-        elif version >= 115 and version < 120:  # Air Plus
+        elif version >= 115 and version < 120:  # AIR PLUS
             internal_ver = ChuniConstants.VER_CHUNITHM_AIR_PLUS
-        elif version >= 120 and version < 125:  # Star
+        elif version >= 120 and version < 125:  # STAR
             internal_ver = ChuniConstants.VER_CHUNITHM_STAR
-        elif version >= 125 and version < 130:  # Star Plus
+        elif version >= 125 and version < 130:  # STAR PLUS
             internal_ver = ChuniConstants.VER_CHUNITHM_STAR_PLUS
-        elif version >= 130 and version < 135:  # Amazon
+        elif version >= 130 and version < 135:  # AMAZON
             internal_ver = ChuniConstants.VER_CHUNITHM_AMAZON
-        elif version >= 135 and version < 140:  # Amazon Plus
+        elif version >= 135 and version < 140:  # AMAZON PLUS
             internal_ver = ChuniConstants.VER_CHUNITHM_AMAZON_PLUS
-        elif version >= 140 and version < 145:  # Crystal
+        elif version >= 140 and version < 145:  # CRYSTAL
             internal_ver = ChuniConstants.VER_CHUNITHM_CRYSTAL
-        elif version >= 145 and version < 150:  # Crystal Plus
+        elif version >= 145 and version < 150:  # CRYSTAL PLUS
             internal_ver = ChuniConstants.VER_CHUNITHM_CRYSTAL_PLUS
-        elif version >= 150 and version < 200:  # Paradise
+        elif version >= 150 and version < 200:  # PARADISE
             internal_ver = ChuniConstants.VER_CHUNITHM_PARADISE
-        elif version >= 200 and version < 205:  # New
+        elif version >= 200 and version < 205:  # NEW!!
             internal_ver = ChuniConstants.VER_CHUNITHM_NEW
-        elif version >= 205 and version < 210:  # New Plus
+        elif version >= 205 and version < 210:  # NEW PLUS!!
             internal_ver = ChuniConstants.VER_CHUNITHM_NEW_PLUS
+        elif version >= 210:  # SUN
+            internal_ver = ChuniConstants.VER_CHUNITHM_SUN
 
         if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:
             # If we get a 32 character long hex string, it's a hash and we're

titles/chuni/new.py

@@ -23,41 +23,44 @@ class ChuniNew(ChuniBase):
         self.version = ChuniConstants.VER_CHUNITHM_NEW
 
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
+        # use UTC time and convert it to JST time by adding +9
+        # matching therefore starts one hour before and lasts for 8 hours
         match_start = datetime.strftime(
-            datetime.now() - timedelta(hours=10), self.date_time_format
+            datetime.utcnow() + timedelta(hours=8), self.date_time_format
         )
         match_end = datetime.strftime(
-            datetime.now() + timedelta(hours=10), self.date_time_format
+            datetime.utcnow() + timedelta(hours=16), self.date_time_format
         )
         reboot_start = datetime.strftime(
-            datetime.now() - timedelta(hours=11), self.date_time_format
+            datetime.utcnow() + timedelta(hours=6), self.date_time_format
         )
         reboot_end = datetime.strftime(
-            datetime.now() - timedelta(hours=10), self.date_time_format
+            datetime.utcnow() + timedelta(hours=7), self.date_time_format
         )
         return {
             "gameSetting": {
-                "isMaintenance": "false",
+                "isMaintenance": False,
                 "requestInterval": 10,
                 "rebootStartTime": reboot_start,
                 "rebootEndTime": reboot_end,
-                "isBackgroundDistribute": "false",
+                "isBackgroundDistribute": False,
                 "maxCountCharacter": 300,
                 "maxCountItem": 300,
                 "maxCountMusic": 300,
                 "matchStartTime": match_start,
                 "matchEndTime": match_end,
-                "matchTimeLimit": 99,
+                "matchTimeLimit": 60,
                 "matchErrorLimit": 9999,
                 "romVersion": self.game_cfg.version.version(self.version)["rom"],
                 "dataVersion": self.game_cfg.version.version(self.version)["data"],
                 "matchingUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
                 "matchingUriX": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
+                # might be really important for online battle to connect the cabs via UDP port 50201
                 "udpHolePunchUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
                 "reflectorUri": f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
             },
-            "isDumpUpload": "false",
-            "isAou": "false",
+            "isDumpUpload": False,
+            "isAou": False,
         }
 
     def handle_remove_token_api_request(self, data: Dict) -> Dict:
@@ -468,3 +471,162 @@ class ChuniNew(ChuniBase):
             self.data.item.put_user_print_state(user_id, id=order_id, hasCompleted=True)
 
         return {"returnCode": "1", "apiName": "CMUpsertUserPrintCancelApi"}
+
+    def handle_ping_request(self, data: Dict) -> Dict:
+        # matchmaking ping request
+        return {"returnCode": "1"}
+
+    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)
+
+        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)
+            if newest_matching is not None:
+                room_id = newest_matching["roomId"] + 1
+
+            # fix userName WTF8
+            new_member = data["matchingMemberInfo"]
+            new_member["userName"] = self.read_wtf8(new_member["userName"])
+
+            # 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(
+                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)
+        else:
+            # a room already exists, so just add the new member to it
+            matching_member_list = matching_room["matchingMemberInfoList"]
+            # fix userName WTF8
+            new_member = data["matchingMemberInfo"]
+            new_member["userName"] = self.read_wtf8(new_member["userName"])
+            matching_member_list.append(new_member)
+
+            # add the updated room to the database, make sure to set isFull correctly!
+            self.data.item.put_matching(
+                self.version,
+                matching_room["roomId"],
+                matching_member_list,
+                user_id=matching_room["user"],
+                is_full=True if len(matching_member_list) >= 4 else False,
+            )
+
+        matching_wait = {
+            "isFinish": False,
+            "restMSec": matching_room["restMSec"],  # in sec
+            "pollingInterval": 1,  # in sec
+            "matchingMemberInfoList": matching_room["matchingMemberInfoList"],
+        }
+
+        return {"roomId": 1, "matchingWaitState": matching_wait}
+
+    def handle_end_matching_api_request(self, data: Dict) -> Dict:
+        matching_room = 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?
+        role_list = [
+            {"role": 1} if m["userId"] == matching_room["user"] else {"role": 0}
+            for m in members
+        ]
+
+        self.data.item.put_matching(
+            self.version,
+            matching_room["roomId"],
+            members,
+            user_id=matching_room["user"],
+            rest_sec=0,  # make sure to always set 0
+            is_full=True,  # and full, so no one can join
+        )
+
+        return {
+            "matchingResult": 1,  # needs to be 1 for successful matching
+            "matchingMemberInfoList": members,
+            # no idea, maybe to differentiate between CPUs and real players?
+            "matchingMemberRoleList": role_list,
+            # TCP/UDP connection?
+            "reflectorUri": f"{self.core_cfg.title.hostname}",
+        }
+
+    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)
+        if matching_rooms is None:
+            return {"returnCode": "1"}
+
+        for room in matching_rooms:
+            old_members = room["matchingMemberInfoList"]
+            new_members = [m for m in old_members if m["userId"] != data["userId"]]
+
+            # if nothing changed go to the next room
+            if len(old_members) == len(new_members):
+                continue
+
+            # if the last user got removed, delete the matching room
+            if len(new_members) <= 0:
+                self.data.item.delete_matching(self.version, room["roomId"])
+            else:
+                # remove the user from the room
+                self.data.item.put_matching(
+                    self.version,
+                    room["roomId"],
+                    new_members,
+                    user_id=room["user"],
+                    rest_sec=room["restMSec"],
+                )
+
+        return {"returnCode": "1"}
+
+    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"])
+        members = matching_room["matchingMemberInfoList"]
+        rest_sec = matching_room["restMSec"]
+
+        # grab the current member
+        current_member = data["matchingMemberInfo"]
+
+        # only the host user can decrease the countdown
+        if matching_room["user"] == int(current_member["userId"]):
+            # cap the restMSec to 0
+            if rest_sec > 0:
+                rest_sec -= polling_interval
+            else:
+                rest_sec = 0
+
+        # update the members in order to recieve messages
+        for i, member in enumerate(members):
+            if member["userId"] == current_member["userId"]:
+                # replace the old user data with the current user data,
+                # also parse WTF-8 everytime
+                current_member["userName"] = self.read_wtf8(current_member["userName"])
+                members[i] = current_member
+
+        self.data.item.put_matching(
+            self.version,
+            data["roomId"],
+            members,
+            rest_sec=rest_sec,
+            user_id=matching_room["user"],
+        )
+
+        # only add the other members to the list
+        diff_members = [m for m in members if m["userId"] != current_member["userId"]]
+
+        matching_wait = {
+            # makes no difference? Always use False?
+            "isFinish": True if rest_sec == 0 else False,
+            "restMSec": rest_sec,
+            "pollingInterval": polling_interval,
+            # the current user needs to be the first one?
+            "matchingMemberInfoList": [current_member] + diff_members,
+        }
+
+        return {"matchingWaitState": matching_wait}

titles/chuni/newplus.py

@@ -36,6 +36,6 @@ class ChuniNewPlus(ChuniNew):
     def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
         user_data = super().handle_cm_get_user_preview_api_request(data)
 
-        # hardcode lastDataVersion for CardMaker 1.35
+        # hardcode lastDataVersion for CardMaker 1.35 A028
         user_data["lastDataVersion"] = "2.05.00"
         return user_data

titles/chuni/schema/item.py

@@ -1,5 +1,12 @@
 from typing import Dict, List, Optional
-from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
+from sqlalchemy import (
+    Table,
+    Column,
+    UniqueConstraint,
+    PrimaryKeyConstraint,
+    and_,
+    delete,
+)
 from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
 from sqlalchemy.engine.base import Connection
 from sqlalchemy.schema import ForeignKey
@@ -203,8 +210,141 @@ login_bonus = Table(
     mysql_charset="utf8mb4",
 )
 
+favorite = Table(
+    "chuni_item_favorite",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("version", Integer, nullable=False),
+    Column("favId", Integer, nullable=False),
+    Column("favKind", Integer, nullable=False, server_default="1"),
+    UniqueConstraint("version", "user", "favId", name="chuni_item_favorite_uk"),
+    mysql_charset="utf8mb4",
+)
+
+matching = Table(
+    "chuni_item_matching",
+    metadata,
+    Column("roomId", Integer, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("version", Integer, nullable=False),
+    Column("restMSec", Integer, nullable=False, server_default="60"),
+    Column("isFull", Boolean, nullable=False, server_default="0"),
+    PrimaryKeyConstraint("roomId", "version", name="chuni_item_matching_pk"),
+    Column("matchingMemberInfoList", JSON, nullable=False),
+    mysql_charset="utf8mb4",
+)
+
 
 class ChuniItemData(BaseData):
+    def get_oldest_free_matching(self, version: int) -> Optional[Row]:
+        sql = matching.select(
+            and_(
+                matching.c.version == version,
+                matching.c.isFull == False
+            )
+        ).order_by(matching.c.roomId.asc())
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    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)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_all_matchings(self, version: int) -> Optional[List[Row]]:
+        sql = matching.select(
+            and_(
+                matching.c.version == version
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    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)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def put_matching(
+        self,
+        version: int,
+        room_id: int,
+        matching_member_info_list: list,
+        user_id: int = None,
+        rest_sec: int = 60,
+        is_full: bool = False
+    ) -> Optional[int]:
+        sql = insert(matching).values(
+            roomId=room_id,
+            version=version,
+            restMSec=rest_sec,
+            user=user_id,
+            isFull=is_full,
+            matchingMemberInfoList=matching_member_info_list,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            restMSec=rest_sec, matchingMemberInfoList=matching_member_info_list
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    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)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def get_all_favorites(
+        self, user_id: int, version: int, fav_kind: int = 1
+    ) -> Optional[List[Row]]:
+        sql = favorite.select(
+            and_(
+                favorite.c.version == version,
+                favorite.c.user == user_id,
+                favorite.c.favKind == fav_kind,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
     def put_login_bonus(
         self, user_id: int, version: int, preset_id: int, **login_bonus_data
     ) -> Optional[int]:

titles/chuni/schema/profile.py

@@ -89,8 +89,6 @@ profile = Table(
         Integer,
         ForeignKey("chuni_profile_team.id", ondelete="SET NULL", onupdate="SET NULL"),
     ),
-    Column("avatarBack", Integer, server_default="0"),
-    Column("avatarFace", Integer, server_default="0"),
     Column("eliteRankPoint", Integer, server_default="0"),
     Column("stockedGridCount", Integer, server_default="0"),
     Column("netBattleLoseCount", Integer, server_default="0"),
@@ -98,10 +96,8 @@ profile = Table(
     Column("netBattle4thCount", Integer, server_default="0"),
     Column("overPowerRate", Integer, server_default="0"),
     Column("battleRewardStatus", Integer, server_default="0"),
-    Column("avatarPoint", Integer, server_default="0"),
     Column("netBattle1stCount", Integer, server_default="0"),
     Column("charaIllustId", Integer, server_default="0"),
-    Column("avatarItem", Integer, server_default="0"),
     Column("userNameEx", String(8), server_default=""),
     Column("netBattleWinCount", Integer, server_default="0"),
     Column("netBattleCorrection", Integer, server_default="0"),
@@ -112,7 +108,6 @@ profile = Table(
     Column("netBattle3rdCount", Integer, server_default="0"),
     Column("netBattleConsecutiveWinCount", Integer, server_default="0"),
     Column("overPowerLowerRank", Integer, server_default="0"),
-    Column("avatarWear", Integer, server_default="0"),
     Column("classEmblemBase", Integer, server_default="0"),
     Column("battleRankPoint", Integer, server_default="0"),
     Column("netBattle2ndCount", Integer, server_default="0"),
@@ -120,13 +115,19 @@ profile = Table(
     Column("skillId", Integer, server_default="0"),
     Column("lastCountryCode", String(5), server_default="JPN"),
     Column("isNetBattleHost", Boolean, server_default="0"),
-    Column("avatarFront", Integer, server_default="0"),
-    Column("avatarSkin", Integer, server_default="0"),
     Column("battleRewardCount", Integer, server_default="0"),
     Column("battleRewardIndex", Integer, server_default="0"),
     Column("netBattlePlayCount", Integer, server_default="0"),
     Column("exMapLoopCount", Integer, server_default="0"),
     Column("netBattleEndState", Integer, server_default="0"),
+    Column("rankUpChallengeResults", JSON),
+    Column("avatarBack", Integer, server_default="0"),
+    Column("avatarFace", Integer, server_default="0"),
+    Column("avatarPoint", Integer, server_default="0"),
+    Column("avatarItem", Integer, server_default="0"),
+    Column("avatarWear", Integer, server_default="0"),
+    Column("avatarFront", Integer, server_default="0"),
+    Column("avatarSkin", Integer, server_default="0"),
     Column("avatarHead", Integer, server_default="0"),
     UniqueConstraint("user", "version", name="chuni_profile_profile_uk"),
     mysql_charset="utf8mb4",
@@ -417,8 +418,8 @@ class ChuniProfileData(BaseData):
         sql = (
             select([profile, option])
             .join(option, profile.c.user == option.c.user)
-            .filter(and_(profile.c.user == aime_id, profile.c.version == version))
-        )
+            .filter(and_(profile.c.user == aime_id, profile.c.version <= version))
+        ).order_by(profile.c.version.desc())
 
         result = self.execute(sql)
         if result is None:
@@ -429,9 +430,9 @@ class ChuniProfileData(BaseData):
         sql = select(profile).where(
             and_(
                 profile.c.user == aime_id,
-                profile.c.version == version,
+                profile.c.version <= version,
             )
-        )
+        ).order_by(profile.c.version.desc())
 
         result = self.execute(sql)
         if result is None:
@@ -461,9 +462,9 @@ class ChuniProfileData(BaseData):
         sql = select(profile_ex).where(
             and_(
                 profile_ex.c.user == aime_id,
-                profile_ex.c.version == version,
+                profile_ex.c.version <= version,
             )
-        )
+        ).order_by(profile_ex.c.version.desc())
 
         result = self.execute(sql)
         if result is None:

titles/chuni/schema/score.py

@@ -134,7 +134,9 @@ playlog = Table(
     Column("charaIllustId", Integer),
     Column("romVersion", String(255)),
     Column("judgeHeaven", Integer),
-    mysql_charset="utf8mb4",
+    Column("regionId", Integer),
+    Column("machineType", Integer),
+    mysql_charset="utf8mb4"
 )
 
 

titles/chuni/schema/static.py

@@ -1,11 +1,19 @@
 from typing import Dict, List, Optional
-from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
+from sqlalchemy import (
+    ForeignKeyConstraint,
+    Table,
+    Column,
+    UniqueConstraint,
+    PrimaryKeyConstraint,
+    and_,
+)
 from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON, Float
 from sqlalchemy.engine.base import Connection
 from sqlalchemy.engine import Row
 from sqlalchemy.schema import ForeignKey
 from sqlalchemy.sql import func, select
 from sqlalchemy.dialects.mysql import insert
+from datetime import datetime
 
 from core.data.schema import BaseData, metadata
 
@@ -17,6 +25,7 @@ events = Table(
     Column("eventId", Integer),
     Column("type", Integer),
     Column("name", String(255)),
+    Column("startDate", TIMESTAMP, server_default=func.now()),
     Column("enabled", Boolean, server_default="1"),
     UniqueConstraint("version", "eventId", name="chuni_static_events_uk"),
     mysql_charset="utf8mb4",
@@ -125,11 +134,13 @@ gacha_cards = Table(
 login_bonus_preset = Table(
     "chuni_static_login_bonus_preset",
     metadata,
-    Column("id", Integer, primary_key=True, nullable=False),
+    Column("presetId", Integer, nullable=False),
     Column("version", Integer, nullable=False),
     Column("presetName", String(255), nullable=False),
     Column("isEnabled", Boolean, server_default="1"),
-    UniqueConstraint("version", "id", name="chuni_static_login_bonus_preset_uk"),
+    PrimaryKeyConstraint(
+        "presetId", "version", name="chuni_static_login_bonus_preset_pk"
+    ),
     mysql_charset="utf8mb4",
 )
 
@@ -138,15 +149,7 @@ login_bonus = Table(
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
     Column("version", Integer, nullable=False),
-    Column(
-        "presetId",
-        ForeignKey(
-            "chuni_static_login_bonus_preset.id",
-            ondelete="cascade",
-            onupdate="cascade",
-        ),
-        nullable=False,
-    ),
+    Column("presetId", Integer, nullable=False),
     Column("loginBonusId", Integer, nullable=False),
     Column("loginBonusName", String(255), nullable=False),
     Column("presentId", Integer, nullable=False),
@@ -157,6 +160,16 @@ login_bonus = Table(
     UniqueConstraint(
         "version", "presetId", "loginBonusId", name="chuni_static_login_bonus_uk"
     ),
+    ForeignKeyConstraint(
+        ["presetId", "version"],
+        [
+            "chuni_static_login_bonus_preset.presetId",
+            "chuni_static_login_bonus_preset.version",
+        ],
+        onupdate="CASCADE",
+        ondelete="CASCADE",
+        name="chuni_static_login_bonus_ibfk_1",
+    ),
     mysql_charset="utf8mb4",
 )
 
@@ -236,7 +249,7 @@ class ChuniStaticData(BaseData):
         self, version: int, preset_id: int, preset_name: str, is_enabled: bool
     ) -> Optional[int]:
         sql = insert(login_bonus_preset).values(
-            id=preset_id,
+            presetId=preset_id,
             version=version,
             presetName=preset_name,
             isEnabled=is_enabled,
@@ -416,6 +429,14 @@ class ChuniStaticData(BaseData):
             return None
         return result.fetchall()
 
+    def get_music(self, version: int) -> Optional[List[Row]]:
+        sql = music.select(music.c.version <= version)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
     def get_music_chart(
         self, version: int, song_id: int, chart_id: int
     ) -> Optional[List[Row]]:

titles/chuni/sun.py

@@ -0,0 +1,37 @@
+from typing import Dict, Any
+
+from core.config import CoreConfig
+from titles.chuni.newplus import ChuniNewPlus
+from titles.chuni.const import ChuniConstants
+from titles.chuni.config import ChuniConfig
+
+
+class ChuniSun(ChuniNewPlus):
+    def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
+        super().__init__(core_cfg, game_cfg)
+        self.version = ChuniConstants.VER_CHUNITHM_SUN
+
+    def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
+        ret = super().handle_get_game_setting_api_request(data)
+        ret["gameSetting"]["romVersion"] = self.game_cfg.version.version(self.version)["rom"]
+        ret["gameSetting"]["dataVersion"] = self.game_cfg.version.version(self.version)["data"]
+        ret["gameSetting"][
+            "matchingUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        ret["gameSetting"][
+            "matchingUriX"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        ret["gameSetting"][
+            "udpHolePunchUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        ret["gameSetting"][
+            "reflectorUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/210/ChuniServlet/"
+        return ret
+
+    def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
+        user_data = super().handle_cm_get_user_preview_api_request(data)
+
+        # hardcode lastDataVersion for CardMaker 1.35 A032
+        user_data["lastDataVersion"] = "2.10.00"
+        return user_data

titles/cm/base.py

@@ -23,19 +23,40 @@ class CardMakerBase:
         self.game = CardMakerConstants.GAME_CODE
         self.version = CardMakerConstants.VER_CARD_MAKER
 
+    @staticmethod
+    def _parse_int_ver(version: str) -> str:
+        return version.replace(".", "")[:3]
+
     def handle_get_game_connect_api_request(self, data: Dict) -> Dict:
         if self.core_cfg.server.is_develop:
             uri = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}"
         else:
             uri = f"http://{self.core_cfg.title.hostname}"
 
-        # CHUNITHM = 0, maimai = 1, ONGEKI = 2
+        # grab the dict with all games version numbers from user config
+        games_ver = self.game_cfg.version.version(self.version)
+
         return {
             "length": 3,
             "gameConnectList": [
-                {"modelKind": 0, "type": 1, "titleUri": f"{uri}/SDHD/200/"},
-                {"modelKind": 1, "type": 1, "titleUri": f"{uri}/SDEZ/120/"},
-                {"modelKind": 2, "type": 1, "titleUri": f"{uri}/SDDT/130/"},
+                # CHUNITHM
+                {
+                    "modelKind": 0,
+                    "type": 1,
+                    "titleUri": f"{uri}/SDHD/{self._parse_int_ver(games_ver['chuni'])}/",
+                },
+                # maimai DX
+                {
+                    "modelKind": 1,
+                    "type": 1,
+                    "titleUri": f"{uri}/SDEZ/{self._parse_int_ver(games_ver['maimai'])}/",
+                },
+                # ONGEKI
+                {
+                    "modelKind": 2,
+                    "type": 1,
+                    "titleUri": f"{uri}/SDDT/{self._parse_int_ver(games_ver['ongeki'])}/",
+                },
             ],
         }
 
@@ -47,12 +68,15 @@ class CardMakerBase:
             datetime.now() + timedelta(hours=4), self.date_time_format
         )
 
+        # grab the dict with all games version numbers from user config
+        games_ver = self.game_cfg.version.version(self.version)
+
         return {
             "gameSetting": {
                 "dataVersion": "1.30.00",
-                "ongekiCmVersion": "1.30.01",
-                "chuniCmVersion": "2.00.00",
-                "maimaiCmVersion": "1.20.00",
+                "ongekiCmVersion": games_ver["ongeki"],
+                "chuniCmVersion": games_ver["chuni"],
+                "maimaiCmVersion": games_ver["maimai"],
                 "requestInterval": 10,
                 "rebootStartTime": reboot_start,
                 "rebootEndTime": reboot_end,

titles/cm/cm135.py

@@ -1,8 +1,4 @@
-from datetime import date, datetime, timedelta
-from typing import Any, Dict, List
-import json
-import logging
-from enum import Enum
+from typing import Dict
 
 from core.config import CoreConfig
 from core.data.cache import cached
@@ -16,23 +12,7 @@ class CardMaker135(CardMakerBase):
         super().__init__(core_cfg, game_cfg)
         self.version = CardMakerConstants.VER_CARD_MAKER_135
 
-    def handle_get_game_connect_api_request(self, data: Dict) -> Dict:
-        ret = super().handle_get_game_connect_api_request(data)
-        if self.core_cfg.server.is_develop:
-            uri = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}"
-        else:
-            uri = f"http://{self.core_cfg.title.hostname}"
-
-        ret["gameConnectList"][0]["titleUri"] = f"{uri}/SDHD/205/"
-        ret["gameConnectList"][1]["titleUri"] = f"{uri}/SDEZ/125/"
-        ret["gameConnectList"][2]["titleUri"] = f"{uri}/SDDT/135/"
-
-        return ret
-
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
         ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.35.00"
-        ret["gameSetting"]["ongekiCmVersion"] = "1.35.03"
-        ret["gameSetting"]["chuniCmVersion"] = "2.05.00"
-        ret["gameSetting"]["maimaiCmVersion"] = "1.25.00"
         return ret

titles/cm/config.py

@@ -1,3 +1,4 @@
+from typing import Dict
 from core.config import CoreConfig
 
 
@@ -20,6 +21,21 @@ class CardMakerServerConfig:
         )
 
 
+class CardMakerVersionConfig:
+    def __init__(self, parent_config: "CardMakerConfig") -> None:
+        self.__config = parent_config
+
+    def version(self, version: int) -> Dict:
+        """
+        in the form of:
+        1: {"ongeki": 1.30.01, "chuni": 2.00.00, "maimai": 1.20.00}
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "cardmaker", "version", default={}
+        )[version]
+
+
 class CardMakerConfig(dict):
     def __init__(self) -> None:
         self.server = CardMakerServerConfig(self)
+        self.version = CardMakerVersionConfig(self)

titles/cm/const.py

@@ -6,7 +6,7 @@ class CardMakerConstants:
     VER_CARD_MAKER = 0
     VER_CARD_MAKER_135 = 1
 
-    VERSION_NAMES = ("Card Maker 1.34", "Card Maker 1.35")
+    VERSION_NAMES = ("Card Maker 1.30", "Card Maker 1.35")
 
     @classmethod
     def game_ver_to_string(cls, ver: int):

titles/cm/index.py

@@ -30,7 +30,7 @@ class CardMakerServlet:
 
         self.versions = [
             CardMakerBase(core_cfg, self.game_cfg),
-            CardMaker135(core_cfg, self.game_cfg),
+            CardMaker135(core_cfg, self.game_cfg)
         ]
 
         self.logger = logging.getLogger("cardmaker")
@@ -89,7 +89,7 @@ class CardMakerServlet:
 
         if version >= 130 and version < 135:  # Card Maker
             internal_ver = CardMakerConstants.VER_CARD_MAKER
-        elif version >= 135 and version < 136:  # Card Maker 1.35
+        elif version >= 135 and version < 140:  # Card Maker 1.35
             internal_ver = CardMakerConstants.VER_CARD_MAKER_135
 
         if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:

titles/cxb/index.py

@@ -103,7 +103,7 @@ class CxbServlet(resource.Resource):
             else:
                 self.logger.info(f"Ready on port {self.game_cfg.server.port}")
 
-    def render_POST(self, request: Request):
+    def render_POST(self, request: Request, version: int, endpoint: str):
         version = 0
         internal_ver = 0
         func_to_find = ""

titles/idz/userdb.py

@@ -83,7 +83,13 @@ class IDZUserDBProtocol(Protocol):
     def dataReceived(self, data: bytes) -> None:
         self.logger.debug(f"Receive data {data.hex()}")
         crypt = AES.new(self.static_key, AES.MODE_ECB)
-        data_dec = crypt.decrypt(data)
+        
+        try:
+            data_dec = crypt.decrypt(data)
+        
+        except Exception as e:
+            self.logger.error(f"Failed to decrypt UserDB request from {self.transport.getPeer().host} because {e} - {data.hex()}")
+        
         self.logger.debug(f"Decrypt data {data_dec.hex()}")
 
         magic = struct.unpack_from("<I", data_dec, 0)[0]

titles/mai2/__init__.py

@@ -16,4 +16,4 @@ game_codes = [
     Mai2Constants.GAME_CODE_GREEN,
     Mai2Constants.GAME_CODE,
 ]
-current_schema_version = 4
+current_schema_version = 5

titles/mai2/base.py

@@ -632,21 +632,38 @@ class Mai2Base:
         return {"userId": data["userId"], "length": 0, "userRegionList": []}
 
     def handle_get_user_music_api_request(self, data: Dict) -> Dict:
-        songs = self.data.score.get_best_scores(data["userId"])
+        user_id = data.get("userId", 0)        
+        next_index = data.get("nextIndex", 0)
+        max_ct = data.get("maxCount", 50)
+        upper_lim = next_index + max_ct
         music_detail_list = []
-        next_index = 0
 
-        if songs is not None:
-            for song in songs:
-                tmp = song._asdict()
-                tmp.pop("id")
-                tmp.pop("user")
-                music_detail_list.append(tmp)
+        if user_id <= 0:
+            self.logger.warn("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)
+        if songs is None:
+            self.logger.debug("handle_get_user_music_api_request: get_best_scores returned None!")
+            return {
+            "userId": data["userId"],
+            "nextIndex": 0,
+            "userMusicList": [],
+        }
 
-                if len(music_detail_list) == data["maxCount"]:
-                    next_index = data["maxCount"] + data["nextIndex"]
-                    break
+        num_user_songs = len(songs)
 
+        for x in range(next_index, upper_lim):
+            if num_user_songs <= x:
+                break
+
+            tmp = songs[x]._asdict()
+            tmp.pop("id")
+            tmp.pop("user")
+            music_detail_list.append(tmp)
+
+        next_index = 0 if len(music_detail_list) < max_ct or num_user_songs == upper_lim else upper_lim
+        self.logger.info(f"Send songs {next_index}-{upper_lim} ({len(music_detail_list)}) out of {num_user_songs} for user {user_id} (next idx {next_index})")
         return {
             "userId": data["userId"],
             "nextIndex": next_index,

titles/mai2/const.py

@@ -71,9 +71,9 @@ class Mai2Constants:
         "maimai DX PLUS",
         "maimai DX Splash",
         "maimai DX Splash PLUS",
-        "maimai DX Universe",
-        "maimai DX Universe PLUS",
-        "maimai DX Festival",
+        "maimai DX UNiVERSE",
+        "maimai DX UNiVERSE PLUS",
+        "maimai DX FESTiVAL",
     )
 
     @classmethod

titles/mai2/schema/item.py

@@ -39,8 +39,8 @@ card = Table(
     Column("cardTypeId", Integer, nullable=False),
     Column("charaId", Integer, nullable=False),
     Column("mapId", Integer, nullable=False),
-    Column("startDate", TIMESTAMP, server_default="2018-01-01 00:00:00.0"),
-    Column("endDate", TIMESTAMP, server_default="2038-01-01 00:00:00.0"),
+    Column("startDate", TIMESTAMP, nullable=False, server_default=func.now()),
+    Column("endDate", TIMESTAMP, nullable=False),
     UniqueConstraint("user", "cardId", "cardTypeId", name="mai2_item_card_uk"),
     mysql_charset="utf8mb4",
 )
@@ -444,6 +444,8 @@ class Mai2ItemData(BaseData):
         card_kind: int,
         chara_id: int,
         map_id: int,
+        start_date: datetime,
+        end_date: datetime,
     ) -> Optional[Row]:
         sql = insert(card).values(
             user=user_id,
@@ -451,9 +453,13 @@ class Mai2ItemData(BaseData):
             cardTypeId=card_kind,
             charaId=chara_id,
             mapId=map_id,
+            startDate=start_date,
+            endDate=end_date,
         )
 
-        conflict = sql.on_duplicate_key_update(charaId=chara_id, mapId=map_id)
+        conflict = sql.on_duplicate_key_update(
+            charaId=chara_id, mapId=map_id, startDate=start_date, endDate=end_date
+        )
 
         result = self.execute(conflict)
         if result is None:

titles/mai2/schema/score.py

@@ -7,6 +7,7 @@ from sqlalchemy.engine import Row
 from sqlalchemy.dialects.mysql import insert
 
 from core.data.schema import BaseData, metadata
+from core.data import cached
 
 best_score = Table(
     "mai2_score_best",
@@ -190,6 +191,7 @@ class Mai2ScoreData(BaseData):
             return None
         return result.lastrowid
 
+    @cached(2)
     def get_best_scores(self, user_id: int, song_id: int = None) -> Optional[List[Row]]:
         sql = best_score.select(
             and_(

titles/mai2/universe.py

@@ -14,3 +14,202 @@ class Mai2Universe(Mai2DX):
     def __init__(self, cfg: CoreConfig, game_cfg: Mai2Config) -> None:
         super().__init__(cfg, game_cfg)
         self.version = Mai2Constants.VER_MAIMAI_DX_UNIVERSE
+
+    def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
+        p = self.data.profile.get_profile_detail(data["userId"], self.version)
+        if p is None:
+            return {}
+
+        return {
+            "userName": p["userName"],
+            "rating": p["playerRating"],
+            # hardcode lastDataVersion for CardMaker 1.34
+            "lastDataVersion": "1.20.00",
+            "isLogin": False,
+            "isExistSellingCard": False,
+        }
+
+    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)
+
+        cards = self.data.card.get_user_cards(data["userId"])
+        if cards is None or len(cards) == 0:
+            # This should never happen
+            self.logger.error(
+                f"handle_get_user_data_api_request: Internal error - No cards found for user id {data['userId']}"
+            )
+            return {}
+
+        # get the dict representation of the row so we can modify values
+        user_data = p._asdict()
+
+        # remove the values the game doesn't want
+        user_data.pop("id")
+        user_data.pop("user")
+        user_data.pop("version")
+
+        return {"userId": data["userId"], "userData": user_data}
+
+    def handle_cm_login_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
+
+    def handle_cm_logout_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
+
+    def handle_cm_get_selling_card_api_request(self, data: Dict) -> Dict:
+        selling_cards = self.data.static.get_enabled_cards(self.version)
+        if selling_cards is None:
+            return {"length": 0, "sellingCardList": []}
+
+        selling_card_list = []
+        for card in selling_cards:
+            tmp = card._asdict()
+            tmp.pop("id")
+            tmp.pop("version")
+            tmp.pop("cardName")
+            tmp.pop("enabled")
+
+            tmp["startDate"] = datetime.strftime(tmp["startDate"], "%Y-%m-%d %H:%M:%S")
+            tmp["endDate"] = datetime.strftime(tmp["endDate"], "%Y-%m-%d %H:%M:%S")
+            tmp["noticeStartDate"] = datetime.strftime(
+                tmp["noticeStartDate"], "%Y-%m-%d %H:%M:%S"
+            )
+            tmp["noticeEndDate"] = datetime.strftime(
+                tmp["noticeEndDate"], "%Y-%m-%d %H:%M:%S"
+            )
+
+            selling_card_list.append(tmp)
+
+        return {"length": len(selling_card_list), "sellingCardList": selling_card_list}
+
+    def handle_cm_get_user_card_api_request(self, data: Dict) -> Dict:
+        user_cards = self.data.item.get_cards(data["userId"])
+        if user_cards is None:
+            return {"returnCode": 1, "length": 0, "nextIndex": 0, "userCardList": []}
+
+        max_ct = data["maxCount"]
+        next_idx = data["nextIndex"]
+        start_idx = next_idx
+        end_idx = max_ct + start_idx
+
+        if len(user_cards[start_idx:]) > max_ct:
+            next_idx += max_ct
+        else:
+            next_idx = 0
+
+        card_list = []
+        for card in user_cards:
+            tmp = card._asdict()
+            tmp.pop("id")
+            tmp.pop("user")
+
+            tmp["startDate"] = datetime.strftime(
+                tmp["startDate"], Mai2Constants.DATE_TIME_FORMAT
+            )
+            tmp["endDate"] = datetime.strftime(
+                tmp["endDate"], Mai2Constants.DATE_TIME_FORMAT
+            )
+            card_list.append(tmp)
+
+        return {
+            "returnCode": 1,
+            "length": len(card_list[start_idx:end_idx]),
+            "nextIndex": next_idx,
+            "userCardList": card_list[start_idx:end_idx],
+        }
+
+    def handle_cm_get_user_item_api_request(self, data: Dict) -> Dict:
+        super().handle_get_user_item_api_request(data)
+
+    def handle_cm_get_user_character_api_request(self, data: Dict) -> Dict:
+        characters = self.data.item.get_characters(data["userId"])
+
+        chara_list = []
+        for chara in characters:
+            chara_list.append(
+                {
+                    "characterId": chara["characterId"],
+                    # no clue why those values are even needed
+                    "point": 0,
+                    "count": 0,
+                    "level": chara["level"],
+                    "nextAwake": 0,
+                    "nextAwakePercent": 0,
+                    "favorite": False,
+                    "awakening": chara["awakening"],
+                    "useCount": chara["useCount"],
+                }
+            )
+
+        return {
+            "returnCode": 1,
+            "length": len(chara_list),
+            "userCharacterList": chara_list,
+        }
+
+    def handle_cm_get_user_card_print_error_api_request(self, data: Dict) -> Dict:
+        return {"length": 0, "userPrintDetailList": []}
+
+    def handle_cm_upsert_user_print_api_request(self, data: Dict) -> Dict:
+        user_id = data["userId"]
+        upsert = data["userPrintDetail"]
+
+        # set a random card serial number
+        serial_id = "".join([str(randint(0, 9)) for _ in range(20)])
+
+        # calculate start and end date of the card
+        start_date = datetime.utcnow()
+        end_date = datetime.utcnow() + timedelta(days=15)
+
+        user_card = upsert["userCard"]
+        self.data.item.put_card(
+            user_id,
+            user_card["cardId"],
+            user_card["cardTypeId"],
+            user_card["charaId"],
+            user_card["mapId"],
+            # add the correct start date and also the end date in 15 days
+            start_date,
+            end_date,
+        )
+
+        # get the profile extend to save the new bought card
+        extend = self.data.profile.get_profile_extend(user_id, self.version)
+        if extend:
+            extend = extend._asdict()
+            # parse the selectedCardList
+            # 6 = Freedom Pass, 4 = Gold Pass (cardTypeId)
+            selected_cards: list = extend["selectedCardList"]
+
+            # if no pass is already added, add the corresponding pass
+            if not user_card["cardTypeId"] in selected_cards:
+                selected_cards.insert(0, user_card["cardTypeId"])
+
+            extend["selectedCardList"] = selected_cards
+            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)
+
+        return {
+            "returnCode": 1,
+            "orderId": 0,
+            "serialId": serial_id,
+            "startDate": datetime.strftime(start_date, Mai2Constants.DATE_TIME_FORMAT),
+            "endDate": datetime.strftime(end_date, Mai2Constants.DATE_TIME_FORMAT),
+        }
+
+    def handle_cm_upsert_user_printlog_api_request(self, data: Dict) -> Dict:
+        return {
+            "returnCode": 1,
+            "orderId": 0,
+            "serialId": data["userPrintlog"]["serialId"],
+        }
+
+    def handle_cm_upsert_buy_card_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}

titles/pokken/base.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timedelta
 import json, logging
-from typing import Any, Dict
+from typing import Any, Dict, List
 import random
 
 from core.data import Data
@@ -44,19 +44,19 @@ class PokkenBase:
         biwa_setting = {
             "MatchingServer": {
                 "host": f"https://{self.game_cfg.server.hostname}",
-                "port": self.game_cfg.server.port,
+                "port": self.game_cfg.ports.game,
                 "url": "/SDAK/100/matching",
             },
             "StunServer": {
-                "addr": self.game_cfg.server.hostname,
-                "port": self.game_cfg.server.port_stun,
+                "addr": self.game_cfg.server.stun_server_host,
+                "port": self.game_cfg.server.stun_server_port,
             },
             "TurnServer": {
-                "addr": self.game_cfg.server.hostname,
-                "port": self.game_cfg.server.port_turn,
+                "addr": self.game_cfg.server.stun_server_host,
+                "port": self.game_cfg.server.stun_server_port,
             },
-            "AdmissionUrl": f"ws://{self.game_cfg.server.hostname}:{self.game_cfg.server.port_admission}",
-            "locationId": 123,
+            "AdmissionUrl": f"ws://{self.game_cfg.server.hostname}:{self.game_cfg.ports.admission}",
+            "locationId": 123, # FIXME: Get arcade's ID from the database
             "logfilename": "JackalMatchingLibrary.log",
             "biwalogfilename": "./biwa.log",
         }
@@ -94,6 +94,7 @@ class PokkenBase:
         res.type = jackal_pb2.MessageType.LOAD_CLIENT_SETTINGS
         settings = jackal_pb2.LoadClientSettingsResponseData()
 
+        # TODO: Make configurable
         settings.money_magnification = 1
         settings.continue_bonus_exp = 100
         settings.continue_fight_money = 100
@@ -274,6 +275,60 @@ class PokkenBase:
         res.result = 1
         res.type = jackal_pb2.MessageType.SAVE_USER
 
+        req = request.save_user
+        user_id = req.banapass_id
+        
+        tut_flgs: List[int] = []
+        ach_flgs: List[int] = []
+        evt_flgs: List[int] = []
+        evt_params: List[int] = []
+
+        get_rank_pts: int = req.get_trainer_rank_point if req.get_trainer_rank_point else 0
+        get_money: int = req.get_money
+        get_score_pts: int = req.get_score_point if req.get_score_point else 0
+        grade_max: int = req.grade_max_num
+        extra_counter: int = req.extra_counter
+        evt_reward_get_flg: int = req.event_reward_get_flag
+        num_continues: int = req.continue_num
+        total_play_days: int = req.total_play_days
+        awake_num: int = req.awake_num  # ?
+        use_support_ct: int = req.use_support_num
+        beat_num: int = req.beat_num # ?
+        evt_state: int = req.event_state
+        aid_skill: int = req.aid_skill
+        last_evt: int = req.last_play_event_id
+
+        battle = req.battle_data
+        mon = req.pokemon_data
+
+        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])
+
+        if 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)
+
+        for tut_flg in req.tutorial_progress_flag:
+            tut_flgs.append(tut_flg)
+        
+        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)
+
+        for evt_flg in req.event_achievement_flag:
+            evt_flgs.append(evt_flg)
+
+        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, )
+        
+        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)
+
         return res.SerializeToString()
 
     def handle_save_ingame_log(self, data: jackal_pb2.Request) -> bytes:
@@ -302,16 +357,35 @@ class PokkenBase:
         self, data: Dict = {}, client_ip: str = "127.0.0.1"
     ) -> Dict:
         """
-        "sessionId":"12345678",
+                "sessionId":"12345678",
+                "A":{
+                    "pcb_id": data["data"]["must"]["pcb_id"],
+                    "gip": client_ip
+                },
+        """
+        return {
+            "data": {
+                "sessionId":"12345678",
                 "A":{
                     "pcb_id": data["data"]["must"]["pcb_id"],
                     "gip": client_ip
                 },
                 "list":[]
-        """
-        return {}
+            }
+        }
 
     def handle_matching_stop_matching(
         self, data: Dict = {}, client_ip: str = "127.0.0.1"
     ) -> Dict:
         return {}
+
+    def handle_admission_noop(self, data: Dict, req_ip: str = "127.0.0.1") -> Dict:
+        return {}
+    
+    def handle_admission_joinsession(self, data: Dict, req_ip: str = "127.0.0.1") -> Dict:
+        self.logger.info(f"Admission: JoinSession from {req_ip}")
+        return {
+            'data': {
+                "id": 12345678
+            }
+        }

titles/pokken/config.py

@@ -25,30 +25,6 @@ class PokkenServerConfig:
             )
         )
 
-    @property
-    def port(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port", default=9000
-        )
-
-    @property
-    def port_stun(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port_stun", default=9001
-        )
-
-    @property
-    def port_turn(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port_turn", default=9002
-        )
-
-    @property
-    def port_admission(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "pokken", "server", "port_admission", default=9003
-        )
-
     @property
     def auto_register(self) -> bool:
         """
@@ -59,7 +35,51 @@ class PokkenServerConfig:
             self.__config, "pokken", "server", "auto_register", default=True
         )
 
+    @property
+    def enable_matching(self) -> bool:
+        """
+        If global matching should happen
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "server", "enable_matching", default=False
+        )
+    
+    @property
+    def stun_server_host(self) -> str:
+        """
+        Hostname of the EXTERNAL stun server the game should connect to. This is not handled by artemis.
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "server", "stun_server_host", default="stunserver.stunprotocol.org"
+        )
+
+    @property
+    def stun_server_port(self) -> int:
+        """
+        Port of the EXTERNAL stun server the game should connect to. This is not handled by artemis.
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "server", "stun_server_port", default=3478
+        )
+
+class PokkenPortsConfig:
+    def __init__(self, parent_config: "PokkenConfig"):
+        self.__config = parent_config
+    
+    @property
+    def game(self) -> int:
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "ports", "game", default=9000
+        )
+
+    @property
+    def admission(self) -> int:
+        return CoreConfig.get_config_field(
+            self.__config, "pokken", "ports", "admission", default=9001
+        )
+    
 
 class PokkenConfig(dict):
     def __init__(self) -> None:
         self.server = PokkenServerConfig(self)
+        self.ports = PokkenPortsConfig(self)

titles/pokken/const.py

@@ -11,14 +11,14 @@ class PokkenConstants:
     VERSION_NAMES = "Pokken Tournament"
 
     class BATTLE_TYPE(Enum):
-        BATTLE_TYPE_TUTORIAL = 1
-        BATTLE_TYPE_AI = 2
-        BATTLE_TYPE_LAN = 3
-        BATTLE_TYPE_WAN = 4
+        TUTORIAL = 1
+        AI = 2
+        LAN = 3
+        WAN = 4
 
     class BATTLE_RESULT(Enum):
-        BATTLE_RESULT_WIN = 1
-        BATTLE_RESULT_LOSS = 2
+        WIN = 1
+        LOSS = 2
 
     @classmethod
     def game_ver_to_string(cls, ver: int):

titles/pokken/frontend.py

@@ -2,8 +2,9 @@ import yaml
 import jinja2
 from twisted.web.http import Request
 from os import path
+from twisted.web.server import Session
 
-from core.frontend import FE_Base
+from core.frontend import FE_Base, IUserSession
 from core.config import CoreConfig
 from .database import PokkenData
 from .config import PokkenConfig
@@ -27,7 +28,12 @@ class PokkenFrontend(FE_Base):
         template = self.environment.get_template(
             "titles/pokken/frontend/pokken_index.jinja"
         )
+
+        sesh: Session = request.getSession()
+        usr_sesh = IUserSession(sesh)
+
         return template.render(
             title=f"{self.core_config.server.name} | {self.nav_name}",
             game_list=self.environment.globals["game_list"],
+            sesh=vars(usr_sesh)
         ).encode("utf-16")

titles/pokken/index.py

@@ -1,6 +1,7 @@
 from typing import Tuple
 from twisted.web.http import Request
 from twisted.web import resource
+from twisted.internet import reactor
 import json, ast
 from datetime import datetime
 import yaml
@@ -11,10 +12,11 @@ from os import path
 from google.protobuf.message import DecodeError
 
 from core import CoreConfig, Utils
-from titles.pokken.config import PokkenConfig
-from titles.pokken.base import PokkenBase
-from titles.pokken.const import PokkenConstants
-from titles.pokken.proto import jackal_pb2
+from .config import PokkenConfig
+from .base import PokkenBase
+from .const import PokkenConstants
+from .proto import jackal_pb2
+from .services import PokkenAdmissionFactory
 
 
 class PokkenServlet(resource.Resource):
@@ -69,7 +71,7 @@ class PokkenServlet(resource.Resource):
 
         return (
             True,
-            f"https://{game_cfg.server.hostname}:{game_cfg.server.port}/{game_code}/$v/",
+            f"https://{game_cfg.server.hostname}:{game_cfg.ports.game}/{game_code}/$v/",
             f"{game_cfg.server.hostname}/SDAK/$v/",
         )
 
@@ -90,8 +92,10 @@ class PokkenServlet(resource.Resource):
         return (True, "PKF1")
 
     def setup(self) -> None:
-        # TODO: Setup stun, turn (UDP) and admission (WSS) servers
-        pass
+        if self.game_cfg.server.enable_matching:
+            reactor.listenTCP(
+                self.game_cfg.ports.admission, PokkenAdmissionFactory(self.core_cfg, self.game_cfg)
+            )
 
     def render_POST(
         self, request: Request, version: int = 0, endpoints: str = ""
@@ -128,6 +132,9 @@ class PokkenServlet(resource.Resource):
         return ret
 
     def handle_matching(self, request: Request) -> bytes:
+        if not self.game_cfg.server.enable_matching:
+            return b""
+        
         content = request.content.getvalue()
         client_ip = Utils.get_ip_addr(request)
 

titles/pokken/schema/item.py

@@ -31,4 +31,16 @@ class PokkenItemData(BaseData):
     Items obtained as rewards
     """
 
-    pass
+    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,
+            content=content,
+            type=item_type,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(f"Failed to insert reward for user {user_id}: {category}-{content}-{item_type}")
+            return None
+        return result.lastrowid

titles/pokken/schema/profile.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, List
+from typing import Optional, Dict, List, Union
 from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_, case
 from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
 from sqlalchemy.schema import ForeignKey
@@ -125,7 +125,7 @@ pokemon_data = Table(
     Column("win_vs_lan", Integer),
     Column("battle_num_vs_cpu", Integer),  # 2
     Column("win_cpu", Integer),
-    Column("battle_all_num_tutorial", Integer),
+    Column("battle_all_num_tutorial", Integer), # ???
     Column("battle_num_tutorial", Integer),  # 1?
     Column("bp_point_atk", Integer),
     Column("bp_point_res", Integer),
@@ -147,11 +147,10 @@ class PokkenProfileData(BaseData):
             return None
         return result.lastrowid
 
-    def set_profile_name(self, user_id: int, new_name: str) -> None:
-        sql = (
-            update(profile)
-            .where(profile.c.user == user_id)
-            .values(trainer_name=new_name)
+    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)
         if result is None:
@@ -159,8 +158,38 @@ class PokkenProfileData(BaseData):
                 f"Failed to update pokken profile name for user {user_id}!"
             )
 
-    def update_profile_tutorial_flags(self, user_id: int, tutorial_flags: Dict) -> None:
-        pass
+    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)
+        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:
+        sql = update(profile).where(profile.c.user == user_id).values(
+            achievement_flag=achievement_flags,
+        )
+        result = 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:
+        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)
+        if result is None:
+            self.logger.error(
+                f"Failed to update pokken profile event state for user {user_id}!"
+            )
 
     def add_profile_points(
         self, user_id: int, rank_pts: int, money: int, score_pts: int
@@ -174,18 +203,53 @@ class PokkenProfileData(BaseData):
             return None
         return result.fetchone()
 
-    def put_pokemon_data(
+    def put_pokemon(
         self,
         user_id: int,
         pokemon_id: int,
         illust_no: int,
-        get_exp: int,
         atk: int,
         res: int,
         defe: int,
-        sp: int,
+        sp: int
     ) -> Optional[int]:
-        pass
+        sql = insert(pokemon_data).values(
+            user=user_id,
+            char_id=pokemon_id,
+            illustration_book_no=illust_no,
+            bp_point_atk=atk,
+            bp_point_res=res,
+            bp_point_defe=defe,
+            bp_point_sp=sp,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            illustration_book_no=illust_no,
+            bp_point_atk=atk,
+            bp_point_res=res,
+            bp_point_defe=defe,
+            bp_point_sp=sp,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.warn(f"Failed to insert pokemon ID {pokemon_id} for user {user_id}")
+            return None
+        return result.lastrowid
+
+    def add_pokemon_xp(
+        self,
+        user_id: int,
+        pokemon_id: int,
+        xp: int
+    ) -> None:
+        sql = update(pokemon_data).where(and_(pokemon_data.c.user==user_id, pokemon_data.c.char_id==pokemon_id)).values(
+            pokemon_exp=pokemon_data.c.pokemon_exp + xp
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(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]:
         pass
@@ -193,13 +257,29 @@ class PokkenProfileData(BaseData):
     def get_all_pokemon_data(self, user_id: int) -> Optional[List[Row]]:
         pass
 
-    def put_results(
-        self, user_id: int, pokemon_id: int, match_type: int, match_result: int
+    def put_pokemon_battle_result(
+        self, user_id: int, pokemon_id: int, match_type: PokkenConstants.BATTLE_TYPE, match_result: PokkenConstants.BATTLE_RESULT
     ) -> None:
         """
         Records the match stats (type and win/loss) for the pokemon and profile
         """
-        pass
+        sql = update(pokemon_data).where(and_(pokemon_data.c.user==user_id, pokemon_data.c.char_id==pokemon_id)).values(
+            battle_num_tutorial=pokemon_data.c.battle_num_tutorial + 1 if match_type==PokkenConstants.BATTLE_TYPE.TUTORIAL else pokemon_data.c.battle_num_tutorial,
+            battle_all_num_tutorial=pokemon_data.c.battle_all_num_tutorial + 1 if match_type==PokkenConstants.BATTLE_TYPE.TUTORIAL else pokemon_data.c.battle_all_num_tutorial,
+
+            battle_num_vs_cpu=pokemon_data.c.battle_num_vs_cpu + 1 if match_type==PokkenConstants.BATTLE_TYPE.AI else pokemon_data.c.battle_num_vs_cpu,
+            win_cpu=pokemon_data.c.win_cpu + 1 if match_type==PokkenConstants.BATTLE_TYPE.AI and match_result==PokkenConstants.BATTLE_RESULT.WIN else pokemon_data.c.win_cpu,
+
+            battle_num_vs_lan=pokemon_data.c.battle_num_vs_lan + 1 if match_type==PokkenConstants.BATTLE_TYPE.LAN else pokemon_data.c.battle_num_vs_lan,
+            win_vs_lan=pokemon_data.c.win_vs_lan + 1 if match_type==PokkenConstants.BATTLE_TYPE.LAN and match_result==PokkenConstants.BATTLE_RESULT.WIN else pokemon_data.c.win_vs_lan,
+
+            battle_num_vs_wan=pokemon_data.c.battle_num_vs_wan + 1 if match_type==PokkenConstants.BATTLE_TYPE.WAN else pokemon_data.c.battle_num_vs_wan,
+            win_vs_wan=pokemon_data.c.win_vs_wan + 1 if match_type==PokkenConstants.BATTLE_TYPE.WAN and match_result==PokkenConstants.BATTLE_RESULT.WIN else pokemon_data.c.win_vs_wan,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(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(
         self,
@@ -215,3 +295,17 @@ class PokkenProfileData(BaseData):
         Records profile stats
         """
         pass
+
+    def update_support_team(self, user_id: int, support_id: int, support1: int = 4294967295, support2: int = 4294967295) -> 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,
+            support_set_2_1=support1 if support_id == 2 else profile.c.support_set_2_1,
+            support_set_2_2=support2 if support_id == 2 else profile.c.support_set_2_2,
+            support_set_3_1=support1 if support_id == 3 else profile.c.support_set_3_1,
+            support_set_3_2=support2 if support_id == 3 else profile.c.support_set_3_2,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(f"Failed to update support team {support_id} for user {user_id}")

titles/pokken/services.py

@@ -0,0 +1,66 @@
+from twisted.internet.interfaces import IAddress
+from twisted.internet.protocol import Protocol
+from autobahn.twisted.websocket import WebSocketServerProtocol, WebSocketServerFactory
+from autobahn.websocket.types import ConnectionRequest
+from typing import Dict
+import logging
+import json
+
+from core.config import CoreConfig
+from .config import PokkenConfig
+from .base import PokkenBase
+
+class PokkenAdmissionProtocol(WebSocketServerProtocol):
+    def __init__(self, cfg: CoreConfig, game_cfg: PokkenConfig):
+        super().__init__()
+        self.core_config = cfg
+        self.game_config = game_cfg
+        self.logger = logging.getLogger("pokken")
+
+        self.base = PokkenBase(cfg, game_cfg)
+    
+    def onConnect(self, request: ConnectionRequest) -> None:
+        self.logger.debug(f"Admission: Connection from {request.peer}")
+    
+    def onClose(self, wasClean: bool, code: int, reason: str) -> None:
+        self.logger.debug(f"Admission: Connection with {self.transport.getPeer().host} closed {'cleanly ' if wasClean else ''}with code {code} - {reason}")
+
+    def onMessage(self, payload, isBinary: bool) -> None:
+        msg: Dict = json.loads(payload)
+        self.logger.debug(f"Admission: Message from {self.transport.getPeer().host}:{self.transport.getPeer().port} - {msg}")
+        
+        api = msg.get("api", "noop")
+        handler = getattr(self.base, f"handle_admission_{api.lower()}")
+        resp = handler(msg, self.transport.getPeer().host)
+        
+        if resp is None:
+            resp = {}
+
+        if "type" not in resp:
+            resp['type'] = "res"
+        if "data" not in resp:
+            resp['data'] = {}
+        if "api" not in resp:
+            resp['api'] = api
+        if "result" not in resp:
+            resp['result'] = 'true'
+        
+        self.logger.debug(f"Websocket response: {resp}")
+        self.sendMessage(json.dumps(resp).encode(), isBinary)
+
+class PokkenAdmissionFactory(WebSocketServerFactory):
+    protocol = PokkenAdmissionProtocol
+
+    def __init__(
+        self,
+        cfg: CoreConfig,
+        game_cfg: PokkenConfig
+    ) -> None:
+        self.core_config = cfg
+        self.game_config = game_cfg
+        super().__init__(f"ws://{self.game_config.server.hostname}:{self.game_config.ports.admission}")
+    
+    def buildProtocol(self, addr: IAddress) -> Protocol:
+        p = self.protocol(self.core_config, self.game_config)
+        p.factory = self
+        return p

titles/sao/__init__.py

@@ -0,0 +1,10 @@
+from .index import SaoServlet
+from .const import SaoConstants
+from .database import SaoData
+from .read import SaoReader
+
+index = SaoServlet
+database = SaoData
+reader = SaoReader
+game_codes = [SaoConstants.GAME_CODE]
+current_schema_version = 1

titles/sao/config.py

@@ -0,0 +1,47 @@
+from core.config import CoreConfig
+
+
+class SaoServerConfig:
+    def __init__(self, parent_config: "SaoConfig"):
+        self.__config = parent_config
+
+    @property
+    def hostname(self) -> str:
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "hostname", default="localhost"
+        )
+
+    @property
+    def enable(self) -> bool:
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "enable", default=True
+        )
+
+    @property
+    def loglevel(self) -> int:
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "sao", "server", "loglevel", default="info"
+            )
+        )
+
+    @property
+    def port(self) -> int:
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "port", default=9000
+        )
+
+    @property
+    def auto_register(self) -> bool:
+        """
+        Automatically register users in `aime_user` on first carding in with sao
+        if they don't exist already. Set to false to display an error instead.
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "sao", "server", "auto_register", default=True
+        )
+
+
+class SaoConfig(dict):
+    def __init__(self) -> None:
+        self.server = SaoServerConfig(self)

titles/sao/const.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class SaoConstants:
+    GAME_CODE = "SDEW"
+
+    CONFIG_NAME = "sao.yaml"
+
+    VER_SAO = 0
+
+    VERSION_NAMES = ("Sword Art Online Arcade")
+
+    @classmethod
+    def game_ver_to_string(cls, ver: int):
+        return cls.VERSION_NAMES[ver]

titles/sao/data/EquipmentLevel.csv

@@ -0,0 +1,121 @@
+EquipmentLevelId,RequireExp
+1,200,
+2,400,
+3,600,
+4,800,
+5,1000,
+6,1200,
+7,1400,
+8,1600,
+9,1800,
+10,2000,
+11,2200,
+12,2400,
+13,2600,
+14,2800,
+15,3000,
+16,3200,
+17,3400,
+18,3600,
+19,3800,
+20,4000,
+21,4200,
+22,4400,
+23,4600,
+24,4800,
+25,5000,
+26,5200,
+27,5400,
+28,5600,
+29,5800,
+30,6000,
+31,6200,
+32,6400,
+33,6600,
+34,6800,
+35,7000,
+36,7200,
+37,7400,
+38,7600,
+39,7800,
+40,8000,
+41,8200,
+42,8400,
+43,8600,
+44,8800,
+45,9000,
+46,9200,
+47,9400,
+48,9600,
+49,9800,
+50,10000,
+51,10200,
+52,10400,
+53,10600,
+54,10800,
+55,11000,
+56,11200,
+57,11400,
+58,11600,
+59,11800,
+60,12000,
+61,12200,
+62,12400,
+63,12600,
+64,12800,
+65,13000,
+66,13200,
+67,13400,
+68,13600,
+69,13800,
+70,14000,
+71,14200,
+72,14400,
+73,14600,
+74,14800,
+75,15000,
+76,15200,
+77,15400,
+78,15600,
+79,15800,
+80,16000,
+81,16200,
+82,16400,
+83,16600,
+84,16800,
+85,17000,
+86,17200,
+87,17400,
+88,17600,
+89,17800,
+90,18000,
+91,18200,
+92,18400,
+93,18600,
+94,18800,
+95,19000,
+96,19200,
+97,19400,
+98,19600,
+99,19800,
+100,100000,
+101,150000,
+102,200000,
+103,250000,
+104,300000,
+105,350000,
+106,400000,
+107,450000,
+108,500000,
+109,550000,
+110,600000,
+111,650000,
+112,700000,
+113,750000,
+114,800000,
+115,850000,
+116,900000,
+117,950000,
+118,1000000,
+119,1000000,
+120,1000000,

titles/sao/data/HeroLogLevel.csv

@@ -0,0 +1,121 @@
+HeroLogLevelId,RequireExp
+1,0,
+2,1000,
+3,1200,
+4,1400,
+5,1600,
+6,1900,
+7,2200,
+8,2500,
+9,2800,
+10,3100,
+11,3500,
+12,3900,
+13,4300,
+14,4700,
+15,5100,
+16,5550,
+17,6000,
+18,6450,
+19,6900,
+20,7350,
+21,7850,
+22,8350,
+23,8850,
+24,9350,
+25,9850,
+26,10450,
+27,11050,
+28,11650,
+29,12250,
+30,12850,
+31,13550,
+32,14250,
+33,14950,
+34,15650,
+35,16350,
+36,17150,
+37,17950,
+38,18750,
+39,19550,
+40,20350,
+41,21250,
+42,22150,
+43,23050,
+44,23950,
+45,24850,
+46,25850,
+47,26850,
+48,27850,
+49,28850,
+50,29850,
+51,30950,
+52,32050,
+53,33150,
+54,34250,
+55,35350,
+56,36550,
+57,37750,
+58,38950,
+59,40150,
+60,41350,
+61,42650,
+62,43950,
+63,45250,
+64,46550,
+65,47850,
+66,49250,
+67,50650,
+68,52050,
+69,53450,
+70,54850,
+71,56350,
+72,57850,
+73,59350,
+74,60850,
+75,62350,
+76,63950,
+77,65550,
+78,67150,
+79,68750,
+80,70350,
+81,72050,
+82,73750,
+83,75450,
+84,77150,
+85,78850,
+86,80650,
+87,82450,
+88,84250,
+89,86050,
+90,87850,
+91,89750,
+92,91650,
+93,93550,
+94,95450,
+95,97350,
+96,99350,
+97,101350,
+98,103350,
+99,105350,
+100,107350,
+101,200000,
+102,300000,
+103,450000,
+104,600000,
+105,800000,
+106,1000000,
+107,1250000,
+108,1500000,
+109,1800000,
+110,2100000,
+111,2100000,
+112,2100000,
+113,2100000,
+114,2100000,
+115,2100000,
+116,2100000,
+117,2100000,
+118,2100000,
+119,2100000,
+120,2100000,

titles/sao/data/PlayerRank.csv

@@ -0,0 +1,301 @@
+PlayerRankId,TotalExp,
+1,0,
+2,100,
+3,300,
+4,500,
+5,800,
+6,1100,
+7,1400,
+8,1800,
+9,2200,
+10,2600,,
+11,3000,,
+12,3500,,
+13,4000,,
+14,4500,,
+15,5000,,
+16,5500,,
+17,6100,,
+18,6700,,
+19,7300,,
+20,7900,,
+21,8500,,
+22,9100,,
+23,9800,,
+24,10500,
+25,11200,
+26,11900,
+27,12600,
+28,13300,
+29,14000,
+30,14800,
+31,15600,
+32,16400,
+33,17200,
+34,18000,
+35,18800,
+36,19600,
+37,20400,
+38,21300,
+39,22200,
+40,23100,
+41,24000,
+42,24900,
+43,25800,
+44,26700,
+45,27600,
+46,28500,
+47,29500,
+48,30600,
+49,31800,
+50,33100,
+51,34500,
+52,36000,
+53,37600,
+54,39300,
+55,41100,
+56,43000,
+57,45000,
+58,47100,
+59,49300,
+60,51600,
+61,54000,
+62,56500,
+63,59100,
+64,61800,
+65,64600,
+66,67500,
+67,70500,
+68,73600,
+69,76800,
+70,80100,
+71,83500,
+72,87000,
+73,90600,
+74,94300,
+75,98100,
+76,102000,
+77,106000,
+78,110100,
+79,114300,
+80,118600,
+81,123000,
+82,127500,
+83,132100,
+84,136800,
+85,141600,
+86,146500,
+87,151500,
+88,156600,
+89,161800,
+90,167100,
+91,172500,
+92,178000,
+93,183600,
+94,189300,
+95,195100,
+96,201000,
+97,207000,
+98,213100,
+99,219300,
+100,225600,
+101,232000,
+102,238500,
+103,245100,
+104,251800,
+105,258600,
+106,265500,
+107,272500,
+108,279600,
+109,286800,
+110,294100,
+111,301500,
+112,309000,
+113,316600,
+114,324300,
+115,332100,
+116,340000,
+117,348000,
+118,356100,
+119,364300,
+120,372600,
+121,381000,
+122,389500,
+123,398100,
+124,406800,
+125,415600,
+126,424500,
+127,433500,
+128,442600,
+129,451800,
+130,461100,
+131,470500,
+132,480000,
+133,489600,
+134,499300,
+135,509100,
+136,519000,
+137,529000,
+138,539100,
+139,549300,
+140,559600,
+141,570000,
+142,580500,
+143,591100,
+144,601800,
+145,612600,
+146,623500,
+147,634500,
+148,645600,
+149,656800,
+150,668100,
+151,679500,
+152,691000,
+153,702600,
+154,714300,
+155,726100,
+156,738000,
+157,750000,
+158,762100,
+159,774300,
+160,786600,
+161,799000,
+162,811500,
+163,824100,
+164,836800,
+165,849600,
+166,862500,
+167,875500,
+168,888600,
+169,901800,
+170,915100,
+171,928500,
+172,942000,
+173,955600,
+174,969300,
+175,983100,
+176,997000,
+177,1011000,
+178,1025100,
+179,1039300,
+180,1053600,
+181,1068000,
+182,1082500,
+183,1097100,
+184,1111800,
+185,1126600,
+186,1141500,
+187,1156500,
+188,1171600,
+189,1186800,
+190,1202100,
+191,1217500,
+192,1233000,
+193,1248600,
+194,1264300,
+195,1280100,
+196,1296000,
+197,1312000,
+198,1328100,
+199,1344300,
+200,1360600,
+201,1377000,
+202,1393500,
+203,1410100,
+204,1426800,
+205,1443600,
+206,1460500,
+207,1477500,
+208,1494600,
+209,1511800,
+210,1529100,
+211,1546500,
+212,1564000,
+213,1581600,
+214,1599300,
+215,1617100,
+216,1635000,
+217,1653000,
+218,1671100,
+219,1689300,
+220,1707600,
+221,1726000,
+222,1744500,
+223,1763100,
+224,1781800,
+225,1800600,
+226,1819500,
+227,1838500,
+228,1857600,
+229,1876800,
+230,1896100,
+231,1915500,
+232,1935000,
+233,1954600,
+234,1974300,
+235,1994100,
+236,2014000,
+237,2034000,
+238,2054100,
+239,2074300,
+240,2094600,
+241,2115000,
+242,2135500,
+243,2156100,
+244,2176800,
+245,2197600,
+246,2218500,
+247,2239500,
+248,2260600,
+249,2281800,
+250,2303100,
+251,2324500,
+252,2346000,
+253,2367600,
+254,2389300,
+255,2411100,
+256,2433000,
+257,2455000,
+258,2477100,
+259,2499300,
+260,2521600,
+261,2544000,
+262,2566500,
+263,2589100,
+264,2611800,
+265,2634600,
+266,2657500,
+267,2680500,
+268,2703600,
+269,2726800,
+270,2750100,
+271,2773500,
+272,2797000,
+273,2820600,
+274,2844300,
+275,2868100,
+276,2892000,
+277,2916000,
+278,2940100,
+279,2964300,
+280,2988600,
+281,3013000,
+282,3037500,
+283,3062100,
+284,3086800,
+285,3111600,
+286,3136500,
+287,3161500,
+288,3186600,
+289,3211800,
+290,3237100,
+291,3262500,
+292,3288000,
+293,3313600,
+294,3339300,
+295,3365100,
+296,3391000,
+297,3417000,
+298,3443100,
+299,3469300,
+300,3495600,

titles/sao/database.py

@@ -0,0 +1,12 @@
+from core.data import Data
+from core.config import CoreConfig
+
+from .schema import *
+
+
+class SaoData(Data):
+    def __init__(self, cfg: CoreConfig) -> None:
+        super().__init__(cfg)
+
+        self.profile = SaoProfileData(cfg, self.session)
+        self.static = SaoStaticData(cfg, self.session)

titles/sao/handlers/__init__.py

@@ -0,0 +1 @@
+from titles.sao.handlers.base import *

titles/sao/index.py

@@ -0,0 +1,116 @@
+from typing import Tuple
+from twisted.web.http import Request
+from twisted.web import resource
+import json, ast
+from datetime import datetime
+import yaml
+import logging, coloredlogs
+from logging.handlers import TimedRotatingFileHandler
+import inflection
+from os import path
+
+from core import CoreConfig, Utils
+from titles.sao.config import SaoConfig
+from titles.sao.const import SaoConstants
+from titles.sao.base import SaoBase
+from titles.sao.handlers.base import *
+
+
+class SaoServlet(resource.Resource):
+    def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
+        self.isLeaf = True
+        self.core_cfg = core_cfg
+        self.config_dir = cfg_dir
+        self.game_cfg = SaoConfig()
+        if path.exists(f"{cfg_dir}/sao.yaml"):
+            self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/sao.yaml")))
+
+        self.logger = logging.getLogger("sao")
+        if not hasattr(self.logger, "inited"):
+            log_fmt_str = "[%(asctime)s] SAO | %(levelname)s | %(message)s"
+            log_fmt = logging.Formatter(log_fmt_str)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.core_cfg.server.log_dir, "sao"),
+                encoding="utf8",
+                when="d",
+                backupCount=10,
+            )
+
+            fileHandler.setFormatter(log_fmt)
+
+            consoleHandler = logging.StreamHandler()
+            consoleHandler.setFormatter(log_fmt)
+
+            self.logger.addHandler(fileHandler)
+            self.logger.addHandler(consoleHandler)
+
+            self.logger.setLevel(self.game_cfg.server.loglevel)
+            coloredlogs.install(
+                level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
+            self.logger.inited = True
+
+        self.base = SaoBase(core_cfg, self.game_cfg)
+
+    @classmethod
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
+        game_cfg = SaoConfig()
+
+        if path.exists(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"):
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"))
+            )
+
+        if not game_cfg.server.enable:
+            return (False, "", "")
+
+        return (
+            True,
+            f"http://{game_cfg.server.hostname}:{game_cfg.server.port}/{game_code}/$v/",
+            f"{game_cfg.server.hostname}/SDEW/$v/",
+        )
+
+    @classmethod
+    def get_mucha_info(
+        cls, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
+        game_cfg = SaoConfig()
+
+        if path.exists(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"):
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{SaoConstants.CONFIG_NAME}"))
+            )
+
+        if not game_cfg.server.enable:
+            return (False, "")
+
+        return (True, "SAO1")
+
+    def setup(self) -> None:
+        pass
+
+    def render_POST(
+        self, request: Request, version: int = 0, endpoints: str = ""
+    ) -> bytes:
+        req_url = request.uri.decode()
+        if req_url == "/matching":
+            self.logger.info("Matching request")
+        
+        request.responseHeaders.addRawHeader(b"content-type", b"text/html; charset=utf-8")
+
+        sao_request = request.content.getvalue().hex()
+
+        handler = getattr(self.base, f"handle_{sao_request[:4]}", None)
+        if handler is None:
+            self.logger.info(f"Generic Handler for {req_url} - {sao_request[:4]}")
+            self.logger.debug(f"Request: {request.content.getvalue().hex()}")
+            resp = SaoNoopResponse(int.from_bytes(bytes.fromhex(sao_request[:4]), "big")+1)
+            self.logger.debug(f"Response: {resp.make().hex()}")
+            return resp.make()
+
+        self.logger.info(f"Handler {req_url} - {sao_request[:4]} request")
+        self.logger.debug(f"Request: {request.content.getvalue().hex()}")
+        self.logger.debug(f"Response: {handler(sao_request).hex()}")
+        return handler(sao_request)

titles/sao/read.py

@@ -0,0 +1,254 @@
+from typing import Optional, Dict, List
+from os import walk, path
+import urllib
+import csv
+
+from read import BaseReader
+from core.config import CoreConfig
+from titles.sao.database import SaoData
+from titles.sao.const import SaoConstants
+
+
+class SaoReader(BaseReader):
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_arg: Optional[str],
+        opt_arg: Optional[str],
+        extra: Optional[str],
+    ) -> None:
+        super().__init__(config, version, bin_arg, opt_arg, extra)
+        self.data = SaoData(config)
+
+        try:
+            self.logger.info(
+                f"Start importer for {SaoConstants.game_ver_to_string(version)}"
+            )
+        except IndexError:
+            self.logger.error(f"Invalid project SAO version {version}")
+            exit(1)
+
+    def read(self) -> None:
+        pull_bin_ram = True
+
+        if not path.exists(f"{self.bin_dir}"):
+            self.logger.warn(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:
+        self.logger.info(f"Read csv from {bin_dir}")
+
+        self.logger.info("Now reading QuestScene.csv")
+        try:
+            fullPath = bin_dir + "/QuestScene.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    questSceneId = row["QuestSceneId"]
+                    sortNo = row["SortNo"]
+                    name = row["Name"]
+                    enabled = True
+
+                    self.logger.info(f"Added quest {questSceneId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_quest(
+                            questSceneId,
+                            0,
+                            sortNo,
+                            name,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+        
+        self.logger.info("Now reading HeroLog.csv")
+        try:
+            fullPath = bin_dir + "/HeroLog.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    heroLogId = row["HeroLogId"]
+                    name = row["Name"]
+                    nickname = row["Nickname"]
+                    rarity = row["Rarity"]
+                    skillTableSubId = row["SkillTableSubId"]
+                    awakeningExp = row["AwakeningExp"]
+                    flavorText = row["FlavorText"]
+                    enabled = True
+
+                    self.logger.info(f"Added hero {heroLogId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_hero(
+                            0,
+                            heroLogId,
+                            name,
+                            nickname,
+                            rarity,
+                            skillTableSubId,
+                            awakeningExp,
+                            flavorText,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+        
+        self.logger.info("Now reading Equipment.csv")
+        try:
+            fullPath = bin_dir + "/Equipment.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    equipmentId = row["EquipmentId"]
+                    equipmentType = row["EquipmentType"]
+                    weaponTypeId = row["WeaponTypeId"]
+                    name = row["Name"]
+                    rarity = row["Rarity"]
+                    flavorText = row["FlavorText"]
+                    enabled = True
+
+                    self.logger.info(f"Added equipment {equipmentId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_equipment(
+                            0,
+                            equipmentId,
+                            name,
+                            equipmentType,
+                            weaponTypeId,
+                            rarity,
+                            flavorText,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+
+        self.logger.info("Now reading Item.csv")
+        try:
+            fullPath = bin_dir + "/Item.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    itemId = row["ItemId"]
+                    itemTypeId = row["ItemTypeId"]
+                    name = row["Name"]
+                    rarity = row["Rarity"]
+                    flavorText = row["FlavorText"]
+                    enabled = True
+
+                    self.logger.info(f"Added item {itemId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_item(
+                            0,
+                            itemId,
+                            name,
+                            itemTypeId,
+                            rarity,
+                            flavorText,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+        
+        self.logger.info("Now reading SupportLog.csv")
+        try:
+            fullPath = bin_dir + "/SupportLog.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    supportLogId = row["SupportLogId"]
+                    charaId = row["CharaId"]
+                    name = row["Name"]
+                    rarity = row["Rarity"]
+                    salePrice = row["SalePrice"]
+                    skillName = row["SkillName"]
+                    enabled = True
+
+                    self.logger.info(f"Added support log {supportLogId} | Name: {name}")
+                    
+                    try:
+                        self.data.static.put_support_log(
+                            0,
+                            supportLogId,
+                            charaId,
+                            name,
+                            rarity,
+                            salePrice,
+                            skillName,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+            
+        self.logger.info("Now reading Title.csv")
+        try:
+            fullPath = bin_dir + "/Title.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    titleId = row["TitleId"]
+                    displayName = row["DisplayName"]
+                    requirement = row["Requirement"]
+                    rank = row["Rank"]
+                    imageFilePath = row["ImageFilePath"]
+                    enabled = True
+
+                    self.logger.info(f"Added title {titleId} | Name: {displayName}")
+                    
+                    if len(titleId) > 5:
+                        try:
+                            self.data.static.put_title(
+                                0,
+                                titleId,
+                                displayName,
+                                requirement,
+                                rank,
+                                imageFilePath,
+                                enabled
+                            )
+                        except Exception as err:
+                            print(err)
+                    elif len(titleId) < 6: # current server code cannot have multiple lengths for the id
+                        continue
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")
+
+        self.logger.info("Now reading RareDropTable.csv")
+        try:
+            fullPath = bin_dir + "/RareDropTable.csv"
+            with open(fullPath, encoding="UTF-8") as fp:
+                reader = csv.DictReader(fp)
+                for row in reader:
+                    questRareDropId = row["QuestRareDropId"]
+                    commonRewardId = row["CommonRewardId"]
+                    enabled = True
+
+                    self.logger.info(f"Added rare drop {questRareDropId} | Reward: {commonRewardId}")
+                    
+                    try:
+                        self.data.static.put_rare_drop(
+                            0,
+                            questRareDropId,
+                            commonRewardId,
+                            enabled
+                        )
+                    except Exception as err:
+                        print(err)
+        except:
+            self.logger.warn(f"Couldn't read csv file in {self.bin_dir}, skipping")

titles/sao/schema/__init__.py

@@ -0,0 +1,3 @@
+from .profile import SaoProfileData
+from .static import SaoStaticData
+from .item import SaoItemData

titles/sao/schema/item.py

@@ -0,0 +1,458 @@
+from typing import Optional, Dict, List
+from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_, case
+from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.sql import func, select, update, delete
+from sqlalchemy.engine import Row
+from sqlalchemy.dialects.mysql import insert
+
+from core.data.schema import BaseData, metadata
+
+equipment_data = Table(
+    "sao_equipment_data",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("equipment_id", Integer, nullable=False),
+    Column("enhancement_value", Integer, nullable=False),
+    Column("enhancement_exp", Integer, nullable=False),
+    Column("awakening_exp", Integer, nullable=False),
+    Column("awakening_stage", Integer, nullable=False),
+    Column("possible_awakening_flag", Integer, nullable=False),
+    Column("get_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "equipment_id", name="sao_equipment_data_uk"),
+    mysql_charset="utf8mb4",
+)
+
+item_data = Table(
+    "sao_item_data",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("item_id", Integer, nullable=False),
+    Column("get_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "item_id", name="sao_item_data_uk"),
+    mysql_charset="utf8mb4",
+)
+
+hero_log_data = Table(
+    "sao_hero_log_data",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("user_hero_log_id", Integer, nullable=False),
+    Column("log_level", Integer, nullable=False),
+    Column("log_exp", Integer, nullable=False),
+    Column("main_weapon", Integer, nullable=False),
+    Column("sub_equipment", Integer, nullable=False),
+    Column("skill_slot1_skill_id", Integer, nullable=False),
+    Column("skill_slot2_skill_id", Integer, nullable=False),
+    Column("skill_slot3_skill_id", Integer, nullable=False),
+    Column("skill_slot4_skill_id", Integer, nullable=False),
+    Column("skill_slot5_skill_id", Integer, nullable=False),
+    Column("get_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "user_hero_log_id", name="sao_hero_log_data_uk"),
+    mysql_charset="utf8mb4",
+)
+
+hero_party = Table(
+    "sao_hero_party",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("user_party_team_id", Integer, nullable=False),
+    Column("user_hero_log_id_1", Integer, nullable=False),
+    Column("user_hero_log_id_2", Integer, nullable=False),
+    Column("user_hero_log_id_3", Integer, nullable=False),
+    UniqueConstraint("user", "user_party_team_id", name="sao_hero_party_uk"),
+    mysql_charset="utf8mb4",
+)
+
+quest = Table(
+    "sao_player_quest",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("episode_id", Integer, nullable=False),
+    Column("quest_clear_flag", Boolean, nullable=False),
+    Column("clear_time", Integer, nullable=False),
+    Column("combo_num", Integer, nullable=False),
+    Column("total_damage", Integer, nullable=False),
+    Column("concurrent_destroying_num", Integer, nullable=False),
+    Column("play_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "episode_id", name="sao_player_quest_uk"),
+    mysql_charset="utf8mb4",
+)
+
+sessions = Table(
+    "sao_play_sessions",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("user_party_team_id", Integer, nullable=False),
+    Column("episode_id", Integer, nullable=False),
+    Column("play_mode", Integer, nullable=False),
+    Column("quest_drop_boost_apply_flag", Integer, nullable=False),
+    Column("play_date", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "user_party_team_id", "play_date", name="sao_play_sessions_uk"),
+    mysql_charset="utf8mb4",
+)
+
+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]:
+        sql = insert(sessions).values(
+            user=user_id,
+            user_party_team_id=user_party_team_id,
+            episode_id=episode_id,
+            play_mode=play_mode,
+            quest_drop_boost_apply_flag=quest_drop_boost_apply_flag
+            )
+
+        conflict = sql.on_duplicate_key_update(user=user_id)
+
+        result = 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 put_item(self, user_id: int, item_id: int) -> Optional[int]:
+        sql = insert(item_data).values(
+            user=user_id,
+            item_id=item_id,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            item_id=item_id,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert item! user: {user_id}, item_id: {item_id}"
+            )
+            return None
+
+        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]:
+        sql = insert(equipment_data).values(
+            user=user_id,
+            equipment_id=equipment_id,
+            enhancement_value=enhancement_value,
+            enhancement_exp=enhancement_exp,
+            awakening_exp=awakening_exp,
+            awakening_stage=awakening_stage,
+            possible_awakening_flag=possible_awakening_flag,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            enhancement_value=enhancement_value,
+            enhancement_exp=enhancement_exp,
+            awakening_exp=awakening_exp,
+            awakening_stage=awakening_stage,
+            possible_awakening_flag=possible_awakening_flag,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert equipment! user: {user_id}, equipment_id: {equipment_id}"
+            )
+            return None
+
+        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]:
+        sql = insert(hero_log_data).values(
+            user=user_id,
+            user_hero_log_id=user_hero_log_id,
+            log_level=log_level,
+            log_exp=log_exp,
+            main_weapon=main_weapon,
+            sub_equipment=sub_equipment,
+            skill_slot1_skill_id=skill_slot1_skill_id,
+            skill_slot2_skill_id=skill_slot2_skill_id,
+            skill_slot3_skill_id=skill_slot3_skill_id,
+            skill_slot4_skill_id=skill_slot4_skill_id,
+            skill_slot5_skill_id=skill_slot5_skill_id,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            log_level=log_level,
+            log_exp=log_exp,
+            main_weapon=main_weapon,
+            sub_equipment=sub_equipment,
+            skill_slot1_skill_id=skill_slot1_skill_id,
+            skill_slot2_skill_id=skill_slot2_skill_id,
+            skill_slot3_skill_id=skill_slot3_skill_id,
+            skill_slot4_skill_id=skill_slot4_skill_id,
+            skill_slot5_skill_id=skill_slot5_skill_id,
+        )
+
+        result = 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}"
+            )
+            return None
+
+        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]:
+        sql = insert(hero_party).values(
+            user=user_id,
+            user_party_team_id=user_party_team_id,
+            user_hero_log_id_1=user_hero_log_id_1,
+            user_hero_log_id_2=user_hero_log_id_2,
+            user_hero_log_id_3=user_hero_log_id_3,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            user_hero_log_id_1=user_hero_log_id_1,
+            user_hero_log_id_2=user_hero_log_id_2,
+            user_hero_log_id_3=user_hero_log_id_3,
+        )
+
+        result = 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}"
+            )
+            return None
+
+        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]:
+        sql = insert(quest).values(
+            user=user_id,
+            episode_id=episode_id,
+            quest_clear_flag=quest_clear_flag,
+            clear_time=clear_time,
+            combo_num=combo_num,
+            total_damage=total_damage,
+            concurrent_destroying_num=concurrent_destroying_num
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            quest_clear_flag=quest_clear_flag,
+            clear_time=clear_time,
+            combo_num=combo_num,
+            total_damage=total_damage,
+            concurrent_destroying_num=concurrent_destroying_num
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert quest! user: {user_id}, episode_id: {episode_id}"
+            )
+            return None
+
+        return result.lastrowid
+
+    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)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    def get_user_equipments(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all equipments lookup given a profile
+        """
+        sql = equipment_data.select(
+            and_(
+                equipment_data.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_user_items(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all items lookup given a profile
+        """
+        sql = item_data.select(
+            and_(
+                item_data.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_hero_log(
+        self, user_id: int, user_hero_log_id: int = None
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all hero lookup given a profile and user_party_team_id and ID specifiers
+        """
+        sql = hero_log_data.select(
+            and_(
+                hero_log_data.c.user == user_id,
+                hero_log_data.c.user_hero_log_id == user_hero_log_id if user_hero_log_id is not None else True,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_hero_logs(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all hero lookup given a profile
+        """
+        sql = hero_log_data.select(
+            and_(
+                hero_log_data.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_hero_party(
+        self, user_id: int, user_party_team_id: int = None
+    ) -> Optional[List[Row]]:
+        sql = hero_party.select(
+            and_(
+                hero_party.c.user == user_id,
+                hero_party.c.user_party_team_id == user_party_team_id if user_party_team_id is not None else True,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_quest_log(
+        self, user_id: int, episode_id: int = None
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all quest lookup given a profile and episode_id
+        """
+        sql = quest.select(
+            and_(
+                quest.c.user == user_id,
+                quest.c.episode_id == episode_id if episode_id is not None else True,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_quest_logs(
+        self, user_id: int
+    ) -> Optional[List[Row]]:
+        """
+        A catch-all quest lookup given a profile
+        """
+        sql = quest.select(
+            and_(
+                quest.c.user == user_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_session(
+        self, user_id: int = None
+    ) -> Optional[List[Row]]:
+        sql = sessions.select(
+            and_(
+                sessions.c.user == user_id,
+            )
+        ).order_by(
+            sessions.c.play_date.asc()
+        )
+
+        result = 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:
+        sql = hero_log_data.delete(
+           and_(
+                hero_log_data.c.user == user_id,
+                hero_log_data.c.user_hero_log_id == user_hero_log_id,
+            )
+        )
+
+        result = 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:
+        sql = equipment_data.delete(
+            and_(equipment_data.c.user == user_id, equipment_data.c.equipment_id == equipment_id)
+        )
+
+        result = 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:
+        sql = item_data.delete(
+            and_(item_data.c.user == user_id, item_data.c.item_id == item_id)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to remove item! profile: {user_id}, item_id: {item_id}"
+            )
+        return None

titles/sao/schema/profile.py

@@ -0,0 +1,80 @@
+from typing import Optional, Dict, List
+from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_, case
+from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.sql import func, select, update, delete
+from sqlalchemy.engine import Row
+from sqlalchemy.dialects.mysql import insert
+
+from core.data.schema import BaseData, metadata
+from ..const import SaoConstants
+
+profile = Table(
+    "sao_profile",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+        unique=True,
+    ),
+    Column("user_type", Integer, server_default="1"),
+    Column("nick_name", String(16), server_default="PLAYER"),
+    Column("rank_num", Integer, server_default="1"),
+    Column("rank_exp", Integer, server_default="0"),
+    Column("own_col", Integer, server_default="0"),
+    Column("own_vp", Integer, server_default="0"),
+    Column("own_yui_medal", Integer, server_default="0"),
+    Column("setting_title_id", Integer, server_default="20005"),
+)
+
+class SaoProfileData(BaseData):
+    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)
+        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]:
+        sql = insert(profile).values(
+            user=user_id,
+            user_type=user_type,
+            nick_name=nick_name,
+            rank_num=rank_num,
+            rank_exp=rank_exp,
+            own_col=own_col,
+            own_vp=own_vp,
+            own_yui_medal=own_yui_medal,
+            setting_title_id=setting_title_id
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            rank_num=rank_num,
+            rank_exp=rank_exp,
+            own_col=own_col,
+            own_vp=own_vp,
+            own_yui_medal=own_yui_medal,
+            setting_title_id=setting_title_id
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.error(
+                f"{__name__} failed to insert profile! user: {user_id}"
+            )
+            return None
+
+        print(result.lastrowid)
+        return result.lastrowid
+
+    def get_profile(self, user_id: int) -> Optional[Row]:
+        sql = profile.select(profile.c.user == user_id)
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()

titles/sao/schema/static.py

@@ -0,0 +1,360 @@
+from typing import Dict, List, Optional
+from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
+from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON, Float
+from sqlalchemy.engine.base import Connection
+from sqlalchemy.engine import Row
+from sqlalchemy.schema import ForeignKey
+from sqlalchemy.sql import func, select
+from sqlalchemy.dialects.mysql import insert
+
+from core.data.schema import BaseData, metadata
+
+quest = Table(
+    "sao_static_quest",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("questSceneId", Integer),
+    Column("sortNo", Integer),
+    Column("name", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "questSceneId", name="sao_static_quest_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+hero = Table(
+    "sao_static_hero_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("heroLogId", Integer),
+    Column("name", String(255)),
+    Column("nickname", String(255)),
+    Column("rarity", Integer),
+    Column("skillTableSubId", Integer),
+    Column("awakeningExp", Integer),
+    Column("flavorText", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "heroLogId", name="sao_static_hero_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+equipment = Table(
+    "sao_static_equipment_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("equipmentId", Integer),
+    Column("equipmentType", Integer),
+    Column("weaponTypeId", Integer),
+    Column("name", String(255)),
+    Column("rarity", Integer),
+    Column("flavorText", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "equipmentId", name="sao_static_equipment_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+item = Table(
+    "sao_static_item_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("itemId", Integer),
+    Column("itemTypeId", Integer),
+    Column("name", String(255)),
+    Column("rarity", Integer),
+    Column("flavorText", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "itemId", name="sao_static_item_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+support = Table(
+    "sao_static_support_log_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("supportLogId", Integer),
+    Column("charaId", Integer),
+    Column("name", String(255)),
+    Column("rarity", Integer),
+    Column("salePrice", Integer),
+    Column("skillName", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "supportLogId", name="sao_static_support_log_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+rare_drop = Table(
+    "sao_static_rare_drop_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("questRareDropId", Integer),
+    Column("commonRewardId", Integer),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "questRareDropId", "commonRewardId", name="sao_static_rare_drop_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+title = Table(
+    "sao_static_title_list",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer),
+    Column("titleId", Integer),
+    Column("displayName", String(255)),
+    Column("requirement", Integer),
+    Column("rank", Integer),
+    Column("imageFilePath", String(255)),
+    Column("enabled", Boolean),
+    UniqueConstraint(
+        "version", "titleId", name="sao_static_title_list_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+class SaoStaticData(BaseData):
+    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,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, questSceneId=questSceneId, version=version
+        )
+
+        result = 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]:
+        sql = insert(hero).values(
+            version=version,
+            heroLogId=heroLogId,
+            name=name,
+            nickname=nickname,
+            rarity=rarity,
+            skillTableSubId=skillTableSubId,
+            awakeningExp=awakeningExp,
+            flavorText=flavorText,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, heroLogId=heroLogId
+        )
+
+        result = 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]:
+        sql = insert(equipment).values(
+            version=version,
+            equipmentId=equipmentId,
+            name=name,
+            equipmentType=equipmentType,
+            weaponTypeId=weaponTypeId,
+            rarity=rarity,
+            flavorText=flavorText,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, equipmentId=equipmentId
+        )
+
+        result = 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]:
+        sql = insert(item).values(
+            version=version,
+            itemId=itemId,
+            name=name,
+            itemTypeId=itemTypeId,
+            rarity=rarity,
+            flavorText=flavorText,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, itemId=itemId
+        )
+
+        result = 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]:
+        sql = insert(support).values(
+            version=version,
+            supportLogId=supportLogId,
+            charaId=charaId,
+            name=name,
+            rarity=rarity,
+            salePrice=salePrice,
+            skillName=skillName,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            name=name, supportLogId=supportLogId
+        )
+
+        result = 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]:
+        sql = insert(rare_drop).values(
+            version=version,
+            questRareDropId=questRareDropId,
+            commonRewardId=commonRewardId,
+            enabled=enabled,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            questRareDropId=questRareDropId, commonRewardId=commonRewardId, version=version
+        )
+
+        result = 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]:
+        sql = insert(title).values(
+            version=version,
+            titleId=titleId,
+            displayName=displayName,
+            requirement=requirement,
+            rank=rank,
+            imageFilePath=imageFilePath,
+            enabled=enabled
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            displayName=displayName, titleId=titleId
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    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)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+    
+    def get_hero_id(self, heroLogId: int) -> Optional[Dict]:
+        sql = hero.select(hero.c.heroLogId == heroLogId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    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)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+    
+    def get_equipment_id(self, equipmentId: int) -> Optional[Dict]:
+        sql = equipment.select(equipment.c.equipmentId == equipmentId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    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)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]
+
+    def get_item_id(self, itemId: int) -> Optional[Dict]:
+        sql = item.select(item.c.itemId == itemId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_rare_drop_id(self, questRareDropId: int) -> Optional[Dict]:
+        sql = rare_drop.select(rare_drop.c.questRareDropId == questRareDropId)
+        
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+    
+    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)
+        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]]:
+        sql = support.select(support.c.version == version and support.c.enabled == enabled).order_by(
+            support.c.supportLogId.asc()
+        )
+
+        result = 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]]:
+        sql = title.select(title.c.version == version and title.c.enabled == enabled).order_by(
+            title.c.titleId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return [list[2] for list in result.fetchall()]

titles/wacca/base.py

@@ -624,10 +624,10 @@ class WaccaBase:
         current_wp = profile["wp"]
 
         tickets = self.data.item.get_tickets(user_id)
-        new_tickets = []
+        new_tickets: List[TicketItem] = []
 
         for ticket in tickets:
-            new_tickets.append([ticket["id"], ticket["ticket_id"], 9999999999])
+            new_tickets.append(TicketItem(ticket["id"], ticket["ticket_id"], 9999999999))
 
         for item in req.itemsUsed:
             if (
@@ -645,11 +645,11 @@ class WaccaBase:
                 and not self.game_config.mods.infinite_tickets
             ):
                 for x in range(len(new_tickets)):
-                    if new_tickets[x][1] == item.itemId:
+                    if new_tickets[x].ticketId == item.itemId:
                         self.logger.debug(
-                            f"Remove ticket ID {new_tickets[x][0]} type {new_tickets[x][1]} from {user_id}"
+                            f"Remove ticket ID {new_tickets[x].userTicketId} type {new_tickets[x].ticketId} from {user_id}"
                         )
-                        self.data.item.spend_ticket(new_tickets[x][0])
+                        self.data.item.spend_ticket(new_tickets[x].userTicketId)
                         new_tickets.pop(x)
                         break
 
@@ -1074,17 +1074,17 @@ class WaccaBase:
                         old_score = self.data.score.get_best_score(
                             user_id, item.itemId, item.quantity
                         )
-                    if not old_score:
-                        self.data.score.put_best_score(
-                            user_id,
-                            item.itemId,
-                            item.quantity,
-                            0,
-                            [0] * 5,
-                            [0] * 13,
-                            0,
-                            0,
-                        )
+                        if not old_score:
+                            self.data.score.put_best_score(
+                                user_id,
+                                item.itemId,
+                                item.quantity,
+                                0,
+                                [0] * 5,
+                                [0] * 13,
+                                0,
+                                0,
+                            )
 
                     if item.quantity == 0:
                         item.quantity = WaccaConstants.Difficulty.HARD.value

titles/wacca/frontend.py

@@ -2,8 +2,9 @@ import yaml
 import jinja2
 from twisted.web.http import Request
 from os import path
+from twisted.web.server import Session
 
-from core.frontend import FE_Base
+from core.frontend import FE_Base, IUserSession
 from core.config import CoreConfig
 from titles.wacca.database import WaccaData
 from titles.wacca.config import WaccaConfig
@@ -27,7 +28,11 @@ class WaccaFrontend(FE_Base):
         template = self.environment.get_template(
             "titles/wacca/frontend/wacca_index.jinja"
         )
+        sesh: Session = request.getSession()
+        usr_sesh = IUserSession(sesh)
+        
         return template.render(
             title=f"{self.core_config.server.name} | {self.nav_name}",
             game_list=self.environment.globals["game_list"],
+            sesh=vars(usr_sesh)
         ).encode("utf-16")

titles/wacca/handlers/user_music.py

@@ -93,13 +93,10 @@ class UserMusicUnlockRequest(BaseRequest):
 
 
 class UserMusicUnlockResponse(BaseResponse):
-    def __init__(self, current_wp: int = 0, tickets_remaining: List = []) -> None:
+    def __init__(self, current_wp: int = 0, tickets_remaining: List[TicketItem] = []) -> None:
         super().__init__()
         self.wp = current_wp
-        self.tickets: List[TicketItem] = []
-
-        for ticket in tickets_remaining:
-            self.tickets.append(TicketItem(ticket[0], ticket[1], ticket[2]))
+        self.tickets = tickets_remaining
 
     def make(self) -> Dict:
         tickets = []