mai2: update script hotfix

Thanks to @One3 for helping with the events

contributing.md

@@ -0,0 +1,8 @@
+# Contributing to ARTEMiS
+If you would like to contribute to artemis, either by adding features, games, or fixing bugs, you can do so by forking the repo and submitting a pull request [here](https://gitea.tendokyu.moe/Hay1tsme/artemis/pulls). Please make sure, if you're submitting a PR for a game or game version, that you're following the n-0/y-1 guidelines, or it will be rejected.
+
+## Adding games
+Guide WIP
+
+## Adding game versions
+Guide WIP

core/__init__.py

@@ -4,3 +4,4 @@ from core.aimedb import AimedbFactory
 from core.title import TitleServlet
 from core.utils import Utils
 from core.mucha import MuchaServlet
+from core.frontend import FrontendServlet

core/aimedb.py

@@ -8,17 +8,18 @@ from logging.handlers import TimedRotatingFileHandler
 from core.config import CoreConfig
 from core.data import Data
 
+
 class AimedbProtocol(Protocol):
     AIMEDB_RESPONSE_CODES = {
         "felica_lookup": 0x03,
         "lookup": 0x06,
-        "log": 0x0a,
-        "campaign": 0x0c,
-        "touch": 0x0e,
+        "log": 0x0A,
+        "campaign": 0x0C,
+        "touch": 0x0E,
         "lookup2": 0x10,
         "felica_lookup2": 0x12,
         "log2": 0x14,
-        "hello": 0x65
+        "hello": 0x65,
     }
 
     request_list: Dict[int, Any] = {}
@@ -30,14 +31,14 @@ class AimedbProtocol(Protocol):
         if core_cfg.aimedb.key == "":
             self.logger.error("!!!KEY NOT SET!!!")
             exit(1)
-        
+
         self.request_list[0x01] = self.handle_felica_lookup
         self.request_list[0x04] = self.handle_lookup
         self.request_list[0x05] = self.handle_register
-        self.request_list[0x09] = self.handle_log        
-        self.request_list[0x0b] = self.handle_campaign
-        self.request_list[0x0d] = self.handle_touch
-        self.request_list[0x0f] = self.handle_lookup2
+        self.request_list[0x09] = self.handle_log
+        self.request_list[0x0B] = self.handle_campaign
+        self.request_list[0x0D] = self.handle_touch
+        self.request_list[0x0F] = self.handle_lookup2
         self.request_list[0x11] = self.handle_felica_lookup2
         self.request_list[0x13] = self.handle_log2
         self.request_list[0x64] = self.handle_hello
@@ -53,8 +54,10 @@ class AimedbProtocol(Protocol):
         self.logger.debug(f"{self.transport.getPeer().host} Connected")
 
     def connectionLost(self, reason) -> None:
-        self.logger.debug(f"{self.transport.getPeer().host} Disconnected - {reason.value}")
-    
+        self.logger.debug(
+            f"{self.transport.getPeer().host} Disconnected - {reason.value}"
+        )
+
     def dataReceived(self, data: bytes) -> None:
         cipher = AES.new(self.config.aimedb.key.encode(), AES.MODE_ECB)
 
@@ -66,7 +69,7 @@ class AimedbProtocol(Protocol):
 
         self.logger.debug(f"{self.transport.getPeer().host} wrote {decrypted.hex()}")
 
-        if not decrypted[1] == 0xa1 and not decrypted[0] == 0x3e:
+        if not decrypted[1] == 0xA1 and not decrypted[0] == 0x3E:
             self.logger.error(f"Bad magic")
             return None
 
@@ -90,30 +93,46 @@ class AimedbProtocol(Protocol):
         except ValueError as e:
             self.logger.error(f"Failed to encrypt {resp.hex()} because {e}")
             return None
-    
+
     def handle_campaign(self, data: bytes) -> bytes:
         self.logger.info(f"campaign from {self.transport.getPeer().host}")
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["campaign"], 0x0200, 0x0001)
+        ret = struct.pack(
+            "<5H",
+            0xA13E,
+            0x3087,
+            self.AIMEDB_RESPONSE_CODES["campaign"],
+            0x0200,
+            0x0001,
+        )
         return self.append_padding(ret)
-    
+
     def handle_hello(self, data: bytes) -> bytes:
         self.logger.info(f"hello from {self.transport.getPeer().host}")
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["hello"], 0x0020, 0x0001)
+        ret = struct.pack(
+            "<5H", 0xA13E, 0x3087, self.AIMEDB_RESPONSE_CODES["hello"], 0x0020, 0x0001
+        )
         return self.append_padding(ret)
 
     def handle_lookup(self, data: bytes) -> bytes:
-        luid = data[0x20: 0x2a].hex()
+        luid = data[0x20:0x2A].hex()
         user_id = self.data.card.get_user_id_from_card(access_code=luid)
 
-        if user_id is None: user_id = -1
+        if user_id is None:
+            user_id = -1
 
-        self.logger.info(f"lookup from {self.transport.getPeer().host}: luid {luid} -> user_id {user_id}")
+        self.logger.info(
+            f"lookup from {self.transport.getPeer().host}: luid {luid} -> user_id {user_id}"
+        )
 
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["lookup"], 0x0130, 0x0001)
+        ret = struct.pack(
+            "<5H", 0xA13E, 0x3087, self.AIMEDB_RESPONSE_CODES["lookup"], 0x0130, 0x0001
+        )
         ret += bytes(0x20 - len(ret))
 
-        if user_id is None: ret += struct.pack("<iH", -1, 0)
-        else: ret += struct.pack("<l", user_id)
+        if user_id is None:
+            ret += struct.pack("<iH", -1, 0)
+        else:
+            ret += struct.pack("<l", user_id)
         return self.append_padding(ret)
 
     def handle_lookup2(self, data: bytes) -> bytes:
@@ -125,66 +144,98 @@ class AimedbProtocol(Protocol):
         return bytes(ret)
 
     def handle_felica_lookup(self, data: bytes) -> bytes:
-        idm = data[0x20: 0x28].hex()
-        pmm = data[0x28: 0x30].hex()
+        idm = data[0x20:0x28].hex()
+        pmm = data[0x28:0x30].hex()
         access_code = self.data.card.to_access_code(idm)
-        self.logger.info(f"felica_lookup from {self.transport.getPeer().host}: idm {idm} pmm {pmm} -> access_code {access_code}")
+        self.logger.info(
+            f"felica_lookup from {self.transport.getPeer().host}: idm {idm} pmm {pmm} -> access_code {access_code}"
+        )
 
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["felica_lookup"], 0x0030, 0x0001)
+        ret = struct.pack(
+            "<5H",
+            0xA13E,
+            0x3087,
+            self.AIMEDB_RESPONSE_CODES["felica_lookup"],
+            0x0030,
+            0x0001,
+        )
         ret += bytes(26)
         ret += bytes.fromhex(access_code)
 
         return self.append_padding(ret)
 
     def handle_felica_lookup2(self, data: bytes) -> bytes:
-        idm = data[0x30: 0x38].hex()
-        pmm = data[0x38: 0x40].hex()
+        idm = data[0x30:0x38].hex()
+        pmm = data[0x38:0x40].hex()
         access_code = self.data.card.to_access_code(idm)
         user_id = self.data.card.get_user_id_from_card(access_code=access_code)
 
-        if user_id is None: user_id = -1
+        if user_id is None:
+            user_id = -1
 
-        self.logger.info(f"felica_lookup2 from {self.transport.getPeer().host}: idm {idm} ipm {pmm} -> access_code {access_code} user_id {user_id}")
+        self.logger.info(
+            f"felica_lookup2 from {self.transport.getPeer().host}: idm {idm} ipm {pmm} -> access_code {access_code} user_id {user_id}"
+        )
 
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["felica_lookup2"], 0x0140, 0x0001)
+        ret = struct.pack(
+            "<5H",
+            0xA13E,
+            0x3087,
+            self.AIMEDB_RESPONSE_CODES["felica_lookup2"],
+            0x0140,
+            0x0001,
+        )
         ret += bytes(22)
-        ret += struct.pack("<lq", user_id, -1) # first -1 is ext_id, 3rd is access code
+        ret += struct.pack("<lq", user_id, -1)  # first -1 is ext_id, 3rd is access code
         ret += bytes.fromhex(access_code)
         ret += struct.pack("<l", 1)
-        
+
         return self.append_padding(ret)
-    
+
     def handle_touch(self, data: bytes) -> bytes:
         self.logger.info(f"touch from {self.transport.getPeer().host}")
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["touch"], 0x0050, 0x0001)
+        ret = struct.pack(
+            "<5H", 0xA13E, 0x3087, self.AIMEDB_RESPONSE_CODES["touch"], 0x0050, 0x0001
+        )
         ret += bytes(5)
-        ret += struct.pack("<3H", 0x6f, 0, 1)
+        ret += struct.pack("<3H", 0x6F, 0, 1)
 
         return self.append_padding(ret)
 
-    def handle_register(self, data: bytes) -> bytes:        
-        luid = data[0x20: 0x2a].hex()
-        if self.config.server.allow_registration:
+    def handle_register(self, data: bytes) -> bytes:
+        luid = data[0x20:0x2A].hex()
+        if self.config.server.allow_user_registration:
             user_id = self.data.user.create_user()
 
-            if user_id is None: 
+            if user_id is None:
                 user_id = -1
                 self.logger.error("Failed to register user!")
 
             else:
                 card_id = self.data.card.create_card(user_id, luid)
 
-                if card_id is None: 
+                if card_id is None:
                     user_id = -1
                     self.logger.error("Failed to register card!")
 
-            self.logger.info(f"register from {self.transport.getPeer().host}: luid {luid} -> user_id {user_id}")
-        
+            self.logger.info(
+                f"register from {self.transport.getPeer().host}: luid {luid} -> user_id {user_id}"
+            )
+
         else:
-            self.logger.info(f"register from {self.transport.getPeer().host} blocked!: luid {luid}")
+            self.logger.info(
+                f"register from {self.transport.getPeer().host} blocked!: luid {luid}"
+            )
             user_id = -1
 
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["lookup"], 0x0030, 0x0001 if user_id > -1 else 0)
+        ret = struct.pack(
+            "<5H",
+            0xA13E,
+            0x3087,
+            self.AIMEDB_RESPONSE_CODES["lookup"],
+            0x0030,
+            0x0001 if user_id > -1 else 0,
+        )
         ret += bytes(0x20 - len(ret))
         ret += struct.pack("<l", user_id)
 
@@ -193,42 +244,54 @@ class AimedbProtocol(Protocol):
     def handle_log(self, data: bytes) -> bytes:
         # TODO: Save aimedb logs
         self.logger.info(f"log from {self.transport.getPeer().host}")
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["log"], 0x0020, 0x0001)
+        ret = struct.pack(
+            "<5H", 0xA13E, 0x3087, self.AIMEDB_RESPONSE_CODES["log"], 0x0020, 0x0001
+        )
         return self.append_padding(ret)
 
     def handle_log2(self, data: bytes) -> bytes:
         self.logger.info(f"log2 from {self.transport.getPeer().host}")
-        ret = struct.pack("<5H", 0xa13e, 0x3087, self.AIMEDB_RESPONSE_CODES["log2"], 0x0040, 0x0001)
+        ret = struct.pack(
+            "<5H", 0xA13E, 0x3087, self.AIMEDB_RESPONSE_CODES["log2"], 0x0040, 0x0001
+        )
         ret += bytes(22)
         ret += struct.pack("H", 1)
 
         return self.append_padding(ret)
 
+
 class AimedbFactory(Factory):
     protocol = AimedbProtocol
+
     def __init__(self, cfg: CoreConfig) -> None:
         self.config = cfg
         log_fmt_str = "[%(asctime)s] Aimedb | %(levelname)s | %(message)s"
         log_fmt = logging.Formatter(log_fmt_str)
         self.logger = logging.getLogger("aimedb")
 
-        fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.config.server.log_dir, "aimedb"), when="d", backupCount=10)
+        fileHandler = TimedRotatingFileHandler(
+            "{0}/{1}.log".format(self.config.server.log_dir, "aimedb"),
+            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.config.aimedb.loglevel)
-        coloredlogs.install(level=cfg.aimedb.loglevel, logger=self.logger, fmt=log_fmt_str)
-        
+        coloredlogs.install(
+            level=cfg.aimedb.loglevel, logger=self.logger, fmt=log_fmt_str
+        )
+
         if self.config.aimedb.key == "":
             self.logger.error("Please set 'key' field in your config file.")
             exit(1)
 
         self.logger.info(f"Ready on port {self.config.aimedb.port}")
-    
+
     def buildProtocol(self, addr):
         return AimedbProtocol(self.config)

core/allnet.py

@@ -12,11 +12,13 @@ from Crypto.Signature import PKCS1_v1_5
 from time import strptime
 
 from core.config import CoreConfig
-from core.data import Data
 from core.utils import Utils
+from core.data import Data
+from core.const import *
+
 
 class AllnetServlet:
-    def __init__(self, core_cfg: CoreConfig, cfg_folder: str):        
+    def __init__(self, core_cfg: CoreConfig, cfg_folder: str):
         super().__init__()
         self.config = core_cfg
         self.config_folder = cfg_folder
@@ -26,158 +28,185 @@ class AllnetServlet:
         self.logger = logging.getLogger("allnet")
         if not hasattr(self.logger, "initialized"):
             log_fmt_str = "[%(asctime)s] Allnet | %(levelname)s | %(message)s"
-            log_fmt = logging.Formatter(log_fmt_str)        
+            log_fmt = logging.Formatter(log_fmt_str)
 
-            fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.config.server.log_dir, "allnet"), when="d", backupCount=10)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.config.server.log_dir, "allnet"),
+                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(core_cfg.allnet.loglevel)
-            coloredlogs.install(level=core_cfg.allnet.loglevel, logger=self.logger, fmt=log_fmt_str)
+            coloredlogs.install(
+                level=core_cfg.allnet.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
             self.logger.initialized = True
 
         plugins = Utils.get_all_titles()
 
         if len(plugins) == 0:
             self.logger.error("No games detected!")
-        
+
         for _, mod in plugins.items():
-            for code in mod.game_codes:
-                if hasattr(mod, "use_default_title") and mod.use_default_title:
-                    if hasattr(mod, "include_protocol") and mod.include_protocol:
-                        if hasattr(mod, "title_secure") and mod.title_secure:
-                            uri = "https://"
-                        
-                        else:
-                            uri = "http://"
+            if hasattr(mod.index, "get_allnet_info"):
+                for code in mod.game_codes:
+                    enabled, uri, host = mod.index.get_allnet_info(
+                        code, self.config, self.config_folder
+                    )
 
-                    else:
-                        uri = ""
-                    
-                    if core_cfg.server.is_develop:
-                        uri += f"{core_cfg.title.hostname}:{core_cfg.title.port}"
-                    
-                    else:
-                        uri += f"{core_cfg.title.hostname}"
-                    
-                    uri += f"/{code}/$v"
+                    if enabled:
+                        self.uri_registry[code] = (uri, host)
 
-                    if hasattr(mod, "trailing_slash") and mod.trailing_slash:
-                        uri += "/"
-                
-                else:
-                    if hasattr(mod, "uri"):
-                        uri = mod.uri
-                    else:
-                        uri = ""
+        self.logger.info(
+            f"Serving {len(self.uri_registry)} game codes port {core_cfg.allnet.port}"
+        )
 
-                if hasattr(mod, "host"):
-                    host = mod.host
-                
-                elif hasattr(mod, "use_default_host") and mod.use_default_host:
-                    if core_cfg.server.is_develop:
-                        host = f"{core_cfg.title.hostname}:{core_cfg.title.port}"
-                    
-                    else:
-                        host = f"{core_cfg.title.hostname}"
-                
-                else:
-                    host = ""
-                
-                self.uri_registry[code] = (uri, host)
-        self.logger.info(f"Allnet serving {len(self.uri_registry)} games on port {core_cfg.allnet.port}")
-
-    def handle_poweron(self, request: Request):
-        request_ip = request.getClientAddress().host
+    def handle_poweron(self, request: Request, _: Dict):
+        request_ip = Utils.get_ip_addr(request)
         try:
-            req = AllnetPowerOnRequest(self.allnet_req_to_dict(request.content.getvalue()))
+            req_dict = self.allnet_req_to_dict(request.content.getvalue())
+            if req_dict is None:
+                raise AllnetRequestException()
+
+            req = AllnetPowerOnRequest(req_dict[0])
             # Validate the request. Currently we only validate the fields we plan on using
 
-            if not req.game_id or not req.ver or not req.token or not req.serial or not req.ip:
-                raise AllnetRequestException(f"Bad auth request params from {request_ip} - {vars(req)}")
-        
+            if not req.game_id or not req.ver or not req.serial or not req.ip:
+                raise AllnetRequestException(
+                    f"Bad auth request params from {request_ip} - {vars(req)}"
+                )
+
         except AllnetRequestException as e:
-            self.logger.error(e)
+            if e.message != "":
+                self.logger.error(e)
             return b""
-        
-        if req.format_ver == 3:
+
+        if req.format_ver == "3":
             resp = AllnetPowerOnResponse3(req.token)
         else:
             resp = AllnetPowerOnResponse2()
 
+        self.logger.debug(f"Allnet request: {vars(req)}")
         if req.game_id not in self.uri_registry:
-            msg = f"Unrecognised game {req.game_id} attempted allnet auth from {request_ip}."
-            self.data.base.log_event("allnet", "ALLNET_AUTH_UNKNOWN_GAME", logging.WARN, msg)
-            self.logger.warn(msg)
+            if not self.config.server.is_develop:
+                msg = f"Unrecognised game {req.game_id} attempted allnet auth from {request_ip}."
+                self.data.base.log_event(
+                    "allnet", "ALLNET_AUTH_UNKNOWN_GAME", logging.WARN, msg
+                )
+                self.logger.warn(msg)
+
+                resp.stat = 0
+                return self.dict_to_http_form_string([vars(resp)])
+            
+            else:
+                self.logger.info(f"Allowed unknown game {req.game_id} v{req.ver} to authenticate from {request_ip} due to 'is_develop' being enabled. S/N: {req.serial}")
+                resp.uri = f"http://{self.config.title.hostname}:{self.config.title.port}/{req.game_id}/{req.ver.replace('.', '')}/"
+                resp.host = f"{self.config.title.hostname}:{self.config.title.port}"
+                return self.dict_to_http_form_string([vars(resp)])
 
-            resp.stat = 0
-            return self.dict_to_http_form_string([vars(resp)])
-        
         resp.uri, resp.host = self.uri_registry[req.game_id]
 
         machine = self.data.arcade.get_machine(req.serial)
         if machine is None and not self.config.server.allow_unregistered_serials:
             msg = f"Unrecognised serial {req.serial} attempted allnet auth from {request_ip}."
-            self.data.base.log_event("allnet", "ALLNET_AUTH_UNKNOWN_SERIAL", logging.WARN, msg)
+            self.data.base.log_event(
+                "allnet", "ALLNET_AUTH_UNKNOWN_SERIAL", logging.WARN, msg
+            )
             self.logger.warn(msg)
 
             resp.stat = 0
             return self.dict_to_http_form_string([vars(resp)])
-        
+
         if machine is not None:
             arcade = self.data.arcade.get_arcade(machine["arcade"])
-            req.country = arcade["country"] if machine["country"] is None else machine["country"]
-            req.place_id = arcade["id"]
-            req.allnet_id = machine["id"]
-            req.name = arcade["name"]
-            req.nickname = arcade["nickname"]
-            req.region0 = arcade["region_id"]
-            req.region_name0 = arcade["country"]
-            req.region_name1 = arcade["state"]
-            req.region_name2 = arcade["city"]
-            req.client_timezone = arcade["timezone"] if arcade["timezone"] is not None else "+0900"
-        
+            country = (
+                arcade["country"] if machine["country"] is None else machine["country"]
+            )
+            if country is None:
+                country = AllnetCountryCode.JAPAN.value
+
+            resp.country = country
+            resp.place_id = arcade["id"]
+            resp.allnet_id = machine["id"]
+            resp.name = arcade["name"] if arcade["name"] is not None else ""
+            resp.nickname = arcade["nickname"] if arcade["nickname"] is not None else ""
+            resp.region0 = (
+                arcade["region_id"]
+                if arcade["region_id"] is not None
+                else AllnetJapanRegionId.AICHI.value
+            )
+            resp.region_name0 = (
+                arcade["country"]
+                if arcade["country"] is not None
+                else AllnetCountryCode.JAPAN.value
+            )
+            resp.region_name1 = (
+                arcade["state"]
+                if arcade["state"] is not None
+                else AllnetJapanRegionId.AICHI.name
+            )
+            resp.region_name2 = arcade["city"] if arcade["city"] is not None else ""
+            resp.client_timezone = (
+                arcade["timezone"] if arcade["timezone"] is not None else "+0900"
+            )
+
+        int_ver = req.ver.replace(".", "")
+        resp.uri = resp.uri.replace("$v", int_ver)
+        resp.host = resp.host.replace("$v", int_ver)
+
         msg = f"{req.serial} authenticated from {request_ip}: {req.game_id} v{req.ver}"
         self.data.base.log_event("allnet", "ALLNET_AUTH_SUCCESS", logging.INFO, msg)
         self.logger.info(msg)
+        self.logger.debug(f"Allnet response: {vars(resp)}")
 
-        return self.dict_to_http_form_string([vars(resp)])
+        return self.dict_to_http_form_string([vars(resp)]).encode("utf-8")
 
-    def handle_dlorder(self, request: Request):
-        request_ip = request.getClientAddress().host
+    def handle_dlorder(self, request: Request, _: Dict):
+        request_ip = Utils.get_ip_addr(request)
         try:
-            req = AllnetDownloadOrderRequest(self.allnet_req_to_dict(request.content.getvalue()))
+            req_dict = self.allnet_req_to_dict(request.content.getvalue())
+            if req_dict is None:
+                raise AllnetRequestException()
+
+            req = AllnetDownloadOrderRequest(req_dict[0])
             # Validate the request. Currently we only validate the fields we plan on using
 
-            if not req.game_id or not req.ver or not req.token or not req.serial or not req.ip:
-                raise AllnetRequestException(f"Bad auth request params from {request_ip} - {vars(req)}")
-        
+            if not req.game_id or not req.ver or not req.serial:
+                raise AllnetRequestException(
+                    f"Bad download request params from {request_ip} - {vars(req)}"
+                )
+
         except AllnetRequestException as e:
-            self.logger.error(e)
+            if e.message != "":
+                self.logger.error(e)
             return b""
 
+        self.logger.info(f"DownloadOrder from {request_ip} -> {req.game_id} v{req.ver} serial {req.serial}")
         resp = AllnetDownloadOrderResponse()
-        if not self.config.allnet.allow_online_updates:
-            return self.dict_to_http_form_string(vars(resp))
         
-        else: # TODO: Actual dlorder response
-            return self.dict_to_http_form_string(vars(resp))
+        if not self.config.allnet.allow_online_updates:
+            return self.dict_to_http_form_string([vars(resp)])
 
-    def handle_billing_request(self, request: Request):
+        else:  # TODO: Actual dlorder response
+            return self.dict_to_http_form_string([vars(resp)])
+
+    def handle_billing_request(self, request: Request, _: Dict):
         req_dict = self.billing_req_to_dict(request.content.getvalue())
-        request_ip = request.getClientAddress()
+        request_ip = Utils.get_ip_addr(request)
         if req_dict is None:
             self.logger.error(f"Failed to parse request {request.content.getvalue()}")
             return b""
-        
+
         self.logger.debug(f"request {req_dict}")
 
-        rsa = RSA.import_key(open(self.config.billing.sign_key, 'rb').read())
+        rsa = RSA.import_key(open(self.config.billing.signing_key, "rb").read())
         signer = PKCS1_v1_5.new(rsa)
         digest = SHA.new()
 
@@ -193,101 +222,116 @@ class AllnetServlet:
         machine = self.data.arcade.get_machine(kc_serial)
         if machine is None and not self.config.server.allow_unregistered_serials:
             msg = f"Unrecognised serial {kc_serial} attempted billing checkin from {request_ip} for game {kc_game}."
-            self.data.base.log_event("allnet", "BILLING_CHECKIN_NG_SERIAL", logging.WARN, msg)
+            self.data.base.log_event(
+                "allnet", "BILLING_CHECKIN_NG_SERIAL", logging.WARN, msg
+            )
             self.logger.warn(msg)
 
             resp = BillingResponse("", "", "", "")
             resp.result = "1"
             return self.dict_to_http_form_string([vars(resp)])
 
-        msg = f"Billing checkin from {request.getClientIP()}: game {kc_game} keychip {kc_serial} playcount " \
+        msg = (
+            f"Billing checkin from {request_ip}: game {kc_game} keychip {kc_serial} playcount "
             f"{kc_playcount} billing_type {kc_billigtype} nearfull {kc_nearfull} playlimit {kc_playlimit}"
+        )
         self.logger.info(msg)
-        self.data.base.log_event('billing', 'BILLING_CHECKIN_OK', logging.INFO, msg)
+        self.data.base.log_event("billing", "BILLING_CHECKIN_OK", logging.INFO, msg)
 
         while kc_playcount > kc_playlimit:
             kc_playlimit += 1024
             kc_nearfull += 1024
-        
+
         playlimit = kc_playlimit
         nearfull = kc_nearfull + (kc_billigtype * 0x00010000)
 
-        digest.update(playlimit.to_bytes(4, 'little') + kc_serial_bytes)
+        digest.update(playlimit.to_bytes(4, "little") + kc_serial_bytes)
         playlimit_sig = signer.sign(digest).hex()
 
         digest = SHA.new()
-        digest.update(nearfull.to_bytes(4, 'little') + kc_serial_bytes)
+        digest.update(nearfull.to_bytes(4, "little") + kc_serial_bytes)
         nearfull_sig = signer.sign(digest).hex()
 
         # TODO: playhistory
 
         resp = BillingResponse(playlimit, playlimit_sig, nearfull, nearfull_sig)
 
-        resp_str = self.dict_to_http_form_string([vars(resp)])
+        resp_str = self.dict_to_http_form_string([vars(resp)], True)
         if resp_str is None:
             self.logger.error(f"Failed to parse response {vars(resp)}")
 
         self.logger.debug(f"response {vars(resp)}")
         return resp_str.encode("utf-8")
 
-    def kvp_to_dict(self, *kvp: str) -> List[Dict[str, Any]]:
+    def handle_naomitest(self, request: Request, _: Dict) -> bytes:
+        self.logger.info(f"Ping from {Utils.get_ip_addr(request)}")
+        return b"naomi ok"
+
+    def kvp_to_dict(self, kvp: List[str]) -> List[Dict[str, Any]]:
         ret: List[Dict[str, Any]] = []
         for x in kvp:
-            items = x.split('&')
+            items = x.split("&")
             tmp = {}
 
             for item in items:
-                kvp = item.split('=')
+                kvp = item.split("=")
                 if len(kvp) == 2:
                     tmp[kvp[0]] = kvp[1]
 
             ret.append(tmp)
 
-    def allnet_req_to_dict(self, data: bytes):
+        return ret
+
+    def billing_req_to_dict(self, data: bytes):
         """
         Parses an billing request string into a python dictionary
         """
         try:
             decomp = zlib.decompressobj(-zlib.MAX_WBITS)
             unzipped = decomp.decompress(data)
-            sections = unzipped.decode('ascii').split('\r\n')
-            
-            return Utils.kvp_to_dict(sections)
+            sections = unzipped.decode("ascii").split("\r\n")
+
+            return self.kvp_to_dict(sections)
 
         except Exception as e:
-            print(e)
+            self.logger.error(f"billing_req_to_dict: {e} while parsing {data}")
             return None
 
-    def billing_req_to_dict(self, data: str) -> Optional[List[Dict[str, Any]]]:
+    def allnet_req_to_dict(self, data: str) -> Optional[List[Dict[str, Any]]]:
         """
         Parses an allnet request string into a python dictionary
-        """    
+        """
         try:
             zipped = base64.b64decode(data)
             unzipped = zlib.decompress(zipped)
-            sections = unzipped.decode('utf-8').split('\r\n')
-            
-            return Utils.kvp_to_dict(sections)
+            sections = unzipped.decode("utf-8").split("\r\n")
+
+            return self.kvp_to_dict(sections)
 
         except Exception as e:
-            print(e)
+            self.logger.error(f"allnet_req_to_dict: {e} while parsing {data}")
             return None
 
-    def dict_to_http_form_string(self, data:List[Dict[str, Any]], crlf: bool = False, trailing_newline: bool = True) -> Optional[str]:
+    def dict_to_http_form_string(
+        self,
+        data: List[Dict[str, Any]],
+        crlf: bool = False,
+        trailing_newline: bool = True,
+    ) -> Optional[str]:
         """
         Takes a python dictionary and parses it into an allnet response string
         """
         try:
             urlencode = ""
             for item in data:
-                for k,v in item.items():
+                for k, v in item.items():
                     urlencode += f"{k}={v}&"
 
                 if crlf:
                     urlencode = urlencode[:-1] + "\r\n"
                 else:
                     urlencode = urlencode[:-1] + "\n"
-            
+
             if not trailing_newline:
                 if crlf:
                     urlencode = urlencode[:-2]
@@ -295,31 +339,29 @@ class AllnetServlet:
                     urlencode = urlencode[:-1]
 
             return urlencode
-            
+
         except Exception as e:
-            print(e)
+            self.logger.error(f"dict_to_http_form_string: {e} while parsing {data}")
             return None
 
-class AllnetPowerOnRequest():
+
+class AllnetPowerOnRequest:
     def __init__(self, req: Dict) -> None:
         if req is None:
             raise AllnetRequestException("Request processing failed")
-        self.game_id: str = req["game_id"] if "game_id" in req else ""
-        self.ver: str = req["ver"] if "ver" in req else ""
-        self.serial: str  = req["serial"] if "serial" in req else ""
-        self.ip: str  = req["ip"] if "ip" in req else ""
-        self.firm_ver: str = req["firm_ver"] if "firm_ver" in req else ""
-        self.boot_ver: str = req["boot_ver"] if "boot_ver" in req else ""
-        self.encode: str = req["encode"] if "encode" in req else ""
-        
-        try:
-            self.hops = int(req["hops"]) if "hops" in req else 0
-            self.format_ver = int(req["format_ver"]) if "format_ver" in req else 2
-            self.token = int(req["token"]) if "token" in req else 0
-        except ValueError as e:
-            raise AllnetRequestException(f"Failed to parse int: {e}")
+        self.game_id: str = req.get("game_id", "")
+        self.ver: str = req.get("ver", "")
+        self.serial: str = req.get("serial", "")
+        self.ip: str = req.get("ip", "")
+        self.firm_ver: str = req.get("firm_ver", "")
+        self.boot_ver: str = req.get("boot_ver", "")
+        self.encode: str = req.get("encode", "")
+        self.hops = int(req.get("hops", "0"))
+        self.format_ver = req.get("format_ver", "2")
+        self.token = int(req.get("token", "0"))
 
-class AllnetPowerOnResponse3():
+
+class AllnetPowerOnResponse3:
     def __init__(self, token) -> None:
         self.stat = 1
         self.uri = ""
@@ -335,12 +377,15 @@ class AllnetPowerOnResponse3():
         self.country = "JPN"
         self.allnet_id = "123"
         self.client_timezone = "+0900"
-        self.utc_time = datetime.now(tz=pytz.timezone('UTC')).strftime("%Y-%m-%dT%H:%M:%SZ")
-        self.setting = ""
+        self.utc_time = datetime.now(tz=pytz.timezone("UTC")).strftime(
+            "%Y-%m-%dT%H:%M:%SZ"
+        )
+        self.setting = "1"
         self.res_ver = "3"
         self.token = str(token)
 
-class AllnetPowerOnResponse2():
+
+class AllnetPowerOnResponse2:
     def __init__(self) -> None:
         self.stat = 1
         self.uri = ""
@@ -364,23 +409,31 @@ class AllnetPowerOnResponse2():
         self.timezone = "+0900"
         self.res_class = "PowerOnResponseV2"
 
-class AllnetDownloadOrderRequest():
-    def __init__(self, req: Dict) -> None:
-        self.game_id = req["game_id"] if "game_id" in req else ""
-        self.ver = req["ver"] if "ver" in req else ""
-        self.serial = req["serial"] if "serial" in req else ""
-        self.encode = req["encode"] if "encode" in req else ""
 
-class AllnetDownloadOrderResponse():
+class AllnetDownloadOrderRequest:
+    def __init__(self, req: Dict) -> None:
+        self.game_id = req.get("game_id", "")
+        self.ver = req.get("ver", "")
+        self.serial = req.get("serial", "")
+        self.encode = req.get("encode", "")
+
+
+class AllnetDownloadOrderResponse:
     def __init__(self, stat: int = 1, serial: str = "", uri: str = "null") -> None:
         self.stat = stat
         self.serial = serial
         self.uri = uri
 
-class BillingResponse():
-    def __init__(self, playlimit: str = "", playlimit_sig: str = "", nearfull: str = "", nearfull_sig: str = "", 
-        playhistory: str = "000000/0:000000/0:000000/0") -> None:
 
+class BillingResponse:
+    def __init__(
+        self,
+        playlimit: str = "",
+        playlimit_sig: str = "",
+        nearfull: str = "",
+        nearfull_sig: str = "",
+        playhistory: str = "000000/0:000000/0:000000/0",
+    ) -> None:
         self.result = "0"
         self.waitime = "100"
         self.linelimit = "1"
@@ -392,11 +445,12 @@ class BillingResponse():
         self.nearfullsig = nearfull_sig
         self.fixlogincnt = "0"
         self.fixinterval = "5"
-        self.playhistory = playhistory 
+        self.playhistory = playhistory
         # playhistory -> YYYYMM/C:...
         # YYYY -> 4 digit year, MM -> 2 digit month, C -> Playcount during that period
 
+
 class AllnetRequestException(Exception):
-    def __init__(self, message="Allnet Request Error") -> None:
+    def __init__(self, message="") -> None:
         self.message = message
         super().__init__(self.message)

core/config.py

@@ -1,33 +1,47 @@
 import logging, os
 from typing import Any
 
+
 class ServerConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
         self.__config = parent_config
 
     @property
     def listen_address(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'server', 'listen_address', default='127.0.0.1')
+        return CoreConfig.get_config_field(
+            self.__config, "core", "server", "listen_address", default="127.0.0.1"
+        )
 
     @property
     def allow_user_registration(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'core', 'server', 'allow_user_registration', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "server", "allow_user_registration", default=True
+        )
 
     @property
     def allow_unregistered_serials(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'core', 'server', 'allow_unregistered_serials', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "server", "allow_unregistered_serials", default=True
+        )
 
     @property
     def name(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'server', 'name', default="ARTEMiS")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "server", "name", default="ARTEMiS"
+        )
 
     @property
     def is_develop(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'core', 'server', 'is_develop', default=True)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "server", "is_develop", default=True
+        )
 
     @property
     def log_dir(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'server', 'log_dir', default='logs')
+        return CoreConfig.get_config_field(
+            self.__config, "core", "server", "log_dir", default="logs"
+        )
+
 
 class TitleConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -35,15 +49,24 @@ class TitleConfig:
 
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'core', 'title', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "title", "loglevel", default="info"
+            )
+        )
 
     @property
     def hostname(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'title', 'hostname', default="localhost")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "title", "hostname", default="localhost"
+        )
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'title', 'port', default=8080)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "title", "port", default=8080
+        )
+
 
 class DatabaseConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -51,43 +74,70 @@ class DatabaseConfig:
 
     @property
     def host(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'host', default="localhost")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "host", default="localhost"
+        )
 
     @property
     def username(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'username', default='aime')
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "username", default="aime"
+        )
 
     @property
     def password(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'password', default='aime')
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "password", default="aime"
+        )
 
     @property
     def name(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'name', default='aime')
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "name", default="aime"
+        )
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'port', default=3306)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "port", default=3306
+        )
 
     @property
     def protocol(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'type', default="mysql")
-    
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "type", default="mysql"
+        )
+
     @property
     def sha2_password(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'sha2_password', default=False)
-    
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "sha2_password", default=False
+        )
+
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'core', 'database', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "database", "loglevel", default="info"
+            )
+        )
 
     @property
     def user_table_autoincrement_start(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'user_table_autoincrement_start', default=10000)
-    
+        return CoreConfig.get_config_field(
+            self.__config,
+            "core",
+            "database",
+            "user_table_autoincrement_start",
+            default=10000,
+        )
+
     @property
     def memcached_host(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'database', 'memcached_host', default="localhost")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "database", "memcached_host", default="localhost"
+        )
+
 
 class FrontendConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -95,15 +145,24 @@ class FrontendConfig:
 
     @property
     def enable(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'frontend', 'enable', default=False)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "frontend", "enable", default=False
+        )
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'frontend', 'port', default=8090)
-    
+        return CoreConfig.get_config_field(
+            self.__config, "core", "frontend", "port", default=8090
+        )
+
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'core', 'frontend', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "frontend", "loglevel", default="info"
+            )
+        )
+
 
 class AllnetConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -111,15 +170,24 @@ class AllnetConfig:
 
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'core', 'allnet', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "allnet", "loglevel", default="info"
+            )
+        )
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'allnet', 'port', default=80)
-    
+        return CoreConfig.get_config_field(
+            self.__config, "core", "allnet", "port", default=80
+        )
+
     @property
     def allow_online_updates(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'allnet', 'allow_online_updates', default=False)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "allnet", "allow_online_updates", default=False
+        )
+
 
 class BillingConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -127,35 +195,53 @@ class BillingConfig:
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'billing', 'port', default=8443)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "billing", "port", default=8443
+        )
 
     @property
     def ssl_key(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'billing', 'ssl_key', default="cert/server.key")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "billing", "ssl_key", default="cert/server.key"
+        )
 
     @property
     def ssl_cert(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'billing', 'ssl_cert', default="cert/server.pem")
-    
+        return CoreConfig.get_config_field(
+            self.__config, "core", "billing", "ssl_cert", default="cert/server.pem"
+        )
+
     @property
     def signing_key(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'billing', 'signing_key', default="cert/billing.key")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "billing", "signing_key", default="cert/billing.key"
+        )
+
 
 class AimedbConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
         self.__config = parent_config
-    
+
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'core', 'aimedb', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "aimedb", "loglevel", default="info"
+            )
+        )
 
     @property
     def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'aimedb', 'port', default=22345)
+        return CoreConfig.get_config_field(
+            self.__config, "core", "aimedb", "port", default=22345
+        )
 
     @property
     def key(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'aimedb', 'key', default="")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "aimedb", "key", default=""
+        )
+
 
 class MuchaConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -163,27 +249,24 @@ class MuchaConfig:
 
     @property
     def enable(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'mucha', 'enable', default=False)
-    
-    @property
-    def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'core', 'mucha', 'loglevel', default="info"))
-    
-    @property
-    def hostname(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'mucha', 'hostname', default="localhost")
+        return CoreConfig.get_config_field(
+            self.__config, "core", "mucha", "enable", default=False
+        )
 
     @property
-    def port(self) -> int:
-        return CoreConfig.get_config_field(self.__config, 'core', 'mucha', 'port', default=8444)
-    
+    def loglevel(self) -> int:
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "mucha", "loglevel", default="info"
+            )
+        )
+
     @property
-    def ssl_cert(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'mucha', 'ssl_cert', default="cert/server.pem")
-    
-    @property
-    def signing_key(self) -> str:
-        return CoreConfig.get_config_field(self.__config, 'core', 'mucha', 'signing_key', default="cert/billing.key")
+    def hostname(self) -> str:
+        return CoreConfig.get_config_field(
+            self.__config, "core", "mucha", "hostname", default="localhost"
+        )
+
 
 class CoreConfig(dict):
     def __init__(self) -> None:
@@ -194,25 +277,28 @@ class CoreConfig(dict):
         self.allnet = AllnetConfig(self)
         self.billing = BillingConfig(self)
         self.aimedb = AimedbConfig(self)
+        self.mucha = MuchaConfig(self)
 
     @classmethod
     def str_to_loglevel(cls, level_str: str):
         if level_str.lower() == "error":
             return logging.ERROR
-        elif level_str.lower().startswith("warn"): # Fits warn or warning
+        elif level_str.lower().startswith("warn"):  # Fits warn or warning
             return logging.WARN
         elif level_str.lower() == "debug":
             return logging.DEBUG
         else:
-             return logging.INFO
+            return logging.INFO
 
     @classmethod
-    def get_config_field(cls, __config: dict, module, *path: str, default: Any = "") -> Any:
-        envKey = f'CFG_{module}_'
+    def get_config_field(
+        cls, __config: dict, module, *path: str, default: Any = ""
+    ) -> Any:
+        envKey = f"CFG_{module}_"
         for arg in path:
-            envKey += arg + '_'
-        
-        if envKey.endswith('_'):
+            envKey += arg + "_"
+
+        if envKey.endswith("_"):
             envKey = envKey[:-1]
 
         if envKey in os.environ:

core/const.py

@@ -1,6 +1,7 @@
 from enum import Enum
 
-class MainboardPlatformCodes():
+
+class MainboardPlatformCodes:
     RINGEDGE = "AALE"
     RINGWIDE = "AAML"
     NU = "AAVE"
@@ -8,7 +9,8 @@ class MainboardPlatformCodes():
     ALLS_UX = "ACAE"
     ALLS_HX = "ACAX"
 
-class MainboardRevisions():
+
+class MainboardRevisions:
     RINGEDGE = 1
     RINGEDGE2 = 2
 
@@ -26,11 +28,70 @@ class MainboardRevisions():
     ALLS_UX2 = 2
     ALLS_HX2 = 12
 
-class KeychipPlatformsCodes():
+
+class KeychipPlatformsCodes:
     RING = "A72E"
     NU = ("A60E", "A60E", "A60E")
     NUSX = ("A61X", "A69X")
     ALLS = "A63E"
-    
-class RegionIDs(Enum):
-    pass
+
+
+class AllnetCountryCode(Enum):
+    JAPAN = "JPN"
+    UNITED_STATES = "USA"
+    HONG_KONG = "HKG"
+    SINGAPORE = "SGP"
+    SOUTH_KOREA = "KOR"
+    TAIWAN = "TWN"
+    CHINA = "CHN"
+
+
+class AllnetJapanRegionId(Enum):
+    NONE = 0
+    AICHI = 1
+    AOMORI = 2
+    AKITA = 3
+    ISHIKAWA = 4
+    IBARAKI = 5
+    IWATE = 6
+    EHIME = 7
+    OITA = 8
+    OSAKA = 9
+    OKAYAMA = 10
+    OKINAWA = 11
+    KAGAWA = 12
+    KAGOSHIMA = 13
+    KANAGAWA = 14
+    GIFU = 15
+    KYOTO = 16
+    KUMAMOTO = 17
+    GUNMA = 18
+    KOCHI = 19
+    SAITAMA = 20
+    SAGA = 21
+    SHIGA = 22
+    SHIZUOKA = 23
+    SHIMANE = 24
+    CHIBA = 25
+    TOKYO = 26
+    TOKUSHIMA = 27
+    TOCHIGI = 28
+    TOTTORI = 29
+    TOYAMA = 30
+    NAGASAKI = 31
+    NAGANO = 32
+    NARA = 33
+    NIIGATA = 34
+    HYOGO = 35
+    HIROSHIMA = 36
+    FUKUI = 37
+    FUKUOKA = 38
+    FUKUSHIMA = 39
+    HOKKAIDO = 40
+    MIE = 41
+    MIYAGI = 42
+    MIYAZAKI = 43
+    YAMAGATA = 44
+    YAMAGUCHI = 45
+    YAMANASHI = 46
+    WAKAYAMA = 47

core/data/__init__.py

@@ -1,2 +1,2 @@
 from core.data.database import Data
-from core.data.cache import cached
+from core.data.cache import cached

core/data/cache.py

@@ -1,4 +1,3 @@
-
 from typing import Any, Callable
 from functools import wraps
 import hashlib
@@ -6,15 +5,17 @@ import pickle
 import logging
 from core.config import CoreConfig
 
-cfg:CoreConfig = None # type: ignore
+cfg: CoreConfig = None  # type: ignore
 # Make memcache optional
 try:
     import pylibmc  # type: ignore
+
     has_mc = True
 except ModuleNotFoundError:
     has_mc = False
 
-def cached(lifetime: int=10, extra_key: Any=None) -> Callable:
+
+def cached(lifetime: int = 10, extra_key: Any = None) -> Callable:
     def _cached(func: Callable) -> Callable:
         if has_mc:
             hostname = "127.0.0.1"
@@ -22,11 +23,10 @@ def cached(lifetime: int=10, extra_key: Any=None) -> Callable:
                 hostname = cfg.database.memcached_host
             memcache = pylibmc.Client([hostname], binary=True)
             memcache.behaviors = {"tcp_nodelay": True, "ketama": True}
-            
+
             @wraps(func)
             def wrapper(*args: Any, **kwargs: Any) -> Any:
                 if lifetime is not None:
-
                     # Hash function args
                     items = kwargs.items()
                     hashable_args = (args[1:], sorted(list(items)))
@@ -41,7 +41,7 @@ def cached(lifetime: int=10, extra_key: Any=None) -> Callable:
                     except pylibmc.Error as e:
                         logging.getLogger("database").error(f"Memcache failed: {e}")
                         result = None
-                        
+
                     if result is not None:
                         logging.getLogger("database").debug(f"Cache hit: {result}")
                         return result
@@ -55,7 +55,9 @@ def cached(lifetime: int=10, extra_key: Any=None) -> Callable:
                     memcache.set(cache_key, result, lifetime)
 
                 return result
+
         else:
+
             @wraps(func)
             def wrapper(*args: Any, **kwargs: Any) -> Any:
                 return func(*args, **kwargs)

core/data/database.py

@@ -1,14 +1,18 @@
 import logging, coloredlogs
-from typing import Any, Dict, List
+from typing import Optional
 from sqlalchemy.orm import scoped_session, sessionmaker
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy import create_engine
 from logging.handlers import TimedRotatingFileHandler
-
+import importlib, os
+import secrets, string
+import bcrypt
 from hashlib import sha256
 
 from core.config import CoreConfig
 from core.data.schema import *
+from core.utils import Utils
+
 
 class Data:
     def __init__(self, cfg: CoreConfig) -> None:
@@ -19,7 +23,7 @@ class Data:
             self.__url = f"{self.config.database.protocol}://{self.config.database.username}:{passwd.hex()}@{self.config.database.host}/{self.config.database.name}?charset=utf8mb4"
         else:
             self.__url = f"{self.config.database.protocol}://{self.config.database.username}:{self.config.database.password}@{self.config.database.host}/{self.config.database.name}?charset=utf8mb4"
-        
+
         self.__engine = create_engine(self.__url, pool_recycle=3600)
         session = sessionmaker(bind=self.__engine, autoflush=True, autocommit=True)
         self.session = scoped_session(session)
@@ -28,18 +32,22 @@ class Data:
         self.arcade = ArcadeData(self.config, self.session)
         self.card = CardData(self.config, self.session)
         self.base = BaseData(self.config, self.session)
-        self.schema_ver_latest = 1
+        self.schema_ver_latest = 4
 
         log_fmt_str = "[%(asctime)s] %(levelname)s | Database | %(message)s"
         log_fmt = logging.Formatter(log_fmt_str)
         self.logger = logging.getLogger("database")
 
         # Prevent the logger from adding handlers multiple times
-        if not getattr(self.logger, 'handler_set', None):
-            fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.config.server.log_dir, "db"), encoding="utf-8",
-                when="d", backupCount=10)
+        if not getattr(self.logger, "handler_set", None):
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.config.server.log_dir, "db"),
+                encoding="utf-8",
+                when="d",
+                backupCount=10,
+            )
             fileHandler.setFormatter(log_fmt)
-            
+
             consoleHandler = logging.StreamHandler()
             consoleHandler.setFormatter(log_fmt)
 
@@ -47,7 +55,225 @@ class Data:
             self.logger.addHandler(consoleHandler)
 
             self.logger.setLevel(self.config.database.loglevel)
-            coloredlogs.install(cfg.database.loglevel, logger=self.logger, fmt=log_fmt_str)
-            self.logger.handler_set = True # type: ignore
+            coloredlogs.install(
+                cfg.database.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
+            self.logger.handler_set = True  # type: ignore
 
-    
+    def create_database(self):
+        self.logger.info("Creating databases...")
+        try:
+            metadata.create_all(self.__engine.connect())
+        except SQLAlchemyError as e:
+            self.logger.error(f"Failed to create databases! {e}")
+            return
+
+        games = Utils.get_all_titles()
+        for game_dir, game_mod in games.items():
+            try:
+                if hasattr(game_mod, "database") and hasattr(game_mod, "current_schema_version"):
+                    game_mod.database(self.config)
+                metadata.create_all(self.__engine.connect())
+
+                self.base.set_schema_ver(
+                    game_mod.current_schema_version, game_mod.game_codes[0]
+                )
+
+            except Exception as e:
+                self.logger.warning(
+                    f"Could not load database schema from {game_dir} - {e}"
+                )
+
+        self.logger.info(f"Setting base_schema_ver to {self.schema_ver_latest}")
+        self.base.set_schema_ver(self.schema_ver_latest)
+
+        self.logger.info(
+            f"Setting user auto_incrememnt to {self.config.database.user_table_autoincrement_start}"
+        )
+        self.user.reset_autoincrement(
+            self.config.database.user_table_autoincrement_start
+        )
+
+    def recreate_database(self):
+        self.logger.info("Dropping all databases...")
+        self.base.execute("SET FOREIGN_KEY_CHECKS=0")
+        try:
+            metadata.drop_all(self.__engine.connect())
+        except SQLAlchemyError as e:
+            self.logger.error(f"Failed to drop databases! {e}")
+            return
+
+        for root, dirs, files in os.walk("./titles"):
+            for dir in dirs:
+                if not dir.startswith("__"):
+                    try:
+                        mod = importlib.import_module(f"titles.{dir}")
+
+                        try:
+                            if hasattr(mod, "database"):
+                                mod.database(self.config)
+                            metadata.drop_all(self.__engine.connect())
+
+                        except Exception as e:
+                            self.logger.warning(
+                                f"Could not load database schema from {dir} - {e}"
+                            )
+
+                    except ImportError as e:
+                        self.logger.warning(
+                            f"Failed to load database schema dir {dir} - {e}"
+                        )
+            break
+
+        self.base.execute("SET FOREIGN_KEY_CHECKS=1")
+
+        self.create_database()
+
+    def migrate_database(self, game: str, version: int, action: str) -> None:
+        old_ver = self.base.get_schema_ver(game)
+        sql = ""
+
+        if old_ver is None:
+            self.logger.error(
+                f"Schema for game {game} does not exist, did you run the creation script?"
+            )
+            return
+
+        if old_ver == version:
+            self.logger.info(
+                f"Schema for game {game} is already version {old_ver}, nothing to do"
+            )
+            return
+
+        if action == "upgrade":
+            for x in range(old_ver, version):
+                if not os.path.exists(
+                    f"core/data/schema/versions/{game.upper()}_{x + 1}_{action}.sql"
+                ):
+                    self.logger.error(
+                        f"Could not find {action} script {game.upper()}_{x + 1}_{action}.sql in core/data/schema/versions folder"
+                    )
+                    return
+
+                with open(
+                    f"core/data/schema/versions/{game.upper()}_{x + 1}_{action}.sql",
+                    "r",
+                    encoding="utf-8",
+                ) as f:
+                    sql = f.read()
+
+                result = self.base.execute(sql)
+                if result is None:
+                    self.logger.error("Error execuing sql script!")
+                    return None
+        
+        else:
+            for x in range(old_ver, version, -1):
+                if not os.path.exists(
+                    f"core/data/schema/versions/{game.upper()}_{x - 1}_{action}.sql"
+                ):
+                    self.logger.error(
+                        f"Could not find {action} script {game.upper()}_{x - 1}_{action}.sql in core/data/schema/versions folder"
+                    )
+                    return
+
+                with open(
+                    f"core/data/schema/versions/{game.upper()}_{x - 1}_{action}.sql",
+                    "r",
+                    encoding="utf-8",
+                ) as f:
+                    sql = f.read()
+
+                result = self.base.execute(sql)
+                if result is None:
+                    self.logger.error("Error execuing sql script!")
+                    return None
+
+        result = self.base.set_schema_ver(version, game)
+        if result is None:
+            self.logger.error("Error setting version in schema_version table!")
+            return None
+
+        self.logger.info(f"Successfully migrated {game} to schema version {version}")
+
+    def create_owner(self, email: Optional[str] = None) -> None:
+        pw = "".join(
+            secrets.choice(string.ascii_letters + string.digits) for i in range(20)
+        )
+        hash = bcrypt.hashpw(pw.encode(), bcrypt.gensalt())
+
+        user_id = self.user.create_user(email=email, permission=255, password=hash)
+        if user_id is None:
+            self.logger.error(f"Failed to create owner with email {email}")
+            return
+
+        card_id = self.card.create_card(user_id, "00000000000000000000")
+        if card_id is None:
+            self.logger.error(f"Failed to create card for owner with id {user_id}")
+            return
+
+        self.logger.warn(
+            f"Successfully created owner with email {email}, access code 00000000000000000000, and password {pw} Make sure to change this password and assign a real card ASAP!"
+        )
+
+    def migrate_card(self, old_ac: str, new_ac: str, should_force: bool) -> None:
+        if old_ac == new_ac:
+            self.logger.error("Both access codes are the same!")
+            return
+
+        new_card = self.card.get_card_by_access_code(new_ac)
+        if new_card is None:
+            self.card.update_access_code(old_ac, new_ac)
+            return
+
+        if not should_force:
+            self.logger.warn(
+                f"Card already exists for access code {new_ac} (id {new_card['id']}). If you wish to continue, rerun with the '--force' flag."
+                f" All exiting data on the target card {new_ac} will be perminently erased and replaced with data from card {old_ac}."
+            )
+            return
+
+        self.logger.info(
+            f"All exiting data on the target card {new_ac} will be perminently erased and replaced with data from card {old_ac}."
+        )
+        self.card.delete_card(new_card["id"])
+        self.card.update_access_code(old_ac, new_ac)
+
+        hanging_user = self.user.get_user(new_card["user"])
+        if hanging_user["password"] is None:
+            self.logger.info(f"Delete hanging user {hanging_user['id']}")
+            self.user.delete_user(hanging_user["id"])
+
+    def delete_hanging_users(self) -> None:
+        """
+        Finds and deletes users that have not registered for the webui that have no cards assocated with them.
+        """
+        unreg_users = self.user.get_unregistered_users()
+        if unreg_users is None:
+            self.logger.error("Error occoured finding unregistered users")
+
+        for user in unreg_users:
+            cards = self.card.get_user_cards(user["id"])
+            if cards is None:
+                self.logger.error(f"Error getting cards for user {user['id']}")
+                continue
+
+            if not cards:
+                self.logger.info(f"Delete hanging user {user['id']}")
+                self.user.delete_user(user["id"])
+
+    def autoupgrade(self) -> None:
+        all_games = self.base.get_all_schema_vers()
+        if all_games is None:
+            self.logger.warn("Failed to get schema versions")
+        
+        for x in all_games:
+            game = x["game"].upper()
+            update_ver = 1
+            for y in range(2, 100):
+                if os.path.exists(f"core/data/schema/versions/{game}_{y}_upgrade.sql"):
+                    update_ver = y
+                else:
+                    break
+        
+            self.migrate_database(game, update_ver, "upgrade")

core/data/schema/__init__.py

@@ -3,4 +3,4 @@ from core.data.schema.card import CardData
 from core.data.schema.base import BaseData, metadata
 from core.data.schema.arcade import ArcadeData
 
-__all__ = ["UserData", "CardData", "BaseData", "metadata", "ArcadeData"]
+__all__ = ["UserData", "CardData", "BaseData", "metadata", "ArcadeData"]

core/data/schema/arcade.py

@@ -4,110 +4,216 @@ from sqlalchemy.sql.schema import ForeignKey, PrimaryKeyConstraint
 from sqlalchemy.types import Integer, String, Boolean
 from sqlalchemy.sql import func, select
 from sqlalchemy.dialects.mysql import insert
+import re
 
 from core.data.schema.base import BaseData, metadata
+from core.const import *
 
 arcade = Table(
     "arcade",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
     Column("name", String(255)),
-    Column("nickname", String(255)),    
+    Column("nickname", String(255)),
     Column("country", String(3)),
     Column("country_id", Integer),
     Column("state", String(255)),
     Column("city", String(255)),
     Column("region_id", Integer),
     Column("timezone", String(255)),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 machine = Table(
     "machine",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("arcade", ForeignKey("arcade.id", ondelete="cascade", onupdate="cascade"), nullable=False),    
+    Column(
+        "arcade",
+        ForeignKey("arcade.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("serial", String(15), nullable=False),
     Column("board", String(15)),
     Column("game", String(4)),
-    Column("country", String(3)), # overwrites if not null
+    Column("country", String(3)),  # overwrites if not null
     Column("timezone", String(255)),
     Column("ota_enable", Boolean),
     Column("is_cab", Boolean),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 arcade_owner = Table(
-    'arcade_owner',
+    "arcade_owner",
     metadata,
-    Column('user', Integer, ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
-    Column('arcade', Integer, ForeignKey("arcade.id", ondelete="cascade", onupdate="cascade"), nullable=False),
-    Column('permissions', Integer, nullable=False),
-    PrimaryKeyConstraint('user', 'arcade', name='arcade_owner_pk'),
-    mysql_charset='utf8mb4'
+    Column(
+        "user",
+        Integer,
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column(
+        "arcade",
+        Integer,
+        ForeignKey("arcade.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("permissions", Integer, nullable=False),
+    PrimaryKeyConstraint("user", "arcade", name="arcade_owner_pk"),
+    mysql_charset="utf8mb4",
 )
 
+
 class ArcadeData(BaseData):
     def get_machine(self, serial: str = None, id: int = None) -> Optional[Dict]:
         if serial is not None:
-            sql = machine.select(machine.c.serial == serial)
+            serial = serial.replace("-", "")
+            if len(serial) == 11:
+                sql = machine.select(machine.c.serial.like(f"{serial}%"))
+
+            elif len(serial) == 15:
+                sql = machine.select(machine.c.serial == serial)
+
+            else:
+                self.logger.error(f"{__name__ }: Malformed serial {serial}")
+                return None
+
         elif id is not None:
             sql = machine.select(machine.c.id == id)
-        else: 
+
+        else:
             self.logger.error(f"{__name__ }: Need either serial or ID to look up!")
             return None
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
-    def put_machine(self, arcade_id: int, serial: str = None, board: str = None, game: str = None, is_cab: bool = False) -> Optional[int]:
+
+    def put_machine(
+        self,
+        arcade_id: int,
+        serial: str = "",
+        board: str = None,
+        game: str = None,
+        is_cab: bool = False,
+    ) -> Optional[int]:
         if arcade_id:
             self.logger.error(f"{__name__ }: Need arcade id!")
             return None
 
-        if serial is None:
-            pass
-
-        sql = machine.insert().values(arcade = arcade_id, keychip = serial, board = board, game = game, is_cab = is_cab)
-        
-        result = self.execute(sql)
-        if result is None: return None
-        return result.lastrowid
-    
-    def get_arcade(self, id: int) -> Optional[Dict]:
-        sql = arcade.select(arcade.c.id == id)
-        result = self.execute(sql)
-        if result is None: return None
-        return result.fetchone()
-    
-    def put_arcade(self, name: str, nickname: str = None, country: str = "JPN", country_id: int = 1, 
-        state: str = "", city: str = "", regional_id: int = 1) -> Optional[int]:
-        if nickname is None: nickname = name
-
-        sql = arcade.insert().values(name = name, nickname = nickname, country = country, country_id = country_id,
-        state = state, city = city, regional_id = regional_id)
-
-        result = self.execute(sql)
-        if result is None: return None
-        return result.lastrowid
-
-    def get_arcade_owners(self, arcade_id: int) -> Optional[Dict]:
-        sql = select(arcade_owner).where(arcade_owner.c.arcade==arcade_id)
-
-        result = self.execute(sql)
-        if result is None: return None
-        return result.fetchall()
-
-    def add_arcade_owner(self, arcade_id: int, user_id: int) -> None:
-        sql = insert(arcade_owner).values(
-            arcade=arcade_id,
-            user=user_id
+        sql = machine.insert().values(
+            arcade=arcade_id, keychip=serial, board=board, game=game, is_cab=is_cab
         )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
-    def generate_keychip_serial(self, platform_id: int) -> str:
-        pass
+    def set_machine_serial(self, machine_id: int, serial: str) -> None:
+        result = self.execute(
+            machine.update(machine.c.id == machine_id).values(keychip=serial)
+        )
+        if result is None:
+            self.logger.error(
+                f"Failed to update serial for machine {machine_id} -> {serial}"
+            )
+        return result.lastrowid
+
+    def set_machine_boardid(self, machine_id: int, boardid: str) -> None:
+        result = self.execute(
+            machine.update(machine.c.id == machine_id).values(board=boardid)
+        )
+        if result is None:
+            self.logger.error(
+                f"Failed to update board id for machine {machine_id} -> {boardid}"
+            )
+
+    def get_arcade(self, id: int) -> Optional[Dict]:
+        sql = arcade.select(arcade.c.id == id)
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def put_arcade(
+        self,
+        name: str,
+        nickname: str = None,
+        country: str = "JPN",
+        country_id: int = 1,
+        state: str = "",
+        city: str = "",
+        regional_id: int = 1,
+    ) -> Optional[int]:
+        if nickname is None:
+            nickname = name
+
+        sql = arcade.insert().values(
+            name=name,
+            nickname=nickname,
+            country=country,
+            country_id=country_id,
+            state=state,
+            city=city,
+            regional_id=regional_id,
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def get_arcade_owners(self, arcade_id: int) -> Optional[Dict]:
+        sql = select(arcade_owner).where(arcade_owner.c.arcade == arcade_id)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def add_arcade_owner(self, arcade_id: int, user_id: int) -> None:
+        sql = insert(arcade_owner).values(arcade=arcade_id, user=user_id)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def format_serial(
+        self, platform_code: str, platform_rev: int, serial_num: int, append: int = 4152
+    ) -> str:
+        return f"{platform_code}{platform_rev:02d}A{serial_num:04d}{append:04d}"  # 0x41 = A, 0x52 = R
+
+    def validate_keychip_format(self, serial: str) -> bool:
+        serial = serial.replace("-", "")
+        if len(serial) != 11 or len(serial) != 15:
+            self.logger.error(
+                f"Serial validate failed: Incorrect length for {serial} (len {len(serial)})"
+            )
+            return False
+
+        platform_code = serial[:4]
+        platform_rev = serial[4:6]
+        const_a = serial[6]
+        num = serial[7:11]
+        append = serial[11:15]
+
+        if re.match("A[7|6]\d[E|X][0|1][0|1|2]A\d{4,8}", serial) is None:
+            self.logger.error(f"Serial validate failed: {serial} failed regex")
+            return False
+
+        if len(append) != 0 or len(append) != 4:
+            self.logger.error(
+                f"Serial validate failed: {serial} had malformed append {append}"
+            )
+            return False
+
+        if len(num) != 4:
+            self.logger.error(
+                f"Serial validate failed: {serial} had malformed number {num}"
+            )
+            return False
+
+        return True

core/data/schema/base.py

@@ -2,6 +2,7 @@ import json
 import logging
 from random import randrange
 from typing import Any, Optional, Dict, List
+from sqlalchemy.engine import Row
 from sqlalchemy.engine.cursor import CursorResult
 from sqlalchemy.engine.base import Connection
 from sqlalchemy.sql import text, func, select
@@ -19,7 +20,7 @@ schema_ver = Table(
     metadata,
     Column("game", String(4), primary_key=True, nullable=False),
     Column("version", Integer, nullable=False, server_default="1"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 event_log = Table(
@@ -29,18 +30,20 @@ event_log = Table(
     Column("system", String(255), nullable=False),
     Column("type", String(255), nullable=False),
     Column("severity", Integer, nullable=False),
+    Column("message", String(1000), nullable=False),
     Column("details", JSON, nullable=False),
     Column("when_logged", TIMESTAMP, nullable=False, server_default=func.now()),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
-class BaseData():
+
+class BaseData:
     def __init__(self, cfg: CoreConfig, conn: Connection) -> None:
         self.config = cfg
         self.conn = conn
         self.logger = logging.getLogger("database")
-    
-    def execute(self, sql: str, opts: Dict[str, Any]={}) -> Optional[CursorResult]:
+
+    def execute(self, sql: str, opts: Dict[str, Any] = {}) -> Optional[CursorResult]:
         res = None
 
         try:
@@ -50,7 +53,7 @@ class BaseData():
         except SQLAlchemyError as e:
             self.logger.error(f"SQLAlchemy error {e}")
             return None
-        
+
         except UnicodeEncodeError as e:
             self.logger.error(f"UnicodeEncodeError error {e}")
             return None
@@ -62,7 +65,7 @@ class BaseData():
             except SQLAlchemyError as e:
                 self.logger.error(f"SQLAlchemy error {e}")
                 return None
-            
+
             except UnicodeEncodeError as e:
                 self.logger.error(f"UnicodeEncodeError error {e}")
                 return None
@@ -72,53 +75,79 @@ class BaseData():
                 raise
 
         return res
-    
+
     def generate_id(self) -> int:
         """
         Generate a random 5-7 digit id
         """
         return randrange(10000, 9999999)
     
+    def get_all_schema_vers(self) -> Optional[List[Row]]:
+        sql = select(schema_ver)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
     def get_schema_ver(self, game: str) -> Optional[int]:
         sql = select(schema_ver).where(schema_ver.c.game == game)
 
         result = self.execute(sql)
         if result is None:
             return None
-        return result.fetchone()["version"]
-    
+
+        row = result.fetchone()
+        if row is None:
+            return None
+
+        return row["version"]
+
     def set_schema_ver(self, ver: int, game: str = "CORE") -> Optional[int]:
-        sql = insert(schema_ver).values(game = game, version = ver)
-        conflict = sql.on_duplicate_key_update(version = ver)
-        
+        sql = insert(schema_ver).values(game=game, version=ver)
+        conflict = sql.on_duplicate_key_update(version=ver)
+
         result = self.execute(conflict)
         if result is None:
-            self.logger.error(f"Failed to update schema version for game {game} (v{ver})")
+            self.logger.error(
+                f"Failed to update schema version for game {game} (v{ver})"
+            )
             return None
         return result.lastrowid
 
-    def log_event(self, system: str, type: str, severity: int, details: Dict) -> Optional[int]:
-        sql = event_log.insert().values(system = system, type = type, severity = severity, details = json.dumps(details))
+    def log_event(
+        self, system: str, type: str, severity: int, message: str, details: Dict = {}
+    ) -> Optional[int]:
+        sql = event_log.insert().values(
+            system=system,
+            type=type,
+            severity=severity,
+            message=message,
+            details=json.dumps(details),
+        )
         result = self.execute(sql)
 
         if result is None:
-            self.logger.error(f"{__name__}: Failed to insert event into event log! system = {system}, type = {type}, severity = {severity}, details = {details}")
+            self.logger.error(
+                f"{__name__}: Failed to insert event into event log! system = {system}, type = {type}, severity = {severity}, message = {message}"
+            )
             return None
 
         return result.lastrowid
-    
+
     def get_event_log(self, entries: int = 100) -> Optional[List[Dict]]:
         sql = event_log.select().limit(entries).all()
         result = self.execute(sql)
 
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def fix_bools(self, data: Dict) -> Dict:
-        for k,v in data.items():
+        for k, v in data.items():
             if type(v) == str and v.lower() == "true":
                 data[k] = True
             elif type(v) == str and v.lower() == "false":
                 data[k] = False
-        
+
         return data

core/data/schema/card.py

@@ -3,55 +3,92 @@ from sqlalchemy import Table, Column, UniqueConstraint
 from sqlalchemy.types import Integer, String, Boolean, TIMESTAMP
 from sqlalchemy.sql.schema import ForeignKey
 from sqlalchemy.sql import func
+from sqlalchemy.engine import Row
 
 from core.data.schema.base import BaseData, metadata
 
 aime_card = Table(
-    'aime_card',
+    "aime_card",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("access_code", String(20)),
     Column("created_date", TIMESTAMP, server_default=func.now()),
     Column("last_login_date", TIMESTAMP, onupdate=func.now()),
     Column("is_locked", Boolean, server_default="0"),
     Column("is_banned", Boolean, server_default="0"),
     UniqueConstraint("user", "access_code", name="aime_card_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class CardData(BaseData):
+    def get_card_by_access_code(self, access_code: str) -> Optional[Row]:
+        sql = aime_card.select(aime_card.c.access_code == access_code)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def get_card_by_id(self, card_id: int) -> Optional[Row]:
+        sql = aime_card.select(aime_card.c.id == card_id)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def update_access_code(self, old_ac: str, new_ac: str) -> None:
+        sql = aime_card.update(aime_card.c.access_code == old_ac).values(
+            access_code=new_ac
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(
+                f"Failed to change card access code from {old_ac} to {new_ac}"
+            )
+
     def get_user_id_from_card(self, access_code: str) -> Optional[int]:
         """
         Given a 20 digit access code as a string, get the user id associated with that card
         """
-        sql = aime_card.select(aime_card.c.access_code == access_code)
-
-        result = self.execute(sql)
-        if result is None: return None 
-
-        card = result.fetchone()
-        if card is None: return None
+        card = self.get_card_by_access_code(access_code)
+        if card is None:
+            return None
 
         return int(card["user"])
 
-    def get_user_cards(self, aime_id: int) -> Optional[List[Dict]]:
+    def delete_card(self, card_id: int) -> None:
+        sql = aime_card.delete(aime_card.c.id == card_id)
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to delete card with id {card_id}")
+
+    def get_user_cards(self, aime_id: int) -> Optional[List[Row]]:
         """
         Returns all cards owned by a user
         """
         sql = aime_card.select(aime_card.c.user == aime_id)
         result = self.execute(sql)
-        if result is None: return None        
+        if result is None:
+            return None
         return result.fetchall()
 
-    
     def create_card(self, user_id: int, access_code: str) -> Optional[int]:
         """
         Given a aime_user id and a 20 digit access code as a string, create a card and return the ID if successful
         """
         sql = aime_card.insert().values(user=user_id, access_code=access_code)
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def to_access_code(self, luid: str) -> str:
@@ -64,4 +101,4 @@ class CardData(BaseData):
         """
         Given a 20 digit access code as a string, return the 16 hex character luid
         """
-        return f'{int(access_code):0{16}x}'
+        return f"{int(access_code):0{16}x}"

core/data/schema/user.py

@@ -1,9 +1,12 @@
 from enum import Enum
-from typing import Dict, Optional
+from typing import Optional, List
 from sqlalchemy import Table, Column
 from sqlalchemy.types import Integer, String, TIMESTAMP
-from sqlalchemy.sql.schema import ForeignKey
 from sqlalchemy.sql import func
+from sqlalchemy.dialects.mysql import insert
+from sqlalchemy.sql import func, select
+from sqlalchemy.engine import Row
+import bcrypt
 
 from core.data.schema.base import BaseData, metadata
 
@@ -14,44 +17,90 @@ aime_user = Table(
     Column("username", String(25), unique=True),
     Column("email", String(255), unique=True),
     Column("password", String(255)),
-    Column("permissions", Integer),    
+    Column("permissions", Integer),
     Column("created_date", TIMESTAMP, server_default=func.now()),
     Column("last_login_date", TIMESTAMP, onupdate=func.now()),
     Column("suspend_expire_time", TIMESTAMP),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
-frontend_session = Table(
-    "frontend_session",
-    metadata,
-    Column("id", Integer, primary_key=True, unique=True),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
-    Column('session_cookie', String(32), nullable=False, unique=True),
-    Column("expires", TIMESTAMP, nullable=False),
-    mysql_charset='utf8mb4'
-)
 
 class PermissionBits(Enum):
     PermUser = 1
     PermMod = 2
     PermSysAdmin = 4
 
+
 class UserData(BaseData):
-    def create_user(self, username: str = None, email: str = None, password: str = None) -> Optional[int]:
-
-        if email is None:
-            permission = None
+    def create_user(
+        self,
+        id: int = None,
+        username: str = None,
+        email: str = None,
+        password: str = None,
+        permission: int = 1,
+    ) -> Optional[int]:
+        if id is None:
+            sql = insert(aime_user).values(
+                username=username,
+                email=email,
+                password=password,
+                permissions=permission,
+            )
         else:
-            permission = 0
+            sql = insert(aime_user).values(
+                id=id,
+                username=username,
+                email=email,
+                password=password,
+                permissions=permission,
+            )
 
-        sql = aime_user.insert().values(username=username, email=email, password=password, permissions=permission)
-        
-        result = self.execute(sql)
-        if result is None: return None
+        conflict = sql.on_duplicate_key_update(
+            username=username, email=email, password=password, permissions=permission
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
         return result.lastrowid
-    
+
+    def get_user(self, user_id: int) -> Optional[Row]:
+        sql = select(aime_user).where(aime_user.c.id == user_id)
+        result = self.execute(sql)
+        if result is None:
+            return False
+        return result.fetchone()
+
+    def check_password(self, user_id: int, passwd: bytes = None) -> bool:
+        usr = self.get_user(user_id)
+        if usr is None:
+            return False
+
+        if usr["password"] is None:
+            return False
+
+        return bcrypt.checkpw(passwd, usr["password"].encode())
+
     def reset_autoincrement(self, ai_value: int) -> None:
-        # Didn't feel like learning how to do this the right way
-        # if somebody wants a free PR go nuts I guess
+        # ALTER TABLE isn't in sqlalchemy so we do this the ugly way
         sql = f"ALTER TABLE aime_user AUTO_INCREMENT={ai_value}"
-        self.execute(sql)
+        self.execute(sql)
+
+    def delete_user(self, user_id: int) -> None:
+        sql = aime_user.delete(aime_user.c.id == user_id)
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.error(f"Failed to delete user with id {user_id}")
+
+    def get_unregistered_users(self) -> List[Row]:
+        """
+        Returns a list of users who have not registered with the webui. They may or may not have cards.
+        """
+        sql = select(aime_user).where(aime_user.c.password == None)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()

core/data/schema/versions/CORE_1_rollback.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `frontend_session`
+DROP COLUMN `ip`;

core/data/schema/versions/CORE_2_rollback.sql

@@ -0,0 +1 @@
+ALTER TABLE `event_log` DROP COLUMN `message`;

core/data/schema/versions/CORE_2_upgrade.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `frontend_session`
+ADD `ip` CHAR(15);

core/data/schema/versions/CORE_3_rollback.sql

@@ -0,0 +1,12 @@
+CREATE TABLE `frontend_session` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `user` int(11) NOT NULL,
+  `ip` varchar(15) DEFAULT NULL,
+  `session_cookie` varchar(32) NOT NULL,
+  `expires` timestamp NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp(),
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `id` (`id`),
+  UNIQUE KEY `session_cookie` (`session_cookie`),
+  KEY `user` (`user`),
+  CONSTRAINT `frontend_session_ibfk_1` FOREIGN KEY (`user`) REFERENCES `aime_user` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8mb4;

core/data/schema/versions/CORE_3_upgrade.sql

@@ -0,0 +1 @@
+ALTER TABLE `event_log` ADD COLUMN `message` VARCHAR(1000) NOT NULL AFTER `severity`;

core/data/schema/versions/CORE_4_upgrade.sql

@@ -0,0 +1 @@
+DROP TABLE `frontend_session`;

core/data/schema/versions/SBZV_1_rollback.sql

@@ -0,0 +1,9 @@
+SET FOREIGN_KEY_CHECKS=0;
+ALTER TABLE diva_score DROP FOREIGN KEY diva_score_ibfk_1;
+ALTER TABLE diva_score DROP CONSTRAINT diva_score_uk;
+ALTER TABLE diva_score ADD CONSTRAINT diva_score_uk UNIQUE (user, pv_id, difficulty);
+ALTER TABLE diva_score ADD CONSTRAINT diva_score_ibfk_1 FOREIGN KEY (user) REFERENCES aime_user(id) ON DELETE CASCADE;
+
+ALTER TABLE diva_score DROP COLUMN edition;
+ALTER TABLE diva_playlog DROP COLUMN edition;
+SET FOREIGN_KEY_CHECKS=1;

core/data/schema/versions/SBZV_2_rollback.sql

@@ -0,0 +1,17 @@
+ALTER TABLE diva_profile_shop DROP COLUMN c_itm_eqp_ary;
+ALTER TABLE diva_profile_shop DROP COLUMN ms_itm_flg_ary;
+
+ALTER TABLE diva_profile DROP COLUMN use_pv_mdl_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_mdl_pri;
+ALTER TABLE diva_profile DROP COLUMN use_pv_skn_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_btn_se_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_sld_se_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_chn_sld_se_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_sldr_tch_se_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_mdl_eqp VARCHAR(8) NOT NULL DEFAULT "true" AFTER sort_kind;
+ALTER TABLE diva_profile ADD COLUMN use_pv_btn_se_eqp VARCHAR(8) NOT NULL DEFAULT "true" AFTER use_pv_mdl_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_sld_se_eqp VARCHAR(8) NOT NULL DEFAULT "false" AFTER use_pv_btn_se_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_chn_sld_se_eqp VARCHAR(8) NOT NULL DEFAULT "false" AFTER use_pv_sld_se_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_sldr_tch_se_eqp VARCHAR(8) NOT NULL DEFAULT "false" AFTER use_pv_chn_sld_se_eqp;
+
+DROP TABLE IF EXISTS `diva_profile_pv_customize`;

core/data/schema/versions/SBZV_2_upgrade.sql

@@ -0,0 +1,9 @@
+SET FOREIGN_KEY_CHECKS=0;
+ALTER TABLE diva_score ADD COLUMN edition int(11) DEFAULT 0 AFTER difficulty;
+ALTER TABLE diva_playlog ADD COLUMN edition int(11) DEFAULT 0 AFTER difficulty;
+
+ALTER TABLE diva_score DROP FOREIGN KEY diva_score_ibfk_1;
+ALTER TABLE diva_score DROP CONSTRAINT diva_score_uk;
+ALTER TABLE diva_score ADD CONSTRAINT diva_score_uk UNIQUE (user, pv_id, difficulty, edition);
+ALTER TABLE diva_score ADD CONSTRAINT diva_score_ibfk_1 FOREIGN KEY (user) REFERENCES aime_user(id) ON DELETE CASCADE;
+SET FOREIGN_KEY_CHECKS=1;

core/data/schema/versions/SBZV_3_rollback.sql

@@ -0,0 +1,3 @@
+ALTER TABLE diva_profile DROP COLUMN passwd_stat;
+ALTER TABLE diva_profile DROP COLUMN passwd;
+ALTER TABLE diva_profile MODIFY player_name VARCHAR(8);

core/data/schema/versions/SBZV_3_upgrade.sql

@@ -0,0 +1,33 @@
+ALTER TABLE diva_profile_shop ADD COLUMN c_itm_eqp_ary varchar(59) DEFAULT "-999,-999,-999,-999,-999,-999,-999,-999,-999,-999,-999,-999";
+ALTER TABLE diva_profile_shop ADD COLUMN ms_itm_flg_ary varchar(59) DEFAULT "-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1";
+
+ALTER TABLE diva_profile DROP COLUMN use_pv_mdl_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_btn_se_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_sld_se_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_chn_sld_se_eqp;
+ALTER TABLE diva_profile DROP COLUMN use_pv_sldr_tch_se_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_mdl_eqp BOOLEAN NOT NULL DEFAULT true AFTER sort_kind;
+ALTER TABLE diva_profile ADD COLUMN use_mdl_pri BOOLEAN NOT NULL DEFAULT false AFTER use_pv_mdl_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_skn_eqp BOOLEAN NOT NULL DEFAULT false AFTER use_mdl_pri;
+ALTER TABLE diva_profile ADD COLUMN use_pv_btn_se_eqp BOOLEAN NOT NULL DEFAULT true AFTER use_pv_skn_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_sld_se_eqp BOOLEAN NOT NULL DEFAULT false AFTER use_pv_btn_se_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_chn_sld_se_eqp BOOLEAN NOT NULL DEFAULT false AFTER use_pv_sld_se_eqp;
+ALTER TABLE diva_profile ADD COLUMN use_pv_sldr_tch_se_eqp BOOLEAN NOT NULL DEFAULT false AFTER use_pv_chn_sld_se_eqp;
+
+
+CREATE TABLE diva_profile_pv_customize (
+    id INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
+    user INT NOT NULL,
+    version INT NOT NULL,
+    pv_id INT NOT NULL,
+    mdl_eqp_ary VARCHAR(14) DEFAULT '-999,-999,-999',
+    c_itm_eqp_ary VARCHAR(59) DEFAULT '-999,-999,-999,-999,-999,-999,-999,-999,-999,-999,-999,-999',
+    ms_itm_flg_ary VARCHAR(59) DEFAULT '-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1',
+    skin INT DEFAULT '-1',
+    btn_se INT DEFAULT '-1',
+    sld_se INT DEFAULT '-1',
+    chsld_se INT DEFAULT '-1',
+    sldtch_se INT DEFAULT '-1',
+    UNIQUE KEY diva_profile_pv_customize_uk (user, version, pv_id),
+    CONSTRAINT diva_profile_pv_customize_ibfk_1 FOREIGN KEY (user) REFERENCES aime_user (id) ON DELETE CASCADE ON UPDATE CASCADE
+);

core/data/schema/versions/SBZV_4_upgrade.sql

@@ -0,0 +1,3 @@
+ALTER TABLE diva_profile ADD COLUMN passwd_stat INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE diva_profile ADD COLUMN passwd VARCHAR(12) NOT NULL DEFAULT "**********";
+ALTER TABLE diva_profile MODIFY player_name VARCHAR(10);

core/data/schema/versions/SDBT_1_rollback.sql

@@ -0,0 +1 @@
+ALTER TABLE chuni_static_music CHANGE COLUMN worldsEndTag worldsEndTag VARCHAR(20) NULL DEFAULT NULL ;

core/data/schema/versions/SDBT_2_rollback.sql

@@ -0,0 +1 @@
+ALTER TABLE chuni_score_course DROP COLUMN theoryCount, DROP COLUMN orderId, DROP COLUMN playerRating;

core/data/schema/versions/SDBT_2_upgrade.sql

@@ -0,0 +1 @@
+ALTER TABLE chuni_static_music CHANGE COLUMN worldsEndTag worldsEndTag VARCHAR(7) NULL DEFAULT NULL ;

core/data/schema/versions/SDBT_3_upgrade.sql

@@ -0,0 +1 @@
+ALTER TABLE chuni_score_course ADD theoryCount int(11), ADD orderId int(11), ADD playerRating int(11);

core/data/schema/versions/SDDT_2_rollback.sql

@@ -0,0 +1,7 @@
+SET FOREIGN_KEY_CHECKS=0;
+ALTER TABLE ongeki_profile_data DROP COLUMN isDialogWatchedSuggestMemory;
+ALTER TABLE ongeki_score_best DROP COLUMN platinumScoreMax;
+ALTER TABLE ongeki_score_playlog DROP COLUMN platinumScore;
+ALTER TABLE ongeki_score_playlog DROP COLUMN platinumScoreMax;
+DROP TABLE IF EXISTS `ongeki_user_memorychapter`;
+SET FOREIGN_KEY_CHECKS=1;

core/data/schema/versions/SDDT_3_rollback.sql

@@ -0,0 +1 @@
+ALTER TABLE ongeki_profile_data DROP COLUMN lastEmoneyCredit;

core/data/schema/versions/SDDT_3_upgrade.sql

@@ -0,0 +1,27 @@
+SET FOREIGN_KEY_CHECKS=0;
+
+ALTER TABLE ongeki_profile_data ADD COLUMN isDialogWatchedSuggestMemory BOOLEAN;
+ALTER TABLE ongeki_score_best ADD COLUMN platinumScoreMax INTEGER;
+ALTER TABLE ongeki_score_playlog ADD COLUMN platinumScore INTEGER;
+ALTER TABLE ongeki_score_playlog ADD COLUMN platinumScoreMax INTEGER;
+
+CREATE TABLE ongeki_user_memorychapter (
+    id INT PRIMARY KEY NOT NULL AUTO_INCREMENT,
+    user INT NOT NULL,
+    chapterId INT NOT NULL,
+    gaugeId INT NOT NULL,
+    gaugeNum INT NOT NULL,
+    jewelCount INT NOT NULL,
+    isStoryWatched BOOLEAN NOT NULL,
+    isBossWatched BOOLEAN NOT NULL,
+    isDialogWatched BOOLEAN NOT NULL,
+    isEndingWatched BOOLEAN NOT NULL,
+    isClear BOOLEAN NOT NULL,
+    lastPlayMusicId INT NOT NULL,
+    lastPlayMusicLevel INT NOT NULL,
+    lastPlayMusicCategory INT NOT NULL,
+    UNIQUE KEY ongeki_user_memorychapter_uk (user, chapterId),
+    CONSTRAINT ongeki_user_memorychapter_ibfk_1 FOREIGN KEY (user) REFERENCES aime_user (id) ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+SET FOREIGN_KEY_CHECKS=1;

core/data/schema/versions/SDDT_4_upgrade.sql

@@ -0,0 +1 @@
+ALTER TABLE ongeki_profile_data ADD COLUMN lastEmoneyCredit INTEGER DEFAULT 0;

core/data/schema/versions/SDEZ_1_rollback.sql

@@ -0,0 +1,3 @@
+SET FOREIGN_KEY_CHECKS=0;
+ALTER TABLE mai2_playlog DROP COLUMN trialPlayAchievement;
+SET FOREIGN_KEY_CHECKS=1;

core/data/schema/versions/SDEZ_2_rollback.sql

@@ -0,0 +1,21 @@
+ALTER TABLE mai2_item_card
+CHANGE COLUMN cardId card_id INT NOT NULL AFTER user,
+CHANGE COLUMN cardTypeId card_kind INT NOT NULL,
+CHANGE COLUMN charaId chara_id INT NOT NULL,
+CHANGE COLUMN mapId map_id INT NOT NULL,
+CHANGE COLUMN startDate start_date TIMESTAMP NULL DEFAULT '2018-01-01 00:00:00',
+CHANGE COLUMN endDate end_date TIMESTAMP NULL DEFAULT '2038-01-01 00:00:00';
+
+ALTER TABLE mai2_item_item 
+CHANGE COLUMN itemId item_id INT NOT NULL AFTER user,
+CHANGE COLUMN itemKind item_kind INT NOT NULL,
+CHANGE COLUMN isValid is_valid TINYINT(1) NOT NULL DEFAULT '1';
+
+ALTER TABLE mai2_item_character 
+CHANGE COLUMN characterId character_id INT NOT NULL,
+CHANGE COLUMN useCount use_count INT NOT NULL DEFAULT '0';
+
+ALTER TABLE mai2_item_charge 
+CHANGE COLUMN chargeId charge_id INT NOT NULL,
+CHANGE COLUMN purchaseDate purchase_date TIMESTAMP NOT NULL,
+CHANGE COLUMN validDate valid_date TIMESTAMP NOT NULL;

core/data/schema/versions/SDEZ_2_upgrade.sql

@@ -0,0 +1,3 @@
+SET FOREIGN_KEY_CHECKS=0;
+ALTER TABLE mai2_playlog ADD trialPlayAchievement INT NULL;
+SET FOREIGN_KEY_CHECKS=1;

core/data/schema/versions/SDEZ_3_rollback.sql

@@ -0,0 +1,31 @@
+ALTER TABLE mai2_profile_option
+DROP COLUMN tapSe;
+
+ALTER TABLE mai2_score_best
+DROP COLUMN extNum1;
+
+ALTER TABLE mai2_profile_extend
+DROP COLUMN playStatusSetting;
+
+ALTER TABLE mai2_playlog
+DROP COLUMN extNum4;
+
+ALTER TABLE mai2_static_event
+DROP COLUMN startDate;
+
+ALTER TABLE mai2_item_map
+CHANGE COLUMN mapId map_id INT NOT NULL,
+CHANGE COLUMN isLock is_lock BOOLEAN NOT NULL DEFAULT 0,
+CHANGE COLUMN isClear is_clear BOOLEAN NOT NULL DEFAULT 0,
+CHANGE COLUMN isComplete is_complete BOOLEAN NOT NULL DEFAULT 0;
+
+ALTER TABLE mai2_item_friend_season_ranking
+CHANGE COLUMN seasonId season_id INT NOT NULL,
+CHANGE COLUMN rewardGet reward_get BOOLEAN NOT NULL,
+CHANGE COLUMN userName user_name VARCHAR(8) NOT NULL,
+CHANGE COLUMN recordDate record_date VARCHAR(255) NOT NULL;
+
+ALTER TABLE mai2_item_login_bonus
+CHANGE COLUMN bonusId bonus_id INT NOT NULL,
+CHANGE COLUMN isCurrent is_current BOOLEAN NOT NULL DEFAULT 0,
+CHANGE COLUMN isComplete is_complete BOOLEAN NOT NULL DEFAULT 0;

core/data/schema/versions/SDEZ_3_upgrade.sql

@@ -0,0 +1,21 @@
+ALTER TABLE mai2_item_card
+CHANGE COLUMN card_id cardId INT NOT NULL AFTER user,
+CHANGE COLUMN card_kind cardTypeId INT NOT NULL,
+CHANGE COLUMN chara_id charaId INT NOT NULL,
+CHANGE COLUMN map_id mapId INT NOT NULL,
+CHANGE COLUMN start_date startDate TIMESTAMP NULL DEFAULT '2018-01-01 00:00:00',
+CHANGE COLUMN end_date endDate TIMESTAMP NULL DEFAULT '2038-01-01 00:00:00';
+
+ALTER TABLE mai2_item_item 
+CHANGE COLUMN item_id itemId INT NOT NULL AFTER user,
+CHANGE COLUMN item_kind itemKind INT NOT NULL,
+CHANGE COLUMN is_valid isValid TINYINT(1) NOT NULL DEFAULT '1';
+
+ALTER TABLE mai2_item_character 
+CHANGE COLUMN character_id characterId INT NOT NULL,
+CHANGE COLUMN use_count useCount INT NOT NULL DEFAULT '0';
+
+ALTER TABLE mai2_item_charge 
+CHANGE COLUMN charge_id chargeId INT NOT NULL,
+CHANGE COLUMN purchase_date purchaseDate TIMESTAMP NOT NULL,
+CHANGE COLUMN valid_date validDate TIMESTAMP NOT NULL;

core/data/schema/versions/SDEZ_4_upgrade.sql

@@ -0,0 +1,31 @@
+ALTER TABLE mai2_profile_option
+ADD COLUMN tapSe INT NOT NULL DEFAULT 0 AFTER tapDesign;
+
+ALTER TABLE mai2_score_best
+ADD COLUMN extNum1 INT NOT NULL DEFAULT 0;
+
+ALTER TABLE mai2_profile_extend
+ADD COLUMN playStatusSetting INT NOT NULL DEFAULT 0;
+
+ALTER TABLE mai2_playlog
+ADD COLUMN extNum4 INT NOT NULL DEFAULT 0;
+
+ALTER TABLE mai2_static_event
+ADD COLUMN startDate TIMESTAMP NOT NULL DEFAULT current_timestamp();
+
+ALTER TABLE mai2_item_map
+CHANGE COLUMN map_id mapId INT NOT NULL,
+CHANGE COLUMN is_lock isLock BOOLEAN NOT NULL DEFAULT 0,
+CHANGE COLUMN is_clear isClear BOOLEAN NOT NULL DEFAULT 0,
+CHANGE COLUMN is_complete isComplete BOOLEAN NOT NULL DEFAULT 0;
+
+ALTER TABLE mai2_item_friend_season_ranking
+CHANGE COLUMN season_id seasonId INT NOT NULL,
+CHANGE COLUMN reward_get rewardGet BOOLEAN NOT NULL,
+CHANGE COLUMN user_name userName VARCHAR(8) NOT NULL,
+CHANGE COLUMN record_date recordDate TIMESTAMP NOT NULL;
+
+ALTER TABLE mai2_item_login_bonus
+CHANGE COLUMN bonus_id bonusId INT NOT NULL,
+CHANGE COLUMN is_current isCurrent BOOLEAN NOT NULL DEFAULT 0,
+CHANGE COLUMN is_complete isComplete BOOLEAN NOT NULL DEFAULT 0;

core/frontend.py

@@ -0,0 +1,243 @@
+import logging, coloredlogs
+from typing import Any, Dict, List
+from twisted.web import resource
+from twisted.web.util import redirectTo
+from twisted.web.http import Request
+from logging.handlers import TimedRotatingFileHandler
+from twisted.web.server import Session
+from zope.interface import Interface, Attribute, implementer
+from twisted.python.components import registerAdapter
+import jinja2
+import bcrypt
+
+from core import CoreConfig, Utils
+from core.data import Data
+
+
+class IUserSession(Interface):
+    userId = Attribute("User's ID")
+    current_ip = Attribute("User's current ip address")
+    permissions = Attribute("User's permission level")
+
+
+@implementer(IUserSession)
+class UserSession(object):
+    def __init__(self, session):
+        self.userId = 0
+        self.current_ip = "0.0.0.0"
+        self.permissions = 0
+
+
+class FrontendServlet(resource.Resource):
+    def getChild(self, name: bytes, request: Request):
+        self.logger.debug(f"{Utils.get_ip_addr(request)} -> {name.decode()}")
+        if name == b"":
+            return self
+        return resource.Resource.getChild(self, name, request)
+
+    def __init__(self, cfg: CoreConfig, config_dir: str) -> None:
+        self.config = cfg
+        log_fmt_str = "[%(asctime)s] Frontend | %(levelname)s | %(message)s"
+        log_fmt = logging.Formatter(log_fmt_str)
+        self.logger = logging.getLogger("frontend")
+        self.environment = jinja2.Environment(loader=jinja2.FileSystemLoader("."))
+        self.game_list: List[Dict[str, str]] = []
+        self.children: Dict[str, Any] = {}
+
+        fileHandler = TimedRotatingFileHandler(
+            "{0}/{1}.log".format(self.config.server.log_dir, "frontend"),
+            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(cfg.frontend.loglevel)
+        coloredlogs.install(
+            level=cfg.frontend.loglevel, logger=self.logger, fmt=log_fmt_str
+        )
+        registerAdapter(UserSession, Session, IUserSession)
+
+        fe_game = FE_Game(cfg, self.environment)
+        games = Utils.get_all_titles()
+        for game_dir, game_mod in games.items():
+            if hasattr(game_mod, "frontend"):
+                try:
+                    game_fe = game_mod.frontend(cfg, self.environment, config_dir)
+                    self.game_list.append({"url": game_dir, "name": game_fe.nav_name})
+                    fe_game.putChild(game_dir.encode(), game_fe)
+                except:
+                    raise
+
+        self.environment.globals["game_list"] = self.game_list
+        self.putChild(b"gate", FE_Gate(cfg, self.environment))
+        self.putChild(b"user", FE_User(cfg, self.environment))
+        self.putChild(b"game", fe_game)
+
+        self.logger.info(
+            f"Ready on port {self.config.frontend.port} serving {len(fe_game.children)} games"
+        )
+
+    def render_GET(self, request):
+        self.logger.debug(f"{Utils.get_ip_addr(request)} -> {request.uri.decode()}")
+        template = self.environment.get_template("core/frontend/index.jinja")
+        return template.render(
+            server_name=self.config.server.name,
+            title=self.config.server.name,
+            game_list=self.game_list,
+            sesh=vars(IUserSession(request.getSession())),
+        ).encode("utf-16")
+
+
+class FE_Base(resource.Resource):
+    """
+    A Generic skeleton class that all frontend handlers should inherit from
+    Initializes the environment, data, logger, config, and sets isLeaf to true
+    It is expected that game implementations of this class overwrite many of these
+    """
+
+    isLeaf = True
+
+    def __init__(self, cfg: CoreConfig, environment: jinja2.Environment) -> None:
+        self.core_config = cfg
+        self.data = Data(cfg)
+        self.logger = logging.getLogger("frontend")
+        self.environment = environment
+        self.nav_name = "nav_name"
+
+
+class FE_Gate(FE_Base):
+    def render_GET(self, request: Request):
+        self.logger.debug(f"{Utils.get_ip_addr(request)} -> {request.uri.decode()}")
+        uri: str = request.uri.decode()
+
+        sesh = request.getSession()
+        usr_sesh = IUserSession(sesh)
+        if usr_sesh.userId > 0:
+            return redirectTo(b"/user", request)
+
+        if uri.startswith("/gate/create"):
+            return self.create_user(request)
+
+        if b"e" in request.args:
+            try:
+                err = int(request.args[b"e"][0].decode())
+            except:
+                err = 0
+
+        else:
+            err = 0
+
+        template = self.environment.get_template("core/frontend/gate/gate.jinja")
+        return template.render(
+            title=f"{self.core_config.server.name} | Login Gate",
+            error=err,
+            sesh=vars(usr_sesh),
+        ).encode("utf-16")
+
+    def render_POST(self, request: Request):
+        uri = request.uri.decode()
+        ip = Utils.get_ip_addr(request)
+
+        if uri == "/gate/gate.login":
+            access_code: str = request.args[b"access_code"][0].decode()
+            passwd: bytes = request.args[b"passwd"][0]
+            if passwd == b"":
+                passwd = None
+
+            uid = self.data.card.get_user_id_from_card(access_code)
+            if uid is None:
+                return redirectTo(b"/gate?e=1", request)
+
+            if passwd is None:
+                sesh = self.data.user.check_password(uid)
+
+                if sesh is not None:
+                    return redirectTo(
+                        f"/gate/create?ac={access_code}".encode(), request
+                    )
+                return redirectTo(b"/gate?e=1", request)
+
+            if not self.data.user.check_password(uid, passwd):
+                return redirectTo(b"/gate?e=1", request)
+
+            self.logger.info(f"Successful login of user {uid} at {ip}")
+
+            sesh = request.getSession()
+            usr_sesh = IUserSession(sesh)
+            usr_sesh.userId = uid
+            usr_sesh.current_ip = ip
+
+            return redirectTo(b"/user", request)
+
+        elif uri == "/gate/gate.create":
+            access_code: str = request.args[b"access_code"][0].decode()
+            username: str = request.args[b"username"][0]
+            email: str = request.args[b"email"][0].decode()
+            passwd: str = request.args[b"passwd"][0]
+
+            uid = self.data.card.get_user_id_from_card(access_code)
+            if uid is None:
+                return redirectTo(b"/gate?e=1", request)
+
+            salt = bcrypt.gensalt()
+            hashed = bcrypt.hashpw(passwd, salt)
+
+            result = self.data.user.create_user(
+                uid, username, email, hashed.decode(), 1
+            )
+            if result is None:
+                return redirectTo(b"/gate?e=3", request)
+
+            if not self.data.user.check_password(uid, passwd.encode()):
+                return redirectTo(b"/gate", request)
+
+            return redirectTo(b"/user", request)
+
+        else:
+            return b""
+
+    def create_user(self, request: Request):
+        if b"ac" not in request.args or len(request.args[b"ac"][0].decode()) != 20:
+            return redirectTo(b"/gate?e=2", request)
+
+        ac = request.args[b"ac"][0].decode()
+
+        template = self.environment.get_template("core/frontend/gate/create.jinja")
+        return template.render(
+            title=f"{self.core_config.server.name} | Create User",
+            code=ac,
+            sesh={"userId": 0},
+        ).encode("utf-16")
+
+
+class FE_User(FE_Base):
+    def render_GET(self, request: Request):
+        template = self.environment.get_template("core/frontend/user/index.jinja")
+
+        sesh: Session = request.getSession()
+        usr_sesh = IUserSession(sesh)
+        if usr_sesh.userId == 0:
+            return redirectTo(b"/gate", request)
+
+        return template.render(
+            title=f"{self.core_config.server.name} | Account", sesh=vars(usr_sesh)
+        ).encode("utf-16")
+
+
+class FE_Game(FE_Base):
+    isLeaf = False
+    children: Dict[str, Any] = {}
+
+    def getChild(self, name: bytes, request: Request):
+        if name == b"":
+            return self
+        return resource.Resource.getChild(self, name, request)
+
+    def render_GET(self, request: Request) -> bytes:
+        return redirectTo(b"/user", request)

core/frontend/gate/create.jinja

@@ -0,0 +1,24 @@
+{% extends "core/frontend/index.jinja" %}
+{% block content %}
+<h1>Create User</h1>
+<form id="create" style="max-width: 240px; min-width: 10%;" action="/gate/gate.create" method="post">
+    <div class="form-group row">
+        <label for="access_code">Card Access Code</label><br>
+        <input class="form-control" name="access_code" id="access_code" type="text" placeholder="00000000000000000000" value={{ code }} maxlength="20" readonly>
+    </div>
+    <div class="form-group row">
+        <label for="username">Username</label><br>
+        <input id="username" class="form-control" name="username" type="text" placeholder="username">
+    </div>
+    <div class="form-group row">
+        <label for="email">Email</label><br>
+        <input id="email" class="form-control" name="email" type="email" placeholder="example@example.com">
+    </div>
+    <div class="form-group row">
+        <label for="passwd">Password</label><br>
+        <input id="passwd" class="form-control" name="passwd" type="password" placeholder="password">
+    </div>
+    <p></p>
+    <input id="submit" class="btn btn-primary" style="display: block; margin: 0 auto;" type="submit" value="Create">
+</form>
+{% endblock content %}

core/frontend/gate/gate.jinja

@@ -0,0 +1,32 @@
+{% extends "core/frontend/index.jinja" %}
+{% block content %}
+<h1>Gate</h1>
+{% include "core/frontend/widgets/err_banner.jinja" %}
+<style>
+    /* Chrome, Safari, Edge, Opera */
+    input::-webkit-outer-spin-button,
+    input::-webkit-inner-spin-button {
+        -webkit-appearance: none;
+        margin: 0;
+    }
+
+    /* Firefox */
+    input[type=number] {
+        -moz-appearance: textfield;
+    }
+</style>
+<form id="login" style="max-width: 240px; min-width: 10%;" action="/gate/gate.login" method="post">
+    <div class="form-group row">
+        <label for="access_code">Card Access Code</label><br>
+        <input form="login" class="form-control" name="access_code" id="access_code" type="number" placeholder="00000000000000000000" maxlength="20" required>
+    </div>
+    <div class="form-group row">
+        <label for="passwd">Password</label><br>
+        <input id="passwd" class="form-control" name="passwd" type="password" placeholder="password">
+    </div>
+    <p></p>
+    <input id="submit" class="btn btn-primary" style="display: block; margin: 0 auto;" form="login" type="submit" value="Login">
+</form>
+<h6>*To register for the webui, type in the access code of your card, as shown in a game, and leave the password field blank.</h6>
+<h6>*If you have not registered a card with this server, you cannot create a webui account.</h6>
+{% endblock content %}

core/frontend/index.jinja

@@ -0,0 +1,88 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>{{ title }}</title>
+        <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
+        <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>
+        <style>
+            html {
+                background-color: #181a1b !important;
+                margin: 10px;
+            }
+            html {
+                color-scheme: dark !important;
+            }
+            html, body, input, textarea, select, button, dialog {
+                background-color: #181a1b;
+            }
+            html, body, input, textarea, select, button {
+                border-color: #736b5e;
+                color: #e8e6e3;
+            }
+            a {
+                color: #3391ff;
+            }
+            table {
+                border-color: #545b5e;
+            }
+            ::placeholder {
+                color: #b2aba1;
+            }
+            input:-webkit-autofill,
+            textarea:-webkit-autofill,
+            select:-webkit-autofill {
+                background-color: #404400 !important;
+                color: #e8e6e3 !important;
+            }
+            ::-webkit-scrollbar {
+                background-color: #202324;
+                color: #aba499;
+            }
+            ::-webkit-scrollbar-thumb {
+                background-color: #454a4d;
+            }
+            ::-webkit-scrollbar-thumb:hover {
+                background-color: #575e62;
+            }
+            ::-webkit-scrollbar-thumb:active {
+                background-color: #484e51;
+            }
+            ::-webkit-scrollbar-corner {
+                background-color: #181a1b;
+            }
+            * {
+                scrollbar-color: #454a4d #202324;
+            }
+            ::selection {
+                background-color: #004daa !important;
+                color: #e8e6e3 !important;
+            }
+            ::-moz-selection {
+                background-color: #004daa !important;
+                color: #e8e6e3 !important;
+            }
+            input[type="text"], input[type="text"]:focus, input[type="password"], input[type="password"]:focus, input[type="email"], input[type="email"]:focus {
+                background-color: #202324 !important;
+                color: #e8e6e3;
+            }
+            form {
+                outline: 1px solid grey; 
+                padding: 20px;
+                padding-top: 10px;
+                padding-bottom: 10px;
+            }
+            .err-banner {
+                background-color: #AA0000;
+                padding: 20px;
+                margin-bottom: 10px;
+                width: 15%;
+            }
+        </style>
+    </head>
+    <body>
+    {% include "core/frontend/widgets/topbar.jinja" %}
+    {% block content %}
+    <h1>{{ server_name }}</h1>
+    {% endblock content %}
+    </body>
+</html>

core/frontend/user/index.jinja

@@ -0,0 +1,4 @@
+{% extends "core/frontend/index.jinja" %}
+{% block content %}
+<h1>testing</h1>
+{% endblock content %}

core/frontend/widgets/err_banner.jinja

@@ -0,0 +1,14 @@
+{% if error > 0 %}
+<div class="err-banner">
+<h3>Error</h3>
+{% if error == 1 %}
+Card not registered, or wrong password
+{% elif error == 2 %}
+Missing or malformed access code
+{% elif error == 3 %}
+Failed to create user
+{% else %}
+An unknown error occoured
+{% endif %}
+</div>
+{% endif %}

core/frontend/widgets/topbar.jinja

@@ -0,0 +1,18 @@
+<div style="background: #333; color: #f9f9f9; width: 10%; height: 50px; line-height: 50px; text-align: center; float: left;">
+    Navigation
+</div>
+<div style="background: #333; color: #f9f9f9; width: 80%; height: 50px; line-height: 50px; padding-left: 10px; float: left;">
+    <a href=/><button class="btn btn-primary">Home</button></a>&nbsp;
+    {% for game in game_list %}    
+    <a href=game/{{ game.url }}><button class="btn btn-success">{{ game.name }}</button></a>&nbsp;
+    {% endfor %}
+</div>
+</div>
+<div style="background: #333; color: #f9f9f9; width: 10%; height: 50px; line-height: 50px; text-align: center; float: left;">
+    {% if sesh is defined and sesh["userId"] > 0 %}
+    <a href="/user"><button class="btn btn-primary">Account</button></a>
+    {% else %}
+    <a href="/gate"><button class="btn btn-primary">Gate</button></a>
+    {% endif %}
+    
+</div>

core/mucha.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 import logging, coloredlogs
 from logging.handlers import TimedRotatingFileHandler
 from twisted.web import resource
@@ -6,65 +6,117 @@ from twisted.web.http import Request
 from datetime import datetime
 import pytz
 
-from core.config import CoreConfig
+from core import CoreConfig
+from core.utils import Utils
+
 
 class MuchaServlet:
-    def __init__(self, cfg: CoreConfig) -> None:        
+    def __init__(self, cfg: CoreConfig, cfg_dir: str) -> None:
         self.config = cfg
+        self.config_dir = cfg_dir
+        self.mucha_registry: List[str] = []
 
-        self.logger = logging.getLogger('mucha')
+        self.logger = logging.getLogger("mucha")
         log_fmt_str = "[%(asctime)s] Mucha | %(levelname)s | %(message)s"
         log_fmt = logging.Formatter(log_fmt_str)
-        
-        fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.config.server.log_dir, "mucha"), when="d", backupCount=10)
+
+        fileHandler = TimedRotatingFileHandler(
+            "{0}/{1}.log".format(self.config.server.log_dir, "mucha"),
+            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(logging.INFO)
         coloredlogs.install(level=logging.INFO, logger=self.logger, fmt=log_fmt_str)
 
-    def handle_boardauth(self, request: Request) -> bytes:
+        all_titles = Utils.get_all_titles()
+
+        for _, mod in all_titles.items():
+            if hasattr(mod, "index") and hasattr(mod.index, "get_mucha_info"):
+                enabled, game_cd = mod.index.get_mucha_info(
+                    self.config, self.config_dir
+                )
+                if enabled:
+                    self.mucha_registry.append(game_cd)
+
+        self.logger.info(
+            f"Serving {len(self.mucha_registry)} games"
+        )
+
+    def handle_boardauth(self, request: Request, _: Dict) -> bytes:
         req_dict = self.mucha_preprocess(request.content.getvalue())
+        client_ip = Utils.get_ip_addr(request)
+
         if req_dict is None:
-            self.logger.error(f"Error processing mucha request {request.content.getvalue()}")
+            self.logger.error(
+                f"Error processing mucha request {request.content.getvalue()}"
+            )
             return b""
 
         req = MuchaAuthRequest(req_dict)
-        self.logger.info(f"Mucha request {vars(req)}")
-        resp = MuchaAuthResponse(mucha_url=f"{self.config.mucha.hostname}:{self.config.mucha.port}")
-        self.logger.info(f"Mucha response {vars(resp)}")
+        self.logger.debug(f"Mucha request {vars(req)}")
+        self.logger.info(
+            f"Boardauth request from {client_ip} for {req.gameVer}"
+        )
+
+        if req.gameCd not in self.mucha_registry:
+            self.logger.warn(f"Unknown gameCd {req.gameCd}")
+            return b""
+
+        # TODO: Decrypt S/N
+
+        resp = MuchaAuthResponse(
+            f"{self.config.mucha.hostname}{':' + str(self.config.allnet.port) if self.config.server.is_develop else ''}"
+        )
+
+        self.logger.debug(f"Mucha response {vars(resp)}")
 
         return self.mucha_postprocess(vars(resp))
-    
-    def handle_updatecheck(self, request: Request) -> bytes:
+
+    def handle_updatecheck(self, request: Request, _: Dict) -> bytes:
         req_dict = self.mucha_preprocess(request.content.getvalue())
+        client_ip = Utils.get_ip_addr(request)
+
         if req_dict is None:
-            self.logger.error(f"Error processing mucha request {request.content.getvalue()}")
+            self.logger.error(
+                f"Error processing mucha request {request.content.getvalue()}"
+            )
             return b""
 
         req = MuchaUpdateRequest(req_dict)
-        self.logger.info(f"Mucha request {vars(req)}")
-        resp = MuchaUpdateResponse(mucha_url=f"{self.config.mucha.hostname}:{self.config.mucha.port}")
-        self.logger.info(f"Mucha response {vars(resp)}")
+        self.logger.debug(f"Mucha request {vars(req)}")
+        self.logger.info(
+            f"Updatecheck request from {client_ip} for {req.gameVer}"
+        )
+
+        if req.gameCd not in self.mucha_registry:
+            self.logger.warn(f"Unknown gameCd {req.gameCd}")
+            return b""
+
+        resp = MuchaUpdateResponseStub(req.gameVer)
+
+        self.logger.debug(f"Mucha response {vars(resp)}")
 
         return self.mucha_postprocess(vars(resp))
 
     def mucha_preprocess(self, data: bytes) -> Optional[Dict]:
         try:
             ret: Dict[str, Any] = {}
-            
-            for x in data.decode().split('&'):
-                kvp = x.split('=')
+
+            for x in data.decode().split("&"):
+                kvp = x.split("=")
                 if len(kvp) == 2:
                     ret[kvp[0]] = kvp[1]
 
             return ret
-        
+
         except:
             self.logger.error(f"Error processing mucha request {data}")
             return None
@@ -72,7 +124,7 @@ class MuchaServlet:
     def mucha_postprocess(self, data: dict) -> Optional[bytes]:
         try:
             urlencode = ""
-            for k,v in data.items():
+            for k, v in data.items():
                 urlencode += f"{k}={v}&"
 
             return urlencode.encode()
@@ -81,35 +133,39 @@ class MuchaServlet:
             self.logger.error("Error processing mucha response")
             return None
 
-class MuchaAuthRequest():
-    def __init__(self, request: Dict) -> None:
-        self.gameVer = "" if "gameVer" not in request else request["gameVer"]
-        self.sendDate = "" if "sendDate" not in request else request["sendDate"]
-        self.serialNum = "" if "serialNum" not in request else request["serialNum"]
-        self.gameCd = "" if "gameCd" not in request else request["gameCd"]
-        self.boardType = "" if "boardType" not in request else request["boardType"]
-        self.boardId = "" if "boardId" not in request else request["boardId"]
-        self.placeId = "" if "placeId" not in request else request["placeId"]
-        self.storeRouterIp = "" if "storeRouterIp" not in request else request["storeRouterIp"]
-        self.countryCd = "" if "countryCd" not in request else request["countryCd"]
-        self.useToken = "" if "useToken" not in request else request["useToken"]
-        self.allToken = "" if "allToken" not in request else request["allToken"]
 
-class MuchaAuthResponse():
-    def __init__(self, mucha_url: str = "localhost") -> None:
-        self.RESULTS = "001"        
+class MuchaAuthRequest:
+    def __init__(self, request: Dict) -> None:
+        # gameCd + boardType + countryCd + version
+        self.gameVer = request.get("gameVer", "")
+        self.sendDate = request.get("sendDate", "")  # %Y%m%d
+        self.serialNum = request.get("serialNum", "")
+        self.gameCd = request.get("gameCd", "")
+        self.boardType = request.get("boardType", "")
+        self.boardId = request.get("boardId", "")
+        self.mac = request.get("mac", "")
+        self.placeId = request.get("placeId", "")
+        self.storeRouterIp = request.get("storeRouterIp", "")
+        self.countryCd = request.get("countryCd", "")
+        self.useToken = request.get("useToken", "")
+        self.allToken = request.get("allToken", "")
+
+
+class MuchaAuthResponse:
+    def __init__(self, mucha_url: str) -> None:
+        self.RESULTS = "001"
         self.AUTH_INTERVAL = "86400"
         self.SERVER_TIME = datetime.strftime(datetime.now(), "%Y%m%d%H%M")
         self.UTC_SERVER_TIME = datetime.strftime(datetime.now(pytz.UTC), "%Y%m%d%H%M")
 
-        self.CHARGE_URL = f"https://{mucha_url}/charge/"        
+        self.CHARGE_URL = f"https://{mucha_url}/charge/"
         self.FILE_URL = f"https://{mucha_url}/file/"
         self.URL_1 = f"https://{mucha_url}/url1/"
         self.URL_2 = f"https://{mucha_url}/url2/"
         self.URL_3 = f"https://{mucha_url}/url3/"
-        
-        self.PLACE_ID = "JPN123"        
-        self.COUNTRY_CD = "JPN"        
+
+        self.PLACE_ID = "JPN123"
+        self.COUNTRY_CD = "JPN"
         self.SHOP_NAME = "TestShop!"
         self.SHOP_NICKNAME = "TestShop"
         self.AREA_0 = "008"
@@ -120,7 +176,7 @@ class MuchaAuthResponse():
         self.AREA_FULL_1 = ""
         self.AREA_FULL_2 = ""
         self.AREA_FULL_3 = ""
-        
+
         self.SHOP_NAME_EN = "TestShop!"
         self.SHOP_NICKNAME_EN = "TestShop"
         self.AREA_0_EN = "008"
@@ -132,24 +188,26 @@ class MuchaAuthResponse():
         self.AREA_FULL_2_EN = ""
         self.AREA_FULL_3_EN = ""
 
-        self.PREFECTURE_ID = "1"        
+        self.PREFECTURE_ID = "1"
         self.EXPIRATION_DATE = "null"
         self.USE_TOKEN = "0"
         self.CONSUME_TOKEN = "0"
         self.DONGLE_FLG = "1"
         self.FORCE_BOOT = "0"
 
-class MuchaUpdateRequest():
-    def __init__(self, request: Dict) -> None:
-        self.gameVer = "" if "gameVer" not in request else request["gameVer"]
-        self.gameCd = "" if "gameCd" not in request else request["gameCd"]
-        self.serialNum = "" if "serialNum" not in request else request["serialNum"]
-        self.countryCd = "" if "countryCd" not in request else request["countryCd"]
-        self.placeId = "" if "placeId" not in request else request["placeId"]
-        self.storeRouterIp = "" if "storeRouterIp" not in request else request["storeRouterIp"]
 
-class MuchaUpdateResponse():
-    def __init__(self, game_ver: str = "PKFN0JPN01.01", mucha_url: str = "localhost") -> None:
+class MuchaUpdateRequest:
+    def __init__(self, request: Dict) -> None:
+        self.gameVer = request.get("gameVer", "")
+        self.gameCd = request.get("gameCd", "")
+        self.serialNum = request.get("serialNum", "")
+        self.countryCd = request.get("countryCd", "")
+        self.placeId = request.get("placeId", "")
+        self.storeRouterIp = request.get("storeRouterIp", "")
+
+
+class MuchaUpdateResponse:
+    def __init__(self, game_ver: str, mucha_url: str) -> None:
         self.RESULTS = "001"
         self.UPDATE_VER_1 = game_ver
         self.UPDATE_URL_1 = f"https://{mucha_url}/updUrl1/"
@@ -161,3 +219,11 @@ class MuchaUpdateResponse():
         self.COM_SIZE_1 = "0"
         self.COM_TIME_1 = "0"
         self.LAN_INFO_SIZE_1 = "0"
+        self.USER_ID = ""
+        self.PASSWORD = ""
+
+
+class MuchaUpdateResponseStub:
+    def __init__(self, game_ver: str) -> None:
+        self.RESULTS = "001"
+        self.UPDATE_VER_1 = game_ver

core/title.py

@@ -7,8 +7,9 @@ from core.config import CoreConfig
 from core.data import Data
 from core.utils import Utils
 
-class TitleServlet():
-    def __init__(self, core_cfg: CoreConfig, cfg_folder: str):        
+
+class TitleServlet:
+    def __init__(self, core_cfg: CoreConfig, cfg_folder: str):
         super().__init__()
         self.config = core_cfg
         self.config_folder = cfg_folder
@@ -18,57 +19,86 @@ class TitleServlet():
         self.logger = logging.getLogger("title")
         if not hasattr(self.logger, "initialized"):
             log_fmt_str = "[%(asctime)s] Title | %(levelname)s | %(message)s"
-            log_fmt = logging.Formatter(log_fmt_str)        
+            log_fmt = logging.Formatter(log_fmt_str)
 
-            fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.config.server.log_dir, "title"), when="d", backupCount=10)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.config.server.log_dir, "title"),
+                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(core_cfg.title.loglevel)
-            coloredlogs.install(level=core_cfg.title.loglevel, logger=self.logger, fmt=log_fmt_str)
+            coloredlogs.install(
+                level=core_cfg.title.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
             self.logger.initialized = True
-        
+
         plugins = Utils.get_all_titles()
-        
+
         for folder, mod in plugins.items():
             if hasattr(mod, "game_codes") and hasattr(mod, "index"):
-                handler_cls = mod.index(self.config, self.config_folder)
-                if hasattr(handler_cls, "setup"):
-                    handler_cls.setup()
-                
-                for code in mod.game_codes:
-                    self.title_registry[code] = handler_cls
-            
+                should_call_setup = True
+
+                if hasattr(mod.index, "get_allnet_info"):
+                    for code in mod.game_codes:
+                        enabled, _, _ = mod.index.get_allnet_info(
+                            code, self.config, self.config_folder
+                        )
+
+                        if enabled:
+                            handler_cls = mod.index(self.config, self.config_folder)
+
+                            if hasattr(handler_cls, "setup") and should_call_setup:
+                                handler_cls.setup()
+                                should_call_setup = False
+
+                            self.title_registry[code] = handler_cls
+
+                else:
+                    self.logger.warn(f"Game {folder} has no get_allnet_info")
+
             else:
                 self.logger.error(f"{folder} missing game_code or index in __init__.py")
-        
-        self.logger.info(f"Serving {len(self.title_registry)} game codes on port {core_cfg.title.port}")
+
+        self.logger.info(
+            f"Serving {len(self.title_registry)} game codes {'on port ' + str(core_cfg.title.port) if core_cfg.title.port > 0 else ''}"
+        )
 
     def render_GET(self, request: Request, endpoints: dict) -> bytes:
         code = endpoints["game"]
         if code not in self.title_registry:
             self.logger.warn(f"Unknown game code {code}")
-        
+            request.setResponseCode(404)
+            return b""
+
         index = self.title_registry[code]
         if not hasattr(index, "render_GET"):
             self.logger.warn(f"{code} does not dispatch GET")
+            request.setResponseCode(405)
             return b""
 
         return index.render_GET(request, endpoints["version"], endpoints["endpoint"])
-    
+
     def render_POST(self, request: Request, endpoints: dict) -> bytes:
         code = endpoints["game"]
         if code not in self.title_registry:
             self.logger.warn(f"Unknown game code {code}")
-        
+            request.setResponseCode(404)
+            return b""
+
         index = self.title_registry[code]
         if not hasattr(index, "render_POST"):
             self.logger.warn(f"{code} does not dispatch POST")
+            request.setResponseCode(405)
             return b""
 
-        return index.render_POST(request, endpoints["version"], endpoints["endpoint"])
+        return index.render_POST(
+            request, int(endpoints["version"]), endpoints["endpoint"]
+        )

core/utils.py

@@ -1,22 +1,28 @@
-from typing import Dict, List, Any, Optional
+from typing import Dict, Any
 from types import ModuleType
-import zlib, base64
+from twisted.web.http import Request
+import logging
 import importlib
 from os import walk
 
+
 class Utils:
     @classmethod
     def get_all_titles(cls) -> Dict[str, ModuleType]:
         ret: Dict[str, Any] = {}
 
         for root, dirs, files in walk("titles"):
-            for dir in dirs: 
+            for dir in dirs:
                 if not dir.startswith("__"):
                     try:
                         mod = importlib.import_module(f"titles.{dir}")
                         ret[dir] = mod
 
                     except ImportError as e:
-                        print(f"{dir} - {e}")
+                        logging.getLogger("core").error(f"get_all_titles: {dir} - {e}")
                         raise
             return ret
+    
+    @classmethod
+    def get_ip_addr(cls, req: Request) -> str:
+        return req.getAllHeaders()[b"x-forwarded-for"].decode() if b"x-forwarded-for" in req.getAllHeaders() else req.getClientAddress().host

dbutils.py

@@ -2,46 +2,78 @@ import yaml
 import argparse
 from core.config import CoreConfig
 from core.data import Data
+from os import path, mkdir, access, W_OK
 
-if __name__=='__main__':
+if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Database utilities")
-    parser.add_argument("--config", "-c", type=str, help="Config folder to use", default="config")
-    parser.add_argument("--version", "-v", type=str, help="Version of the database to upgrade/rollback to")
-    parser.add_argument("--game", "-g", type=str, help="Game code of the game who's schema will be updated/rolled back. Ex. SDFE")
-    parser.add_argument("action", type=str, help="DB Action, create, recreate, upgrade, or rollback")
+    parser.add_argument(
+        "--config", "-c", type=str, help="Config folder to use", default="config"
+    )
+    parser.add_argument(
+        "--version",
+        "-v",
+        type=str,
+        help="Version of the database to upgrade/rollback to",
+    )
+    parser.add_argument(
+        "--game",
+        "-g",
+        type=str,
+        help="Game code of the game who's schema will be updated/rolled back. Ex. SDFE",
+    )
+    parser.add_argument("--email", "-e", type=str, help="Email for the new user")
+    parser.add_argument("--old_ac", "-o", type=str, help="Access code to transfer from")
+    parser.add_argument("--new_ac", "-n", type=str, help="Access code to transfer to")
+    parser.add_argument("--force", "-f", type=bool, help="Force the action to happen")
+    parser.add_argument(
+        "action", type=str, help="DB Action, create, recreate, upgrade, or rollback"
+    )
     args = parser.parse_args()
 
     cfg = CoreConfig()
-    cfg.update(yaml.safe_load(open(f"{args.config}/core.yaml")))
+    if path.exists(f"{args.config}/core.yaml"):
+        cfg.update(yaml.safe_load(open(f"{args.config}/core.yaml")))
+    
+    if not path.exists(cfg.server.log_dir):
+        mkdir(cfg.server.log_dir)
+    
+    if not access(cfg.server.log_dir, W_OK):
+        print(
+            f"Log directory {cfg.server.log_dir} NOT writable, please check permissions"
+        )
+        exit(1)
+
     data = Data(cfg)
+    
 
     if args.action == "create":
         data.create_database()
-        
+
     elif args.action == "recreate":
         data.recreate_database()
 
     elif args.action == "upgrade" or args.action == "rollback":
         if args.version is None:
-            print("Must set game and version to migrate to")
+            data.logger.error("Must set game and version to migrate to")
             exit(0)
 
         if args.game is None:
-            print("No game set, upgrading core schema")
-            data.migrate_database("CORE", int(args.version))
+            data.logger.info("No game set, upgrading core schema")
+            data.migrate_database("CORE", int(args.version), args.action)
 
         else:
             data.migrate_database(args.game, int(args.version), args.action)
-    
-    elif args.action == "migrate":
-        print("Migrating from old schema to new schema")
-        data.restore_from_old_schema()
-    
-    elif args.action == "dump":
-        print("Dumping old schema to migrate to new schema")
-        data.dump_db()
-    
-    elif args.action == "generate":
-        pass
+
+    elif args.action == "autoupgrade":
+        data.autoupgrade()
+
+    elif args.action == "create-owner":
+        data.create_owner(args.email)
+
+    elif args.action == "migrate-card":
+        data.migrate_card(args.old_ac, args.new_ac, args.force)
+
+    elif args.action == "cleanup":
+        data.delete_hanging_users()
 
     data.logger.info("Done")

docs/INSTALL_UBUNTU.md

@@ -0,0 +1,129 @@
+# ARTEMiS - Ubuntu 20.04 LTS Guide
+This step-by-step guide assumes that you are using a fresh install of Ubuntu 20.04 LTS, some of the steps can be skipped if you already have an installation with MySQL 5.7 or even some of the modules already present on your environment
+
+# Setup
+## Install memcached module
+1. sudo apt-get install memcached
+2. Under the file /etc/memcached.conf, please make sure the following parameters are set:
+
+```
+# Start with a cap of 64 megs of memory. It's reasonable, and the daemon default
+# Note that the daemon will grow to this size, but does not start out holding this much
+# memory
+
+-I 128m
+-m 1024
+```
+
+** This is mandatory to avoid memcached overload caused by Crossbeats or by massive profiles
+
+3. Restart memcached using:  sudo systemctl restart memcached
+
+## Install MySQL 5.7
+```
+sudo apt update
+sudo apt install wget -y
+wget https://dev.mysql.com/get/mysql-apt-config_0.8.12-1_all.deb
+sudo dpkg -i mysql-apt-config_0.8.12-1_all.deb
+```
+    1. During the first prompt, select Ubuntu Bionic
+    2. Select the default option
+    3. Select MySQL 5.7
+    4. Select the last option
+```
+sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 467B942D3A79BD29
+sudo apt-get update
+sudo apt-cache policy mysql-server
+sudo apt install -f mysql-client=5.7* mysql-community-server=5.7* mysql-server=5.7*
+```
+
+## Default Configuration for MySQL Server
+1. sudo mysql_secure_installation
+> Make sure to follow the steps that will be prompted such as changing the mysql root password and such
+
+2. Test your MySQL Server login by doing the following command :
+> mysql -u root -p
+
+## Create the default ARTEMiS database and user
+1. mysql -u root -p
+2. Please change the password indicated in the next line for a custom secure one and continue with the next commands
+
+```
+CREATE USER 'aime'@'localhost' IDENTIFIED BY 'MyStrongPass.';
+CREATE DATABASE aime;
+GRANT Alter,Create,Delete,Drop,Index,Insert,References,Select,Update ON aime.* TO 'aime'@'localhost';
+FLUSH PRIVILEGES;
+exit;
+```
+
+3. sudo systemctl restart mysql
+
+## Install Python modules
+```
+sudo apt-get install python3-dev default-libmysqlclient-dev build-essential mysql-client libmysqlclient-dev libmemcached-dev
+sudo apt install libpython3.8-dev
+sudo apt-get install python3-software-properties
+sudo apt install python3-pip
+sudo pip3 install --upgrade pip testresources
+sudo pip3 install --upgrade pip setuptools
+sudo apt-get install python3-tk
+```
+7. Change your work path to the ARTEMiS root folder using 'cd' and install the requirements:
+> sudo python3 -m pip install -r requirements.txt
+
+## Copy/Rename the folder example_config to config
+
+## Adjust /config/core.yaml
+1. Make sure to change the server listen_address to be set to your local machine IP (ex.: 192.168.1.xxx) 
+2. Adjust the proper MySQL information you created earlier
+3. Add the AimeDB key at the bottom of the file
+
+## Create the database tables for ARTEMiS
+1. sudo python3 dbutils.py create
+
+2. If you get "No module named Crypto", run the following command:
+```
+sudo pip uninstall crypto
+sudo pip uninstall pycrypto
+sudo pip install pycrypto
+```
+
+## Firewall Adjustements 
+```
+sudo ufw allow 80
+sudo ufw allow 443
+sudo ufw allow 8443
+sudo ufw allow 22345
+sudo ufw allow 8090
+sudo ufw allow 8444
+sudo ufw allow 8080
+```
+
+## Running the ARTEMiS instance
+1. sudo python3 index.py
+
+# Troubleshooting
+
+## Game does not connect to ARTEMiS Allnet server
+1. Double-check your core.yaml, the listen_address is most likely either not binded to the proper IP or the port is not opened
+
+## Game does not connect to Title Server
+1. Verify that your core.yaml is setup properly for both the server listen_address and title hostname
+2. Boot your game and verify that an AllNet response does show and if it does, attempt to open the URI that is shown under a browser such as Edge, Chrome & Firefox.
+3. If a page is shown, the server is working properly and if it doesn't, double check your port forwarding and also that you have entered the proper local IP under the Title hostname in core.yaml.
+
+## Unhandled command under AimeDB
+1. Double check your AimeDB key under core.yaml, it is incorrect.
+
+## Memcache failed, error 3
+1. Make sure memcached is properly installed and running. You can check the status of the service using the following command:
+> sudo systemctl status memcached
+2. If it is failing, double check the /etc/memcached.conf file, it may have duplicated arguments like the -I and -m
+3. If it is still not working afterward, you can proceed with a workaround by manually editing the /core/data/cache.py file.
+```
+# Make memcache optional
+try:
+    has_mc = False
+except ModuleNotFoundError:
+    has_mc = False
+```

docs/INSTALL_WINDOWS.md

@@ -0,0 +1,83 @@
+# ARTEMiS - Windows 10/11 Guide
+This step-by-step guide assumes that you are using a fresh install of Windows 10/11 without MySQL installed, some of the steps can be skipped if you already have an installation with MySQL 8.0 or even some of the modules already present on your environment
+
+# Setup
+## Install Python Python 3.9 (recommended) or 3.10
+1. Download Python 3.9 : [Link](https://www.python.org/ftp/python/3.9.13/python-3.9.13-amd64.exe)
+2. Install python-3.9.13-amd64.exe
+    1. Select Customize installation
+    2. Make sure that pip, tcl/tk, and the for all users are checked and hit Next
+    3. Make sure that you enable "Create shortcuts for installed applications" and "Add Python to environment variables" and hit Install
+
+## Install MySQL 8.0
+1. Download MySQL 8.0 Server : [Link](https://cdn.mysql.com//Downloads/MySQLInstaller/mysql-installer-web-community-8.0.31.0.msi)
+2. Install mysql-installer-web-community-8.0.31.0.msi
+    1. Click on "Add ..." on the side
+    2. Click on the "+" next to MySQL Servers
+    3. Make sure MySQL Server 8.0.29 - X64 is under the products to be installed.
+    4. Hit Next and Next once installed
+    5. Select the configuration type "Development Computer"
+    6. Hit Next
+    7. Select "Use Legacy Authentication Method (Retain MySQL 5.x compatibility)" and hit Next
+    8. Enter a root password and then hit Next >
+    9. Leave everything under Windows Service as default and hit Next >
+    10. Click on Execute and for it to finish and hit Next> and then Finish
+3. Open MySQL 8.0 Command Line Client and login as your root user
+4. Type those commands to create your user and the database
+```
+CREATE USER 'aime'@'localhost' IDENTIFIED BY 'MyStrongPass.';
+CREATE DATABASE aime;
+GRANT Alter,Create,Delete,Drop,Index,Insert,References,Select,Update ON aime.* TO 'aime'@'localhost';
+FLUSH PRIVILEGES;
+exit;
+```
+
+## Install Python modules
+1. Change your work path to the artemis-master folder using 'cd' and install the requirements:
+> pip install -r requirements.txt
+
+## Copy/Rename the folder example_config to config
+
+## Adjust /config/core.yaml
+
+1. Make sure to change the server listen_address to be set to your local machine IP (ex.: 192.168.1.xxx) 
+    - In case you want to run this only locally, set the following values:
+```
+server:
+    listen_address: 0.0.0.0
+title: 
+    hostname: localhost
+```
+2. Adjust the proper MySQL information you created earlier
+3. Add the AimeDB key at the bottom of the file
+4. If the webui is needed, change the flag from False to True
+
+## Create the database tables for ARTEMiS
+> python dbutils.py create
+
+## Firewall Adjustements 
+Make sure the following ports are open both on your router and local Windows firewall in case you want to use this for public use (NOT recommended):
+> Port 80 (TCP), 443 (TCP), 8443 (TCP), 22345 (TCP), 8080 (TCP), 8090 (TCP) **webui, 8444 (TCP) **mucha
+
+## Running the ARTEMiS instance
+> python index.py
+
+# Troubleshooting
+
+## Game does not connect to ARTEMiS Allnet server
+1. Double-check your core.yaml, the listen_address is most likely either not binded to the proper IP or the port is not opened
+
+## Game does not connect to Title Server
+1. Verify that your core.yaml is setup properly for both the server listen_address and title hostname
+2. Boot your game and verify that an AllNet response does show and if it does, attempt to open the URI that is shown under a browser such as Edge, Chrome & Firefox.
+3. If a page is shown, the server is working properly and if it doesn't, double check your port forwarding and also that you have entered the proper local IP under the Title hostname in core.yaml.
+
+## Unhandled command under AimeDB
+1. Double check your AimeDB key under core.yaml, it is incorrect.
+
+## AttributeError: module 'collections' has no attribute 'Hashable'
+1. This means the pyYAML module is obsolete, simply rerun pip with the -U (force update) flag, as shown below.
+    - Change your work path to the artemis-master (or artemis-develop) folder using 'cd' and run the following commands:
+```
+pip install -r requirements.txt -U
+```

docs/game_specific_info.md

@@ -0,0 +1,352 @@
+# ARTEMiS Games Documentation
+
+Below are all supported games with supported version ids in order to use
+the corresponding importer and database upgrades.
+
+**Important: The described database upgrades are only required if you are using an old database schema, f.e. still
+using the megaime database. Clean installations always create the latest database structure!**
+
+# Table of content
+
+- [Supported Games](#supported-games)
+    - [Chunithm](#chunithm)
+    - [crossbeats REV.](#crossbeats-rev)
+    - [maimai DX](#maimai-dx)
+    - [O.N.G.E.K.I.](#o-n-g-e-k-i)
+    - [Card Maker](#card-maker)
+    - [WACCA](#wacca)
+
+
+# Supported Games
+
+Games listed below have been tested and confirmed working.
+
+## Chunithm
+
+### SDBT
+
+| Version ID | Version Name       |
+|------------|--------------------|
+| 0          | Chunithm           |
+| 1          | Chunithm+          |
+| 2          | Chunithm Air       |
+| 3          | Chunithm Air +     |
+| 4          | Chunithm Star      |
+| 5          | Chunithm Star +    |
+| 6          | Chunithm Amazon    |
+| 7          | Chunithm Amazon +  |
+| 8          | Chunithm Crystal   |
+| 9          | Chunithm Crystal + |
+| 10         | Chunithm Paradise  |
+
+### SDHD/SDBT
+
+| Version ID | Version Name    |
+|------------|-----------------|
+| 11         | Chunithm New!!  |
+| 12         | Chunithm New!!+ |
+
+
+### Importer
+
+In order to use the importer locate your game installation folder and execute:
+
+```shell
+python read.py --series SDBT --version <version ID> --binfolder /path/to/game/folder --optfolder /path/to/game/option/folder
+```
+
+The importer for Chunithm will import: Events, Music, Charge Items and Avatar Accesories.
+
+### Database upgrade
+
+Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see
+which version is the latest, f.e. `SDBT_3_upgrade.sql`. In order to upgrade to version 3 in this case you need to
+perform all previous updates as well:
+
+```shell
+python dbutils.py --game SDBT --version 2 upgrade
+python dbutils.py --game SDBT --version 3 upgrade
+```
+
+## crossbeats REV.
+
+### SDCA
+
+| Version ID | Version Name                       |
+|------------|------------------------------------|
+| 0          | crossbeats REV.                    |
+| 1          | crossbeats REV. SUNRISE            |
+| 2          | crossbeats REV. SUNRISE S2         |
+| 3          | crossbeats REV. SUNRISE S2 Omnimix |
+
+### Importer
+
+In order to use the importer you need to use the provided `Export.csv` file:
+
+```shell
+python read.py --series SDCA --version <version ID> --binfolder titles/cxb/data
+```
+
+The importer for crossbeats REV. will import Music.
+
+### Config
+
+Config file is located in `config/cxb.yaml`.
+
+| Option                 | Info                                                       |
+|------------------------|------------------------------------------------------------|
+| `hostname`             | Requires a proper `hostname` (not localhost!) to run       |
+| `ssl_enable`           | Enables/Disables the use of the `ssl_cert` and `ssl_key`   |
+| `port`                 | Set your unsecure port number                              |
+| `port_secure`          | Set your secure/SSL port number                            |
+| `ssl_cert`, `ssl_key`  | Enter your SSL certificate (requires not self signed cert) |
+
+
+## maimai DX
+
+### SDEZ
+
+| Version ID | Version Name            |
+|------------|-------------------------|
+| 0          | maimai DX               |
+| 1          | maimai DX PLUS          |
+| 2          | maimai DX Splash        |
+| 3          | maimai DX Splash PLUS   |
+| 4          | maimai DX Universe      |
+| 5          | maimai DX Universe PLUS |
+| 6          | maimai DX Festival      |
+
+### Importer
+
+In order to use the importer locate your game installation folder and execute:
+
+```shell
+python read.py --series SDEZ --version <version ID> --binfolder /path/to/game/folder --optfolder /path/to/game/option/folder
+```
+
+The importer for maimai DX will import Events, Music and Tickets.
+
+**NOTE: It is required to use the importer because the game will
+crash without Events!**
+
+### Database upgrade
+
+Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see which version is the latest, f.e. `SDEZ_2_upgrade.sql`. In order to upgrade to version 2 in this case you need to perform all previous updates as well:
+
+```shell
+python dbutils.py --game SDEZ --version 2 upgrade
+```
+
+## Hatsune Miku Project Diva
+
+### SBZV
+
+| Version ID | Version Name                    |
+|------------|---------------------------------|
+| 0          | Project Diva Arcade             |
+| 1          | Project Diva Arcade Future Tone |
+
+
+### Importer
+
+In order to use the importer locate your game installation folder and execute:
+
+```shell
+python read.py --series SBZV --version <version ID> --binfolder /path/to/game/data/diva --optfolder /path/to/game/data/diva/mdata
+```
+
+The importer for Project Diva Arcade will all required data in order to use
+the Shop, Modules and Customizations.
+
+### Config
+
+Config file is located in `config/diva.yaml`.
+
+| Option               | Info                                                                                            |
+|----------------------|-------------------------------------------------------------------------------------------------|
+| `unlock_all_modules` | Unlocks all modules (costumes) by default, if set to `False` all modules need to be purchased   |
+| `unlock_all_items`   | Unlocks all items (customizations) by default, if set to `False` all items need to be purchased |
+
+
+### Database upgrade
+
+Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see
+which version is the latest, f.e. `SBZV_4_upgrade.sql`. In order to upgrade to version 4 in this case you need to
+perform all previous updates as well:
+
+```shell
+python dbutils.py --game SBZV --version 2 upgrade
+python dbutils.py --game SBZV --version 3 upgrade
+python dbutils.py --game SBZV --version 4 upgrade
+```
+
+## O.N.G.E.K.I.
+
+### SDDT
+
+| Version ID | Version Name               |
+|------------|----------------------------|
+| 0          | O.N.G.E.K.I.               |
+| 1          | O.N.G.E.K.I. +             |
+| 2          | O.N.G.E.K.I. Summer        |
+| 3          | O.N.G.E.K.I. Summer +      |
+| 4          | O.N.G.E.K.I. Red           |
+| 5          | O.N.G.E.K.I. Red +         |
+| 6          | O.N.G.E.K.I. Bright        |
+| 7          | O.N.G.E.K.I. Bright Memory |
+
+
+### Importer
+
+In order to use the importer locate your game installation folder and execute:
+
+```shell
+python read.py --series SDDT --version <version ID> --binfolder /path/to/game/folder --optfolder /path/to/game/option/folder
+```
+
+The importer for O.N.G.E.K.I. will all all Cards, Music and Events.
+
+**NOTE: The Importer is required for Card Maker.**
+
+### Config
+
+Config file is located in `config/ongeki.yaml`.
+
+| Option           | Info                                                                                                           |
+|------------------|----------------------------------------------------------------------------------------------------------------|
+| `enabled_gachas` | Enter all gacha IDs for Card Maker to work, other than default may not work due to missing cards added to them |
+
+Note: 1149 and higher are only for Card Maker 1.35 and higher and will be ignored on lower versions.
+
+### Database upgrade
+
+Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see
+which version is the latest, f.e. `SDDT_4_upgrade.sql`. In order to upgrade to version 4 in this case you need to
+perform all previous updates as well:
+
+```shell
+python dbutils.py --game SDDT --version 2 upgrade
+python dbutils.py --game SDDT --version 3 upgrade
+python dbutils.py --game SDDT --version 4 upgrade
+```
+
+## Card Maker
+
+### SDED
+
+| Version ID | Version Name    |
+|------------|-----------------|
+| 0          | Card Maker 1.34 |
+| 1          | Card Maker 1.35 |
+
+
+### Support status
+
+* Card Maker 1.34:
+  * Chunithm New!!: Yes
+  * maimai DX Universe: Yes
+  * O.N.G.E.K.I. Bright: Yes
+
+* Card Maker 1.35:
+  * Chunithm New!!+: Yes
+  * maimai DX Universe PLUS: Yes
+  * O.N.G.E.K.I. Bright Memory: Yes
+
+
+### Importer
+
+In order to use the importer you need to use the provided `.csv` files (which are required for O.N.G.E.K.I.) and the
+option folders:
+
+```shell
+python read.py --series SDED --version <version ID> --binfolder titles/cm/cm_data --optfolder /path/to/cardmaker/option/folder
+```
+
+**If you haven't already executed the O.N.G.E.K.I. importer, make sure you import all cards!**
+
+```shell
+python read.py --series SDDT --version <version ID> --binfolder /path/to/game/folder --optfolder /path/to/game/option/folder
+```
+
+Also make sure to import all maimai and Chunithm data as well:
+
+```shell
+python read.py --series SDED --version <version ID> --binfolder /path/to/cardmaker/CardMaker_Data
+```
+
+The importer for Card Maker will import all required Gachas (Banners) and cards (for maimai/Chunithm) and the hardcoded
+Cards for each Gacha (O.N.G.E.K.I. only).
+
+**NOTE: Without executing the importer Card Maker WILL NOT work!**
+
+
+### O.N.G.E.K.I. Gachas
+
+Gacha "無料ガチャ" can only pull from the free cards with the following probabilities: 94%: R, 5% SR and 1% chance of
+getting an SSR card
+
+Gacha "無料ガチャ（SR確定）" can only pull from free SR cards with prob: 92% SR and 8% chance of getting an SSR card
+
+Gacha "レギュラーガチャ" can pull from every card added to ongeki_static_cards with the following prob: 77% R, 20% SR
+and 3% chance of getting an SSR card
+
+All other (limited) gachas can pull from every card added to ongeki_static_cards but with the promoted cards
+(click on the green button under the banner) having a 10 times higher chance to get pulled
+
+### Chunithm Gachas
+
+All cards in Chunithm (basically just the characters) have the same rarity to it just pulls randomly from all cards
+from a given gacha but made sure you cannot pull the same card twice in the same 5 times gacha roll.
+
+### Notes
+
+Card Maker 1.34 will only load an O.N.G.E.K.I. Bright profile (1.30). Card Maker 1.35 will only load an O.N.G.E.K.I.
+Bright Memory profile (1.35).
+The gachas inside the `ongeki.yaml` will make sure only the right gacha ids for the right CM version will be loaded.
+Gacha IDs up to 1140 will be loaded for CM 1.34 and all gachas will be loaded for CM 1.35.
+
+**NOTE: There is currently no way to load/use the (printed) maimai DX cards!**
+
+## WACCA
+
+### SDFE
+
+| Version ID | Version Name  |
+|------------|---------------|
+| 0          | WACCA         |
+| 1          | WACCA S       |
+| 2          | WACCA Lily    |
+| 3          | WACCA Lily R  |
+| 4          | WACCA Reverse |
+
+
+### Importer
+
+In order to use the importer locate your game installation folder and execute:
+
+```shell
+python read.py --series SDFE --version <version ID> --binfolder /path/to/game/WindowsNoEditor/Mercury/Content
+```
+
+The importer for WACCA will import all Music data.
+
+### Config
+
+Config file is located in `config/wacca.yaml`.
+
+| Option             | Info                                                                        |
+|--------------------|-----------------------------------------------------------------------------|
+| `always_vip`       | Enables/Disables VIP, if disabled it needs to be purchased manually in game |
+| `infinite_tickets` | Always set the "unlock expert" tickets to 5                                 |
+| `infinite_wp`      | Sets the user WP to `999999`                                                |
+| `enabled_gates`    | Enter all gate IDs which should be enabled in game                          |
+
+
+### Database upgrade
+
+Always make sure your database (tables) are up-to-date, to do so go to the `core/data/schema/versions` folder and see which version is the latest, f.e. `SDFE_3_upgrade.sql`. In order to upgrade to version 3 in this case you need to perform all previous updates as well:
+
+```shell
+python dbutils.py --game SDFE --version 2 upgrade
+python dbutils.py --game SDFE --version 3 upgrade
+```

docs/prod.md

@@ -0,0 +1,41 @@
+# ARTEMiS Production mode
+Production mode is a configuration option that changes how the server listens to be more friendly to a production environment. This mode assumes that a proxy (for this guide, nginx) is standing in front of the server to handle port mapping and TLS. In order to activate production mode, simply change `is_develop` to `False` in `core.yaml`. Next time you start the server, you should see "Starting server in production mode".
+
+## Nginx Configuration
+### Port forwarding
+Artemis requires that the following ports be forwarded to allow internet traffic to access the server. This will not change regardless of what you set in the config, as many of these ports are hard-coded in the games.
+`tcp:80` all.net, non-ssl titles
+`tcp:8443` billing
+`tcp:22345` aimedb
+`tcp:443` frontend, SSL titles
+
+### A note about external proxy services (cloudflare, etc)
+Due to the way that artemis functions, it is currently not possible to put the server behind something like Cloudflare. Cloudflare only proxies web traffic on the standard ports (80, 443) and, as shown above, this does not work with artemis. Server administrators should seek other means to protect their network (VPS hosting, VPN, etc)
+
+### SSL Certificates
+You will need to generate SSL certificates for some games. The certificates vary in security and validity requirements. Please see the general guide below
+- General Title: The certificate for the general title server should be valid, not self-signed and match the CN that the game will be reaching out to (e.i if your games are reaching out to titles.hostname.here, your ssl certificate should be valid for titles.hostname.here, or *.hostname.here)
+- CXB: Same requires as the title server. It must not be self-signed, and CN must match. Recomended to get a wildcard cert if possible, and use it for both Title and CXB
+- Pokken: Pokken can be self-signed, and the CN doesn't have to match, but it MUST use 2048-bit RSA. Due to the games age, andthing stronger then that will be rejected.
+
+### Port mappings
+An example config is provided in the `config` folder called `nginx_example.conf`. It is set up for the following:
+`naominet.jp:tcp:80` -> `localhost:tcp:8000` for allnet
+`ib.naominet.jp:ssl:8443` -> `localhost:tcp:8444` for the billing server
+`your.hostname.here:ssl:443` -> `localhost:tcp:8080` for the SSL title server
+`your.hostname.here:tcp:80` -> `localhost:tcp:8080` for the non-SSL title server
+`cxb.hostname.here:ssl:443` -> `localhost:tcp:8080` for crossbeats (appends /SDCA/104/ to the request)
+`pokken.hostname.here:ssl:443` -> `localhost:tcp:8080` for pokken
+`frontend.hostname.here:ssl:443` -> `localhost:tcp:8090` for the frontend, includes https redirection
+
+If you're using this as a guide, be sure to replace your.hostname.here with the hostname you specified in core.yaml under `titles->hostname`. Do *not* change naominet.jp, or allnet/billing will fail. Also remember to specifiy certificate paths correctly, as in the example they are simply placeholders.
+
+### Multi-service ports
+It is possible to use nginx to redirect billing and title server requests to the same port that all.net uses. By setting `port` to 0 under billing and title server, you can change the nginx config to serve the following (entries not shown here should be the same)
+`ib.naominet.jp:ssl:8443` -> `localhost:tcp:8000` for the billing server
+`your.hostname.here:ssl:443` -> `localhost:tcp:8000` for the SSL title server
+`your.hostname.here:tcp:80` -> `localhost:tcp:8000` for the non-SSL title server
+`cxb.hostname.here:ssl:443` -> `localhost:tcp:8000` for crossbeats (appends /SDCA/104/ to the request)
+`pokken.hostname.here:ssl:443` -> `localhost:tcp:8000` for pokken
+
+This will allow you to only use 3 ports locally, but you will still need to forward the same internet-facing ports as before.

example_config/cardmaker.yaml

@@ -0,0 +1,3 @@
+server:
+  enable: True
+  loglevel: "info"

example_config/chuni.yaml

@@ -2,5 +2,19 @@ server:
   enable: True
   loglevel: "info"
 
+team:
+  name: ARTEMiS
+
+mods:
+  use_login_bonus: True
+
+version:
+  11:
+    rom: 2.00.00
+    data: 2.00.00
+  12:
+    rom: 2.05.00
+    data: 2.05.00
+
 crypto:
   encrypted_only: False

example_config/core.yaml

@@ -48,6 +48,3 @@ mucha:
   enable: False
   hostname: "localhost"
   loglevel: "info"
-  port: 8444
-  ssl_key: "cert/server.key"
-  ssl_cert: "cert/server.pem"

example_config/diva.yaml

@@ -2,3 +2,6 @@ server:
   enable: True
   loglevel: "info"
 
+mods:
+  unlock_all_modules: True
+  unlock_all_items: True

example_config/nginx_example.conf

@@ -4,6 +4,8 @@ server {
 	server_name naominet.jp;
 	
 	location / {
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_pass_request_headers on;
 		proxy_pass http://localhost:8000/;
 	}
 }
@@ -14,11 +16,13 @@ server {
 	server_name your.hostname.here;
 
 	location / {
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_pass_request_headers on;
 		proxy_pass http://localhost:8080/;
 	}
 }
 
-# SSL titles
+# SSL titles, comment out if you don't plan on accepting SSL titles
 server {
 	listen 443 ssl default_server;
 	listen [::]:443 ssl default_server;	
@@ -57,4 +61,86 @@ server {
 	location / {
 		proxy_pass http://localhost:8444/;
 	}
+}
+
+# Pokken, comment this out if you don't plan on serving pokken.
+server {
+	listen 443 ssl;	
+	server_name pokken.hostname.here;
+	
+	ssl_certificate /path/to/cert/pokken.pem;
+	ssl_certificate_key /path/to/cert/pokken.key;
+	ssl_session_timeout 1d;
+	ssl_session_cache shared:MozSSL:10m;
+	ssl_session_tickets off;
+
+	ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
+	ssl_ciphers "ALL:@SECLEVEL=1";
+	ssl_prefer_server_ciphers off;
+
+	location / {
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_pass_request_headers on;
+		proxy_pass http://localhost:8080/;
+	}
+}
+
+# CXB, comment this out if you don't plan on serving crossbeats.
+server {
+	listen 443 ssl;	
+	server_name cxb.hostname.here;
+	
+	ssl_certificate /path/to/cert/cxb.pem;
+	ssl_certificate_key /path/to/cert/cxb.key;
+	ssl_session_timeout 1d;
+	ssl_session_cache shared:MozSSL:10m;
+	ssl_session_tickets off;
+
+	ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
+	ssl_ciphers "ALL:@SECLEVEL=1";
+	ssl_prefer_server_ciphers off;
+
+	location / {
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_pass_request_headers on;
+		proxy_pass http://localhost:8080/SDBT/104/;
+	}
+}
+
+# Frontend, set to redirect to HTTPS. Comment out if you don't intend to use the frontend
+server {
+    listen 80;
+	server_name frontend.hostname.here
+
+    location / {
+        return 301 https://$host$request_uri;
+		# If you don't want https redirection, comment the line above and uncomment the line below
+		# proxy_pass http://localhost:8090/;
+    }
+}
+
+# Frontend HTTPS. Comment out if you on't intend to use the frontend
+server {
+    listen 443 ssl;
+	server_name frontend.hostname.here;
+
+    ssl_certificate /path/to/cert/frontend.pem;
+	ssl_certificate_key /path/to/cert/frontend.key;
+    ssl_session_timeout 1d;
+    ssl_session_cache shared:MozSSL:10m;  # about 40000 sessions
+    ssl_session_tickets off;
+
+    # intermediate configuration
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
+    ssl_prefer_server_ciphers off;
+
+    # HSTS (ngx_http_headers_module is required) (63072000 seconds)
+    add_header Strict-Transport-Security "max-age=63072000" always;
+
+	location / {
+		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+		proxy_pass_request_headers on;
+		proxy_pass http://localhost:8090/;
+	}
 }

example_config/ongeki.yaml

@@ -1,3 +1,31 @@
 server:
   enable: True
   loglevel: "info"
+
+gachas:
+  enabled_gachas:
+    - 1011
+    - 1012
+    - 1043
+    - 1067
+    - 1068
+    - 1069
+    - 1070
+    - 1071
+    - 1072
+    - 1073
+    - 1074
+    - 1075
+    - 1076
+    - 1077
+    - 1081
+    - 1085
+    - 1089
+    - 1104
+    - 1111
+    - 1135
+    # can be used for Card Maker 1.35 and up, else will be ignored
+    - 1149
+    - 1156
+    - 1163
+    - 1164

example_config/pokken.yaml

@@ -1,9 +1,9 @@
 server:
+  hostname: "localhost"
   enable: True
   loglevel: "info"
-  hostname: "localhost"
-  ssl_enable: False
   port: 9000
-  port_matching: 9001
-  ssl_cert: cert/pokken.crt
-  ssl_key: cert/pokken.key
+  port_stun: 9001
+  port_turn: 9002
+  port_admission: 9003
+  auto_register: True

example_config/wacca.yaml

@@ -1,6 +1,7 @@
 server:
   enable: True
   loglevel: "info"
+  prefecture_name: "Hokkaido"
 
 mods:
   always_vip: True

index.py

@@ -1,5 +1,8 @@
 #!/usr/bin/env python3
 import argparse
+import logging, coloredlogs
+from logging.handlers import TimedRotatingFileHandler
+from typing import Dict
 import yaml
 from os import path, mkdir, access, W_OK
 from core import *
@@ -9,6 +12,7 @@ from twisted.internet import reactor, endpoints
 from twisted.web.http import Request
 from routes import Mapper
 
+
 class HttpDispatcher(resource.Resource):
     def __init__(self, cfg: CoreConfig, config_dir: str):
         super().__init__()
@@ -16,118 +20,224 @@ class HttpDispatcher(resource.Resource):
         self.isLeaf = True
         self.map_get = Mapper()
         self.map_post = Mapper()
-        
+        self.logger = logging.getLogger("core")
+
         self.allnet = AllnetServlet(cfg, config_dir)
         self.title = TitleServlet(cfg, config_dir)
-        self.mucha = MuchaServlet(cfg)
+        self.mucha = MuchaServlet(cfg, config_dir)
 
-        self.map_post.connect('allnet_poweron', '/sys/servlet/PowerOn', controller="allnet", action='handle_poweron', conditions=dict(method=['POST']))
-        self.map_post.connect('allnet_downloadorder', '/sys/servlet/DownloadOrder', controller="allnet", action='handle_dlorder', conditions=dict(method=['POST']))
-        self.map_post.connect('allnet_billing', '/request', controller="allnet", action='handle_billing_request', conditions=dict(method=['POST']))
+        self.map_post.connect(
+            "allnet_ping",
+            "/naomitest.html",
+            controller="allnet",
+            action="handle_naomitest",
+            conditions=dict(method=["GET"]),
+        )
+        self.map_post.connect(
+            "allnet_poweron",
+            "/sys/servlet/PowerOn",
+            controller="allnet",
+            action="handle_poweron",
+            conditions=dict(method=["POST"]),
+        )
+        self.map_post.connect(
+            "allnet_downloadorder",
+            "/sys/servlet/DownloadOrder",
+            controller="allnet",
+            action="handle_dlorder",
+            conditions=dict(method=["POST"]),
+        )
+        self.map_post.connect(
+            "allnet_billing",
+            "/request",
+            controller="allnet",
+            action="handle_billing_request",
+            conditions=dict(method=["POST"]),
+        )
+        self.map_post.connect(
+            "allnet_billing",
+            "/request/",
+            controller="allnet",
+            action="handle_billing_request",
+            conditions=dict(method=["POST"]),
+        )
 
-        self.map_post.connect('mucha_boardauth', '/mucha/boardauth.do', controller="mucha", action='handle_boardauth', conditions=dict(method=['POST']))
-        self.map_post.connect('mucha_updatacheck', '/mucha/updatacheck.do', controller="mucha", action='handle_updatacheck', conditions=dict(method=['POST']))
+        self.map_post.connect(
+            "mucha_boardauth",
+            "/mucha/boardauth.do",
+            controller="mucha",
+            action="handle_boardauth",
+            conditions=dict(method=["POST"]),
+        )
+        self.map_post.connect(
+            "mucha_updatacheck",
+            "/mucha/updatacheck.do",
+            controller="mucha",
+            action="handle_updatecheck",
+            conditions=dict(method=["POST"]),
+        )
 
-        self.map_get.connect("title_get", "/{game}/{version}/{endpoint:.*?}", controller="title", action="render_GET", requirements=dict(game=R"S..."))
-        self.map_post.connect("title_post", "/{game}/{version}/{endpoint:.*?}", controller="title", action="render_POST", requirements=dict(game=R"S..."))
+        self.map_get.connect(
+            "title_get",
+            "/{game}/{version}/{endpoint:.*?}",
+            controller="title",
+            action="render_GET",
+            conditions=dict(method=["GET"]),
+            requirements=dict(game=R"S..."),
+        )
+        self.map_post.connect(
+            "title_post",
+            "/{game}/{version}/{endpoint:.*?}",
+            controller="title",
+            action="render_POST",
+            conditions=dict(method=["POST"]),
+            requirements=dict(game=R"S..."),
+        )
 
-    def render_POST(self, request: Request) -> bytes:    
+    def render_GET(self, request: Request) -> bytes:
+        self.logger.debug(request.uri)
         test = self.map_get.match(request.uri.decode())
-        if test is None:
-            return b""
+        client_ip = Utils.get_ip_addr(request)
 
-        controller = getattr(self, test["controller"], None)
+        if test is None:
+            self.logger.debug(
+                f"Unknown GET endpoint {request.uri.decode()} from {client_ip} to port {request.getHost().port}"
+            )
+            request.setResponseCode(404)
+            return b"Endpoint not found."
+
+        return self.dispatch(test, request)
+
+    def render_POST(self, request: Request) -> bytes:
+        test = self.map_post.match(request.uri.decode())
+        client_ip = Utils.get_ip_addr(request)
+
+        if test is None:
+            self.logger.debug(
+                f"Unknown POST endpoint {request.uri.decode()} from {client_ip} to port {request.getHost().port}"
+            )
+            request.setResponseCode(404)
+            return b"Endpoint not found."
+
+        return self.dispatch(test, request)
+
+    def dispatch(self, matcher: Dict, request: Request) -> bytes:
+        controller = getattr(self, matcher["controller"], None)
         if controller is None:
-            return b""
-        
-        handler = getattr(controller, test["action"], None)
+            self.logger.error(
+                f"Controller {matcher['controller']} not found via endpoint {request.uri.decode()}"
+            )
+            request.setResponseCode(404)
+            return b"Endpoint not found."
+
+        handler = getattr(controller, matcher["action"], None)
         if handler is None:
-            return b""
-        
-        url_vars = test
+            self.logger.error(
+                f"Action {matcher['action']} not found in controller {matcher['controller']} via endpoint {request.uri.decode()}"
+            )
+            request.setResponseCode(404)
+            return b"Endpoint not found."
+
+        url_vars = matcher
         url_vars.pop("controller")
         url_vars.pop("action")
-        
-        if len(url_vars) > 0:
-            ret = handler(request, url_vars)
-        else:
-            ret = handler(request)
-        
-        if type(ret) == str:
-            return ret.encode()
-        elif type(ret) == bytes:
-            return ret
-        else:
-            return b""
-
-    def render_POST(self, request: Request) -> bytes:    
-        test = self.map_post.match(request.uri.decode())
-        if test is None:
-            return b""
-
-        controller = getattr(self, test["controller"], None)
-        if controller is None:
-            return b""
-        
-        handler = getattr(controller, test["action"], None)
-        if handler is None:
-            return b""
-        
-        url_vars = test
-        url_vars.pop("controller")
-        url_vars.pop("action")        
         ret = handler(request, url_vars)
-        
+
         if type(ret) == str:
             return ret.encode()
         elif type(ret) == bytes:
             return ret
         else:
             return b""
-        
+
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="ARTEMiS main entry point")
-    parser.add_argument("--config", "-c", type=str, default="config", help="Configuration folder")
+    parser.add_argument(
+        "--config", "-c", type=str, default="config", help="Configuration folder"
+    )
     args = parser.parse_args()
 
     if not path.exists(f"{args.config}/core.yaml"):
-        print(f"The config folder you specified ({args.config}) does not exist or does not contain core.yaml.\nDid you copy the example folder?")
+        print(
+            f"The config folder you specified ({args.config}) does not exist or does not contain core.yaml.\nDid you copy the example folder?"
+        )
         exit(1)
 
     cfg: CoreConfig = CoreConfig()
-    cfg.update(yaml.safe_load(open(f"{args.config}/core.yaml")))
+    if path.exists(f"{args.config}/core.yaml"):
+        cfg.update(yaml.safe_load(open(f"{args.config}/core.yaml")))
 
     if not path.exists(cfg.server.log_dir):
         mkdir(cfg.server.log_dir)
-    
+
     if not access(cfg.server.log_dir, W_OK):
-        print(f"Log directory {cfg.server.log_dir} NOT writable, please check permissions")
+        print(
+            f"Log directory {cfg.server.log_dir} NOT writable, please check permissions"
+        )
         exit(1)
 
+    logger = logging.getLogger("core")
+    log_fmt_str = "[%(asctime)s] Core | %(levelname)s | %(message)s"
+    log_fmt = logging.Formatter(log_fmt_str)
+
+    fileHandler = TimedRotatingFileHandler(
+        "{0}/{1}.log".format(cfg.server.log_dir, "core"), when="d", backupCount=10
+    )
+    fileHandler.setFormatter(log_fmt)
+
+    consoleHandler = logging.StreamHandler()
+    consoleHandler.setFormatter(log_fmt)
+
+    logger.addHandler(fileHandler)
+    logger.addHandler(consoleHandler)
+
+    log_lv = logging.DEBUG if cfg.server.is_develop else logging.INFO
+    logger.setLevel(log_lv)
+    coloredlogs.install(level=log_lv, logger=logger, fmt=log_fmt_str)
+
     if not cfg.aimedb.key:
-        print("!!AIMEDB KEY BLANK, SET KEY IN CORE.YAML!!")
+        logger.error("!!AIMEDB KEY BLANK, SET KEY IN CORE.YAML!!")
         exit(1)
-    
-    print(f"ARTEMiS starting in {'develop' if cfg.server.is_develop else 'production'} mode")
 
-    allnet_server_str = f"tcp:{cfg.allnet.port}:interface={cfg.server.listen_address}"    
+    logger.info(
+        f"ARTEMiS starting in {'develop' if cfg.server.is_develop else 'production'} mode"
+    )
+
+    allnet_server_str = f"tcp:{cfg.allnet.port}:interface={cfg.server.listen_address}"
     title_server_str = f"tcp:{cfg.title.port}:interface={cfg.server.listen_address}"
     adb_server_str = f"tcp:{cfg.aimedb.port}:interface={cfg.server.listen_address}"
+    frontend_server_str = (
+        f"tcp:{cfg.frontend.port}:interface={cfg.server.listen_address}"
+    )
 
     billing_server_str = f"tcp:{cfg.billing.port}:interface={cfg.server.listen_address}"
     if cfg.server.is_develop:
-        billing_server_str = f"ssl:{cfg.billing.port}:interface={cfg.server.listen_address}"\
+        billing_server_str = (
+            f"ssl:{cfg.billing.port}:interface={cfg.server.listen_address}"
             f":privateKey={cfg.billing.ssl_key}:certKey={cfg.billing.ssl_cert}"
-    
+        )
+
     dispatcher = HttpDispatcher(cfg, args.config)
 
-    endpoints.serverFromString(reactor, allnet_server_str).listen(server.Site(dispatcher))
+    endpoints.serverFromString(reactor, allnet_server_str).listen(
+        server.Site(dispatcher)
+    )
     endpoints.serverFromString(reactor, adb_server_str).listen(AimedbFactory(cfg))
 
+    if cfg.frontend.enable:
+        endpoints.serverFromString(reactor, frontend_server_str).listen(
+            server.Site(FrontendServlet(cfg, args.config))
+        )
+
     if cfg.billing.port > 0:
-        endpoints.serverFromString(reactor, billing_server_str).listen(server.Site(dispatcher))
-    
-    if cfg.title.port > 0:        
-        endpoints.serverFromString(reactor, title_server_str).listen(server.Site(dispatcher))
-    
-    reactor.run() # type: ignore
+        endpoints.serverFromString(reactor, billing_server_str).listen(
+            server.Site(dispatcher)
+        )
+
+    if cfg.title.port > 0:
+        endpoints.serverFromString(reactor, title_server_str).listen(
+            server.Site(dispatcher)
+        )
+
+    reactor.run()  # type: ignore

read.py

@@ -3,65 +3,73 @@ import argparse
 import re
 import os
 import yaml
-import importlib
-import logging, coloredlogs
+from os import path
+import logging
+import coloredlogs
 
 from logging.handlers import TimedRotatingFileHandler
 from typing import List, Optional
 
-from core import CoreConfig
-from core.utils import Utils
+from core import CoreConfig, Utils
 
-class BaseReader():
-    def __init__(self, config: CoreConfig, version: int, bin_dir: Optional[str], opt_dir: Optional[str], extra: Optional[str]) -> None:
+
+class BaseReader:
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_dir: Optional[str],
+        opt_dir: Optional[str],
+        extra: Optional[str],
+    ) -> None:
         self.logger = logging.getLogger("reader")
         self.config = config
         self.bin_dir = bin_dir
         self.opt_dir = opt_dir
         self.version = version
         self.extra = extra
-    
-    
+
     def get_data_directories(self, directory: str) -> List[str]:
         ret: List[str] = []
 
         for root, dirs, files in os.walk(directory):
-                for dir in dirs:
-                    if re.fullmatch("[A-Z0-9]{4,4}", dir) is not None:
-                        ret.append(f"{root}/{dir}")
-        
+            for dir in dirs:
+                if re.fullmatch("[A-Z0-9]{4,4}", dir) is not None:
+                    ret.append(f"{root}/{dir}")
+
         return ret
 
+
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Import Game Information')
+    parser = argparse.ArgumentParser(description="Import Game Information")
     parser.add_argument(
-        '--series',
-        action='store',
+        "--series",
+        action="store",
         type=str,
         required=True,
-        help='The game series we are importing.',
+        help="The game series we are importing.",
     )
     parser.add_argument(
-        '--version',
-        dest='version',
-        action='store',
+        "--version",
+        dest="version",
+        action="store",
         type=int,
         required=True,
-        help='The game version we are importing.',
+        help="The game version we are importing.",
     )
     parser.add_argument(
-        '--binfolder',
-        dest='bin',
-        action='store',
+        "--binfolder",
+        dest="bin",
+        action="store",
         type=str,
-        help='Folder containing A000 base data',
+        help="Folder containing A000 base data",
     )
     parser.add_argument(
-        '--optfolder',
-        dest='opt',
-        action='store',
+        "--optfolder",
+        dest="opt",
+        action="store",
         type=str,
-        help='Folder containing Option data folders',
+        help="Folder containing Option data folders",
     )
     parser.add_argument(
         "--config",
@@ -79,29 +87,33 @@ if __name__ == "__main__":
     args = parser.parse_args()
 
     config = CoreConfig()
-    config.update(yaml.safe_load(open(f"{args.config}/core.yaml")))
+    if path.exists(f"{args.config}/core.yaml"):
+        config.update(yaml.safe_load(open(f"{args.config}/core.yaml")))
 
     log_fmt_str = "[%(asctime)s] Reader | %(levelname)s | %(message)s"
     log_fmt = logging.Formatter(log_fmt_str)
     logger = logging.getLogger("reader")
 
-    fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(config.server.logs, "reader"), when="d", backupCount=10)
+    fileHandler = TimedRotatingFileHandler(
+        "{0}/{1}.log".format(config.server.log_dir, "reader"), when="d", backupCount=10
+    )
     fileHandler.setFormatter(log_fmt)
-    
+
     consoleHandler = logging.StreamHandler()
     consoleHandler.setFormatter(log_fmt)
 
     logger.addHandler(fileHandler)
     logger.addHandler(consoleHandler)
-    
-    logger.setLevel(logging.INFO)
-    coloredlogs.install(level=logging.INFO, logger=logger, fmt=log_fmt_str)
+
+    log_lv = logging.DEBUG if config.server.is_develop else logging.INFO
+    logger.setLevel(log_lv)
+    coloredlogs.install(level=log_lv, logger=logger, fmt=log_fmt_str)
 
     if args.series is None or args.version is None:
         logger.error("Game or version not specified")
         parser.print_help()
-        exit(1) 
-    
+        exit(1)
+
     if args.bin is None and args.opt is None:
         logger.error("Must specify either bin or opt directory")
         parser.print_help()
@@ -111,7 +123,7 @@ if __name__ == "__main__":
         bin_arg = args.bin[:-1]
     else:
         bin_arg = args.bin
-    
+
     if args.opt is not None and (args.opt.endswith("\\") or args.opt.endswith("/")):
         opt_arg = args.opt[:-1]
     else:
@@ -123,7 +135,8 @@ if __name__ == "__main__":
 
     for dir, mod in titles.items():
         if args.series in mod.game_codes:
-            handler = mod.reader(config, args.version, bin_arg, opt_arg, args.extra)
+            handler = mod.reader(config, args.version,
+                                 bin_arg, opt_arg, args.extra)
             handler.read()
-    
+
     logger.info("Done")

readme.md

@@ -9,14 +9,18 @@ Games listed below have been tested and confirmed working. Only game versions ol
 + Crossbeats Rev
     + All versions + omnimix
 
-+ Maimai
-    + All versions up to Universe Plus
++ maimai DX
+    + All versions up to Festival
 
 + Hatsune Miku Arcade
     + All versions
 
++ Card Maker
+    + 1.34.xx
+    + 1.35.xx
+
 + Ongeki
-    + All versions up to Bright
+    + All versions up to Bright Memory
 
 + Wacca
     + Lily R
@@ -29,10 +33,11 @@ Games listed below have been tested and confirmed working. Only game versions ol
 - memcached (for non-windows platforms)
 - mysql/mariadb server
 
-## Quick start guide
-1) Clone this repository
-2) Install requirements (see the platform-specific guides for instructions)
-3) Install python libraries via `pip`
-4) Copy the example configuration files into another folder (by default the server looks for the `config` directory)
-5) Edit the newly copied configuration files to your liking, using [this](docs/config.md) doc as a guide.
-6) Run the server by invoking `index.py` ex. `python3 index.py`
+## Setup guides
+Follow the platform-specific guides for [windows](docs/INSTALL_WINDOWS.md) and [ubuntu](docs/INSTALL_UBUNTU.md) to setup and run the server.
+
+## Game specific information
+Read [Games specific info](docs/game_specific_info.md) for all supported games, importer settings, configuration option and database upgrades.
+
+## Production guide
+See the [production guide](docs/prod.md) for running a production server.

requirements.txt

@@ -10,6 +10,9 @@ service_identity
 PyCryptodome
 inflection
 coloredlogs
-pylibmc
+pylibmc; platform_system != "Windows"
 wacky
 Routes
+bcrypt
+jinja2
+protobuf

requirements_win.txt

@@ -1,14 +0,0 @@
-mypy
-wheel
-twisted
-pytz
-pyyaml
-sqlalchemy==1.4.46
-mysqlclient
-pyopenssl
-service_identity
-PyCryptodome
-inflection
-coloredlogs
-wacky
-Routes

titles/chuni/__init__.py

@@ -6,13 +6,5 @@ from titles.chuni.read import ChuniReader
 index = ChuniServlet
 database = ChuniData
 reader = ChuniReader
-
-use_default_title = True
-include_protocol = True
-title_secure = False
 game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW]
-trailing_slash = True
-use_default_host = False
-host = ""
-
-current_schema_version = 1
+current_schema_version = 3

titles/chuni/air.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAir(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AIR
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.10.00"
-        return ret
+        return ret

titles/chuni/airplus.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAirPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AIR_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.15.00"
-        return ret
+        return ret

titles/chuni/amazon.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAmazon(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AMAZON
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.30.00"
         return ret

titles/chuni/amazonplus.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniAmazonPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_AMAZON_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.35.00"
         return ret

titles/chuni/base.py

@@ -11,7 +11,8 @@ from titles.chuni.const import ChuniConstants
 from titles.chuni.database import ChuniData
 from titles.chuni.config import ChuniConfig
 
-class ChuniBase():
+
+class ChuniBase:
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = game_cfg
@@ -20,38 +21,139 @@ class ChuniBase():
         self.logger = logging.getLogger("chuni")
         self.game = ChuniConstants.GAME_CODE
         self.version = ChuniConstants.VER_CHUNITHM
-    
+
     def handle_game_login_api_request(self, data: Dict) -> Dict:
-        #self.data.base.log_event("chuni", "login", logging.INFO, {"version": self.version, "user": data["userId"]})
-        return { "returnCode": 1 }
-    
+        """
+        Handles the login bonus logic, required for the game because
+        getUserLoginBonus gets called after getUserItem and therefore the
+        items needs to be inserted in the database before they get requested.
+
+        Adds a bonusCount after a user logged in after 24 hours, makes sure
+        loginBonus 30 gets looped, only show the login banner every 24 hours,
+        adds the bonus to items (itemKind 6)
+        """
+
+        # ignore the login bonus if disabled in config
+        if not self.game_cfg.mods.use_login_bonus:
+            return {"returnCode": 1}
+
+        user_id = data["userId"]
+        login_bonus_presets = self.data.static.get_login_bonus_presets(self.version)
+
+        for preset in login_bonus_presets:
+            # check if a user already has some pogress and if not add the
+            # login bonus entry
+            user_login_bonus = self.data.item.get_login_bonus(
+                user_id, self.version, preset["id"]
+            )
+            if user_login_bonus is None:
+                self.data.item.put_login_bonus(user_id, self.version, preset["id"])
+                # yeah i'm lazy
+                user_login_bonus = self.data.item.get_login_bonus(
+                    user_id, self.version, preset["id"]
+                )
+
+            # skip the login bonus entirely if its already finished
+            if user_login_bonus["isFinished"]:
+                continue
+
+            # make sure the last login is more than 24 hours ago
+            if user_login_bonus["lastUpdateDate"] < datetime.now() - timedelta(
+                hours=24
+            ):
+                # increase the login day counter and update the last login date
+                bonus_count = user_login_bonus["bonusCount"] + 1
+                last_update_date = datetime.now()
+
+                all_login_boni = self.data.static.get_login_bonus(
+                    self.version, preset["id"]
+                )
+
+                # 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']}"
+                    )
+                    continue
+
+                max_needed_days = all_login_boni[0]["needLoginDayCount"]
+
+                # make sure to not show login boni after all days got redeemed
+                is_finished = False
+                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:
+                        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
+                )
+                if login_item is not None:
+                    # now add the present to the database so the
+                    # handle_get_user_item_api_request can grab them
+                    self.data.item.put_item(
+                        user_id,
+                        {
+                            "itemId": login_item["presentId"],
+                            "itemKind": 6,
+                            "stock": login_item["itemNum"],
+                            "isValid": True,
+                        },
+                    )
+
+                self.data.item.put_login_bonus(
+                    user_id,
+                    self.version,
+                    preset["id"],
+                    bonusCount=bonus_count,
+                    lastUpdateDate=last_update_date,
+                    isWatched=False,
+                    isFinished=is_finished,
+                )
+
+        return {"returnCode": 1}
+
     def handle_game_logout_api_request(self, data: Dict) -> Dict:
-        #self.data.base.log_event("chuni", "logout", logging.INFO, {"version": self.version, "user": data["userId"]})
-        return { "returnCode": 1 }
+        # self.data.base.log_event("chuni", "logout", logging.INFO, {"version": self.version, "user": data["userId"]})
+        return {"returnCode": 1}
 
     def handle_get_game_charge_api_request(self, data: Dict) -> Dict:
         game_charge_list = self.data.static.get_enabled_charges(self.version)
 
+        if game_charge_list is None or len(game_charge_list) == 0:
+            return {"length": 0, "gameChargeList": []}
+
         charges = []
-        for x in range(len(game_charge_list)):            
-            charges.append({
-                "orderId": x,
-                "chargeId": game_charge_list[x]["chargeId"],
-                "price": 1,
-                "startDate": "2017-12-05 07:00:00.0", 
-                "endDate": "2099-12-31 00:00:00.0", 
-                "salePrice": 1, 
-                "saleStartDate": "2017-12-05 07:00:00.0", 
-                "saleEndDate": "2099-12-31 00:00:00.0"
-            })
-        return {
-            "length": len(charges), 
-            "gameChargeList": charges
-        }
+        for x in range(len(game_charge_list)):
+            charges.append(
+                {
+                    "orderId": x,
+                    "chargeId": game_charge_list[x]["chargeId"],
+                    "price": 1,
+                    "startDate": "2017-12-05 07:00:00.0",
+                    "endDate": "2099-12-31 00:00:00.0",
+                    "salePrice": 1,
+                    "saleStartDate": "2017-12-05 07:00:00.0",
+                    "saleEndDate": "2099-12-31 00:00:00.0",
+                }
+            )
+        return {"length": len(charges), "gameChargeList": charges}
 
     def handle_get_game_event_api_request(self, data: Dict) -> Dict:
         game_events = self.data.static.get_enabled_events(self.version)
 
+        if game_events is None or len(game_events) == 0:
+            self.logger.warn("No enabled events, did you run the reader?")
+            return {
+                "type": data["type"],
+                "length": 0,
+                "gameEventList": [],
+            }
+
         event_list = []
         for evt_row in game_events:
             tmp = {}
@@ -62,26 +164,30 @@ class ChuniBase():
             event_list.append(tmp)
 
         return {
-            "type": data["type"], 
-            "length": len(event_list), 
-            "gameEventList": event_list
+            "type": data["type"],
+            "length": len(event_list),
+            "gameEventList": event_list,
         }
 
     def handle_get_game_idlist_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "length": 0, "gameIdlistList": [] }
+        return {"type": data["type"], "length": 0, "gameIdlistList": []}
 
     def handle_get_game_message_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "length": "0", "gameMessageList": [] }
+        return {"type": data["type"], "length": "0", "gameMessageList": []}
 
     def handle_get_game_ranking_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "gameRankingList": [] }
+        return {"type": data["type"], "gameRankingList": []}
 
     def handle_get_game_sale_api_request(self, data: Dict) -> Dict:
-        return { "type": data["type"], "length": 0, "gameSaleList": [] }
+        return {"type": data["type"], "length": 0, "gameSaleList": []}
 
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        reboot_start = datetime.strftime(datetime.now() - timedelta(hours=4), self.date_time_format)
-        reboot_end = datetime.strftime(datetime.now() - timedelta(hours=3), self.date_time_format)
+        reboot_start = datetime.strftime(
+            datetime.now() - timedelta(hours=4), self.date_time_format
+        )
+        reboot_end = datetime.strftime(
+            datetime.now() - timedelta(hours=3), self.date_time_format
+        )
         return {
             "gameSetting": {
                 "dataVersion": "1.00.00",
@@ -94,15 +200,17 @@ class ChuniBase():
                 "maxCountItem": 300,
                 "maxCountMusic": 300,
             },
-                "isDumpUpload": "false",
-                "isAou": "false",
+            "isDumpUpload": "false",
+            "isAou": "false",
         }
 
     def handle_get_user_activity_api_request(self, data: Dict) -> Dict:
-        user_activity_list = self.data.profile.get_profile_activity(data["userId"], data["kind"])
-        
+        user_activity_list = self.data.profile.get_profile_activity(
+            data["userId"], data["kind"]
+        )
+
         activity_list = []
-        
+
         for activity in user_activity_list:
             tmp = activity._asdict()
             tmp.pop("user")
@@ -111,15 +219,16 @@ class ChuniBase():
             activity_list.append(tmp)
 
         return {
-          "userId": data["userId"], 
-          "length": len(activity_list),
-          "kind": data["kind"],
-          "userActivityList": activity_list
+            "userId": data["userId"],
+            "length": len(activity_list),
+            "kind": int(data["kind"]),
+            "userActivityList": activity_list,
         }
 
     def handle_get_user_character_api_request(self, data: Dict) -> Dict:
         characters = self.data.item.get_characters(data["userId"])
-        if characters is None: return {}
+        if characters is None:
+            return {}
         next_idx = -1
 
         characterList = []
@@ -131,15 +240,17 @@ class ChuniBase():
 
             if len(characterList) >= int(data["maxCount"]):
                 break
-        
-        if len(characterList) >= int(data["maxCount"]) and len(characters) > int(data["maxCount"]) + int(data["nextIndex"]):
+
+        if len(characterList) >= int(data["maxCount"]) and len(characters) > int(
+            data["maxCount"]
+        ) + int(data["nextIndex"]):
             next_idx = int(data["maxCount"]) + int(data["nextIndex"]) + 1
-        
+
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(characterList),
-            "nextIndex": next_idx, 
-            "userCharacterList": characterList
+            "nextIndex": next_idx,
+            "userCharacterList": characterList,
         }
 
     def handle_get_user_charge_api_request(self, data: Dict) -> Dict:
@@ -153,21 +264,21 @@ class ChuniBase():
             charge_list.append(tmp)
 
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(charge_list),
-            "userChargeList": charge_list
+            "userChargeList": charge_list,
         }
 
     def handle_get_user_course_api_request(self, data: Dict) -> Dict:
         user_course_list = self.data.score.get_courses(data["userId"])
-        if user_course_list is None: 
+        if user_course_list is None:
             return {
-                "userId": data["userId"], 
+                "userId": data["userId"],
                 "length": 0,
-                "nextIndex": -1, 
-                "userCourseList": []
+                "nextIndex": -1,
+                "userCourseList": [],
             }
-        
+
         course_list = []
         next_idx = int(data["nextIndex"])
         max_ct = int(data["maxCount"])
@@ -180,51 +291,48 @@ class ChuniBase():
 
             if len(user_course_list) >= max_ct:
                 break
-        
+
         if len(user_course_list) >= max_ct:
             next_idx = next_idx + max_ct
         else:
             next_idx = -1
-                
+
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(course_list),
-            "nextIndex": next_idx, 
-            "userCourseList": course_list
+            "nextIndex": next_idx,
+            "userCourseList": course_list,
         }
 
     def handle_get_user_data_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_data(data["userId"], self.version)
-        if p is None: return {}
+        if p is None:
+            return {}
 
         profile = p._asdict()
         profile.pop("id")
         profile.pop("user")
         profile.pop("version")
 
-        return {
-            "userId": data["userId"], 
-            "userData": profile
-        }
+        return {"userId": data["userId"], "userData": profile}
 
     def handle_get_user_data_ex_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_data_ex(data["userId"], self.version)
-        if p is None: return {}
+        if p is None:
+            return {}
 
         profile = p._asdict()
         profile.pop("id")
         profile.pop("user")
         profile.pop("version")
 
-        return {
-            "userId": data["userId"], 
-            "userDataEx": profile
-        }
+        return {"userId": data["userId"], "userDataEx": profile}
 
     def handle_get_user_duel_api_request(self, data: Dict) -> Dict:
         user_duel_list = self.data.item.get_duels(data["userId"])
-        if user_duel_list is None: return {}
-        
+        if user_duel_list is None:
+            return {}
+
         duel_list = []
         for duel in user_duel_list:
             tmp = duel._asdict()
@@ -233,18 +341,18 @@ class ChuniBase():
             duel_list.append(tmp)
 
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(duel_list),
-            "userDuelList": duel_list
+            "userDuelList": duel_list,
         }
 
     def handle_get_user_favorite_item_api_request(self, data: Dict) -> Dict:
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": 0,
-            "kind": data["kind"], 
-            "nextIndex": -1, 
-            "userFavoriteItemList": []
+            "kind": data["kind"],
+            "nextIndex": -1,
+            "userFavoriteItemList": [],
         }
 
     def handle_get_user_favorite_music_api_request(self, data: Dict) -> Dict:
@@ -252,22 +360,23 @@ class ChuniBase():
         This is handled via the webui, which we don't have right now
         """
 
-        return {
-            "userId": data["userId"], 
-            "length": 0,
-            "userFavoriteMusicList": []
-        }
+        return {"userId": data["userId"], "length": 0, "userFavoriteMusicList": []}
 
     def handle_get_user_item_api_request(self, data: Dict) -> Dict:
         kind = int(int(data["nextIndex"]) / 10000000000)
         next_idx = int(int(data["nextIndex"]) % 10000000000)
         user_item_list = self.data.item.get_items(data["userId"], kind)
 
-        if user_item_list is None or len(user_item_list) == 0: 
-            return {"userId": data["userId"], "nextIndex": -1, "itemKind": kind, "userItemList": []}
+        if user_item_list is None or len(user_item_list) == 0:
+            return {
+                "userId": data["userId"],
+                "nextIndex": -1,
+                "itemKind": kind,
+                "userItemList": [],
+            }
 
         items: list[Dict[str, Any]] = []
-        for i in range(next_idx, len(user_item_list)):            
+        for i in range(next_idx, len(user_item_list)):
             tmp = user_item_list[i]._asdict()
             tmp.pop("user")
             tmp.pop("id")
@@ -277,38 +386,50 @@ class ChuniBase():
 
         xout = kind * 10000000000 + next_idx + len(items)
 
-        if len(items) < int(data["maxCount"]): nextIndex = 0
-        else: nextIndex = xout
+        if len(items) < int(data["maxCount"]):
+            nextIndex = 0
+        else:
+            nextIndex = xout
 
-        return {"userId": data["userId"], "nextIndex": nextIndex, "itemKind": kind, "length": len(items), "userItemList": items}
+        return {
+            "userId": data["userId"],
+            "nextIndex": nextIndex,
+            "itemKind": kind,
+            "length": len(items),
+            "userItemList": items,
+        }
 
     def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
-        """
-        Unsure how to get this to trigger...
-        """
+        user_id = data["userId"]
+        user_login_bonus = self.data.item.get_all_login_bonus(user_id, self.version)
+        # ignore the loginBonus request if its disabled in config
+        if user_login_bonus is None or not self.game_cfg.mods.use_login_bonus:
+            return {"userId": user_id, "length": 0, "userLoginBonusList": []}
+
+        user_login_list = []
+        for bonus in user_login_bonus:
+            user_login_list.append(
+                {
+                    "presetId": bonus["presetId"],
+                    "bonusCount": bonus["bonusCount"],
+                    "lastUpdateDate": datetime.strftime(
+                        bonus["lastUpdateDate"], "%Y-%m-%d %H:%M:%S"
+                    ),
+                    "isWatched": bonus["isWatched"],
+                }
+            )
+
         return {
-            "userId": data["userId"], 
-            "length": 2,
-            "userLoginBonusList": [
-                {
-                "presetId": '10',
-                "bonusCount": '0',
-                "lastUpdateDate": "1970-01-01 09:00:00",
-                "isWatched": "true"
-                },
-                {
-                "presetId": '20',
-                "bonusCount": '0',
-                "lastUpdateDate": "1970-01-01 09:00:00",
-                "isWatched": "true"
-                },
-            ]
+            "userId": user_id,
+            "length": len(user_login_list),
+            "userLoginBonusList": user_login_list,
         }
 
     def handle_get_user_map_api_request(self, data: Dict) -> Dict:
         user_map_list = self.data.item.get_maps(data["userId"])
-        if user_map_list is None: return {}
-        
+        if user_map_list is None:
+            return {}
+
         map_list = []
         for map in user_map_list:
             tmp = map._asdict()
@@ -317,19 +438,19 @@ class ChuniBase():
             map_list.append(tmp)
 
         return {
-            "userId": data["userId"], 
+            "userId": data["userId"],
             "length": len(map_list),
-            "userMapList": map_list
+            "userMapList": map_list,
         }
 
     def handle_get_user_music_api_request(self, data: Dict) -> Dict:
         music_detail = self.data.score.get_scores(data["userId"])
-        if music_detail is None: 
+        if music_detail is None:
             return {
-                "userId": data["userId"], 
-                "length": 0, 
+                "userId": data["userId"],
+                "length": 0,
                 "nextIndex": -1,
-                "userMusicList": [] #240
+                "userMusicList": [],  # 240
             }
         song_list = []
         next_idx = int(data["nextIndex"])
@@ -340,66 +461,60 @@ class ChuniBase():
             tmp = music_detail[x]._asdict()
             tmp.pop("user")
             tmp.pop("id")
-            
+
             for song in song_list:
                 if song["userMusicDetailList"][0]["musicId"] == tmp["musicId"]:
                     found = True
                     song["userMusicDetailList"].append(tmp)
                     song["length"] = len(song["userMusicDetailList"])
-            
+
             if not found:
-                song_list.append({
-                    "length": 1,
-                    "userMusicDetailList": [tmp]
-                })
-            
+                song_list.append({"length": 1, "userMusicDetailList": [tmp]})
+
             if len(song_list) >= max_ct:
                 break
-        
+
         if len(song_list) >= max_ct:
             next_idx += max_ct
         else:
             next_idx = 0
 
         return {
-            "userId": data["userId"], 
-            "length": len(song_list), 
+            "userId": data["userId"],
+            "length": len(song_list),
             "nextIndex": next_idx,
-            "userMusicList": song_list #240
+            "userMusicList": song_list,  # 240
         }
 
     def handle_get_user_option_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_option(data["userId"])
-        
+
         option = p._asdict()
         option.pop("id")
         option.pop("user")
 
-        return {
-            "userId": data["userId"], 
-            "userGameOption": option
-        }
+        return {"userId": data["userId"], "userGameOption": option}
 
     def handle_get_user_option_ex_api_request(self, data: Dict) -> Dict:
         p = self.data.profile.get_profile_option_ex(data["userId"])
-        
+
         option = p._asdict()
         option.pop("id")
         option.pop("user")
 
-        return {
-            "userId": data["userId"], 
-            "userGameOptionEx": option
-        }
+        return {"userId": data["userId"], "userGameOptionEx": option}
 
     def read_wtf8(self, src):
         return bytes([ord(c) for c in src]).decode("utf-8")
 
     def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile_preview(data["userId"], self.version)
-        if profile is None: return None
-        profile_character = self.data.item.get_character(data["userId"], profile["characterId"])
-        
+        if profile is None:
+            return None
+        profile_character = self.data.item.get_character(
+            data["userId"], profile["characterId"]
+        )
+
         if profile_character is None:
             chara = {}
         else:
@@ -408,8 +523,8 @@ class ChuniBase():
             chara.pop("user")
 
         return {
-            "userId": data["userId"],    
-            # Current Login State            
+            "userId": data["userId"],
+            # Current Login State
             "isLogin": False,
             "lastLoginDate": profile["lastPlayDate"],
             # User Profile
@@ -421,22 +536,22 @@ class ChuniBase():
             "lastGameId": profile["lastGameId"],
             "lastRomVersion": profile["lastRomVersion"],
             "lastDataVersion": profile["lastDataVersion"],
-            "lastPlayDate": profile["lastPlayDate"],            
-            "trophyId": profile["trophyId"],  
+            "lastPlayDate": profile["lastPlayDate"],
+            "trophyId": profile["trophyId"],
             "nameplateId": profile["nameplateId"],
             # Current Selected Character
             "userCharacter": chara,
             # User Game Options
-            "playerLevel": profile["playerLevel"], 
-            "rating": profile["rating"], 
+            "playerLevel": profile["playerLevel"],
+            "rating": profile["rating"],
             "headphone": profile["headphone"],
-            "chargeState": "1",
+            "chargeState": 1,
             "userNameEx": profile["userName"],
         }
 
     def handle_get_user_recent_rating_api_request(self, data: Dict) -> Dict:
-        recet_rating_list = self.data.profile.get_profile_recent_rating(data["userId"])
-        if recet_rating_list is None: 
+        recent_rating_list = self.data.profile.get_profile_recent_rating(data["userId"])
+        if recent_rating_list is None:
             return {
                 "userId": data["userId"],
                 "length": 0,
@@ -445,8 +560,8 @@ class ChuniBase():
 
         return {
             "userId": data["userId"],
-            "length": len(recet_rating_list["recentRating"]),
-            "userRecentRatingList": recet_rating_list["recentRating"],
+            "length": len(recent_rating_list["recentRating"]),
+            "userRecentRatingList": recent_rating_list["recentRating"],
         }
 
     def handle_get_user_region_api_request(self, data: Dict) -> Dict:
@@ -458,12 +573,25 @@ class ChuniBase():
         }
 
     def handle_get_user_team_api_request(self, data: Dict) -> Dict:
-        # TODO: Team
+        # TODO: use the database "chuni_profile_team" with a GUI
+        team_name = self.game_cfg.team.team_name
+        if team_name == "":
+            return {"userId": data["userId"], "teamId": 0}
+
         return {
             "userId": data["userId"],
-            "teamId": 0
+            "teamId": 1,
+            "teamRank": 1,
+            "teamName": team_name,
+            "userTeamPoint": {
+                "userId": data["userId"],
+                "teamId": 1,
+                "orderId": 1,
+                "teamPoint": 1,
+                "aggrDate": data["playDate"],
+            },
         }
-    
+
     def handle_get_team_course_setting_api_request(self, data: Dict) -> Dict:
         return {
             "userId": data["userId"],
@@ -486,19 +614,30 @@ class ChuniBase():
 
         if "userData" in upsert:
             try:
-                upsert["userData"][0]["userName"] = self.read_wtf8(upsert["userData"][0]["userName"])
-            except: pass
+                upsert["userData"][0]["userName"] = self.read_wtf8(
+                    upsert["userData"][0]["userName"]
+                )
+            except:
+                pass
 
-            self.data.profile.put_profile_data(user_id, self.version, upsert["userData"][0])
+            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])
+            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])
+            self.data.profile.put_profile_option_ex(
+                user_id, upsert["userGameOptionEx"][0]
+            )
         if "userRecentRatingList" in upsert:
-            self.data.profile.put_profile_recent_rating(user_id, upsert["userRecentRatingList"])
-        
+            self.data.profile.put_profile_recent_rating(
+                user_id, upsert["userRecentRatingList"]
+            )
+
         if "userCharacterList" in upsert:
             for character in upsert["userCharacterList"]:
                 self.data.item.put_character(user_id, character)
@@ -514,7 +653,7 @@ class ChuniBase():
         if "userDuelList" in upsert:
             for duel in upsert["userDuelList"]:
                 self.data.item.put_duel(user_id, duel)
-        
+
         if "userItemList" in upsert:
             for item in upsert["userItemList"]:
                 self.data.item.put_item(user_id, item)
@@ -522,23 +661,23 @@ class ChuniBase():
         if "userActivityList" in upsert:
             for activity in upsert["userActivityList"]:
                 self.data.profile.put_profile_activity(user_id, activity)
-        
+
         if "userChargeList" in upsert:
             for charge in upsert["userChargeList"]:
                 self.data.profile.put_profile_charge(user_id, charge)
-        
+
         if "userMusicDetailList" in upsert:
             for song in upsert["userMusicDetailList"]:
                 self.data.score.put_score(user_id, song)
-        
+
         if "userPlaylogList" in upsert:
             for playlog in upsert["userPlaylogList"]:
                 self.data.score.put_playlog(user_id, playlog)
-        
+
         if "userTeamPoint" in upsert:
             # TODO: team stuff
             pass
-        
+
         if "userMapAreaList" in upsert:
             for map_area in upsert["userMapAreaList"]:
                 self.data.item.put_map_area(user_id, map_area)
@@ -551,22 +690,37 @@ class ChuniBase():
             for emoney in upsert["userEmoneyList"]:
                 self.data.profile.put_profile_emoney(user_id, emoney)
 
-        return { "returnCode": "1" }
+        if "userLoginBonusList" in upsert:
+            for login in upsert["userLoginBonusList"]:
+                self.data.item.put_login_bonus(
+                    user_id, self.version, login["presetId"], isWatched=True
+                )
+
+        return {"returnCode": "1"}
 
     def handle_upsert_user_chargelog_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        # add tickets after they got bought, this makes sure the tickets are
+        # still valid after an unsuccessful logout
+        self.data.profile.put_profile_charge(data["userId"], data["userCharge"])
+        return {"returnCode": "1"}
 
     def handle_upsert_client_bookkeeping_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_develop_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_error_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_setting_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
 
     def handle_upsert_client_testmode_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
+        return {"returnCode": "1"}
+
+    def handle_get_user_net_battle_data_api_request(self, data: Dict) -> Dict:
+        return {
+            "userId": data["userId"],
+            "userNetBattleData": {"recentNBSelectMusicList": []},
+        }

titles/chuni/config.py

@@ -1,36 +1,88 @@
 from core.config import CoreConfig
 from typing import Dict
 
-class ChuniServerConfig():
+
+class ChuniServerConfig:
     def __init__(self, parent_config: "ChuniConfig") -> None:
         self.__config = parent_config
-    
+
     @property
     def enable(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'chuni', 'server', 'enable', default=True)
-    
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "server", "enable", default=True
+        )
+
     @property
     def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(CoreConfig.get_config_field(self.__config, 'chuni', 'server', 'loglevel', default="info"))
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "chuni", "server", "loglevel", default="info"
+            )
+        )
 
-class ChuniCryptoConfig():
+
+class ChuniTeamConfig:
     def __init__(self, parent_config: "ChuniConfig") -> None:
         self.__config = parent_config
-    
+
+    @property
+    def team_name(self) -> str:
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "team", "name", default=""
+        )
+
+
+class ChuniModsConfig:
+    def __init__(self, parent_config: "ChuniConfig") -> None:
+        self.__config = parent_config
+
+    @property
+    def use_login_bonus(self) -> bool:
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "mods", "use_login_bonus", default=True
+        )
+
+
+class ChuniVersionConfig:
+    def __init__(self, parent_config: "ChuniConfig") -> None:
+        self.__config = parent_config
+
+    def version(self, version: int) -> Dict:
+        """
+        in the form of:
+        11: {"rom": 2.00.00, "data": 2.00.00}
+        """
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "version", default={}
+        )[version]
+
+
+class ChuniCryptoConfig:
+    def __init__(self, parent_config: "ChuniConfig") -> None:
+        self.__config = parent_config
+
     @property
     def keys(self) -> Dict:
         """
         in the form of:
-        internal_version: [key, iv]        
+        internal_version: [key, iv]
         all values are hex strings
         """
-        return CoreConfig.get_config_field(self.__config, 'chuni', 'crypto', 'keys', default={})
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "crypto", "keys", default={}
+        )
 
     @property
     def encrypted_only(self) -> bool:
-        return CoreConfig.get_config_field(self.__config, 'chuni', 'crypto', 'encrypted_only', default=False)
+        return CoreConfig.get_config_field(
+            self.__config, "chuni", "crypto", "encrypted_only", default=False
+        )
+
 
 class ChuniConfig(dict):
     def __init__(self) -> None:
         self.server = ChuniServerConfig(self)
-        self.crypto = ChuniCryptoConfig(self)
+        self.team = ChuniTeamConfig(self)
+        self.mods = ChuniModsConfig(self)
+        self.version = ChuniVersionConfig(self)
+        self.crypto = ChuniCryptoConfig(self)

titles/chuni/const.py

@@ -1,12 +1,14 @@
-class ChuniConstants():
+class ChuniConstants:
     GAME_CODE = "SDBT"
     GAME_CODE_NEW = "SDHD"
 
+    CONFIG_NAME = "chuni.yaml"
+
     VER_CHUNITHM = 0
     VER_CHUNITHM_PLUS = 1
     VER_CHUNITHM_AIR = 2
     VER_CHUNITHM_AIR_PLUS = 3
-    VER_CHUNITHM_STAR = 4 
+    VER_CHUNITHM_STAR = 4
     VER_CHUNITHM_STAR_PLUS = 5
     VER_CHUNITHM_AMAZON = 6
     VER_CHUNITHM_AMAZON_PLUS = 7
@@ -16,8 +18,21 @@ class ChuniConstants():
     VER_CHUNITHM_NEW = 11
     VER_CHUNITHM_NEW_PLUS = 12
 
-    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!!+"]
+    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!!+",
+    ]
 
     @classmethod
     def game_ver_to_string(cls, ver: int):

titles/chuni/crystal.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniCrystal(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_CRYSTAL
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.40.00"
         return ret

titles/chuni/crystalplus.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniCrystalPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_CRYSTAL_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.45.00"
         return ret

titles/chuni/database.py

@@ -2,6 +2,7 @@ from core.data import Data
 from core.config import CoreConfig
 from titles.chuni.schema import *
 
+
 class ChuniData(Data):
     def __init__(self, cfg: CoreConfig) -> None:
         super().__init__(cfg)
@@ -9,4 +10,4 @@ class ChuniData(Data):
         self.item = ChuniItemData(cfg, self.session)
         self.profile = ChuniProfileData(cfg, self.session)
         self.score = ChuniScoreData(cfg, self.session)
-        self.static = ChuniStaticData(cfg, self.session)
+        self.static = ChuniStaticData(cfg, self.session)

titles/chuni/index.py

@@ -8,8 +8,12 @@ import inflection
 import string
 from Crypto.Cipher import AES
 from Crypto.Util.Padding import pad
+from Crypto.Protocol.KDF import PBKDF2
+from Crypto.Hash import SHA1
+from os import path
+from typing import Tuple, Dict
 
-from core import CoreConfig
+from core import CoreConfig, Utils
 from titles.chuni.config import ChuniConfig
 from titles.chuni.const import ChuniConstants
 from titles.chuni.base import ChuniBase
@@ -26,26 +30,31 @@ from titles.chuni.paradise import ChuniParadise
 from titles.chuni.new import ChuniNew
 from titles.chuni.newplus import ChuniNewPlus
 
-class ChuniServlet():
+
+class ChuniServlet:
     def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
         self.core_cfg = core_cfg
         self.game_cfg = ChuniConfig()
-        self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/chuni.yaml")))
+        self.hash_table: Dict[Dict[str, str]] = {}
+        if path.exists(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"):
+            self.game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"))
+            )
 
         self.versions = [
-            ChuniBase(core_cfg, self.game_cfg),
-            ChuniPlus(core_cfg, self.game_cfg),
-            ChuniAir(core_cfg, self.game_cfg),
-            ChuniAirPlus(core_cfg, self.game_cfg),
-            ChuniStar(core_cfg, self.game_cfg),
-            ChuniStarPlus(core_cfg, self.game_cfg),
-            ChuniAmazon(core_cfg, self.game_cfg),
-            ChuniAmazonPlus(core_cfg, self.game_cfg),
-            ChuniCrystal(core_cfg, self.game_cfg),
-            ChuniCrystalPlus(core_cfg, self.game_cfg),
-            ChuniParadise(core_cfg, self.game_cfg),
-            ChuniNew(core_cfg, self.game_cfg),
-            ChuniNewPlus(core_cfg, self.game_cfg),
+            ChuniBase,
+            ChuniPlus,
+            ChuniAir,
+            ChuniAirPlus,
+            ChuniStar,
+            ChuniStarPlus,
+            ChuniAmazon,
+            ChuniAmazonPlus,
+            ChuniCrystal,
+            ChuniCrystalPlus,
+            ChuniParadise,
+            ChuniNew,
+            ChuniNewPlus,
         ]
 
         self.logger = logging.getLogger("chuni")
@@ -53,120 +62,191 @@ class ChuniServlet():
         if not hasattr(self.logger, "inited"):
             log_fmt_str = "[%(asctime)s] Chunithm | %(levelname)s | %(message)s"
             log_fmt = logging.Formatter(log_fmt_str)
-            fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.core_cfg.server.log_dir, "chuni"), encoding='utf8', 
-                when="d", backupCount=10)
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.core_cfg.server.log_dir, "chuni"),
+                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)
+            coloredlogs.install(
+                level=self.game_cfg.server.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
             self.logger.inited = True
+        
+        for version, keys in self.game_cfg.crypto.keys.items():
+            if len(keys) < 3:
+                continue
+            
+            self.hash_table[version] = {}
+            
+            method_list = [method for method in dir(self.versions[version]) if not method.startswith('__')]
+            for method in method_list:
+                method_fixed = inflection.camelize(method)[6:-7]
+                hash = PBKDF2(method_fixed, bytes.fromhex(keys[2]), 128, count=44, hmac_hash_module=SHA1)
+                
+                self.hash_table[version][hash.hex()] = method_fixed
+                
+                self.logger.debug(f"Hashed v{version} method {method_fixed} with {bytes.fromhex(keys[2])} to get {hash.hex()}")
+
+    @classmethod
+    def get_allnet_info(
+        cls, game_code: str, core_cfg: CoreConfig, cfg_dir: str
+    ) -> Tuple[bool, str, str]:
+        game_cfg = ChuniConfig()
+        if path.exists(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"):
+            game_cfg.update(
+                yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"))
+            )
+
+        if not game_cfg.server.enable:
+            return (False, "", "")
+
+        if core_cfg.server.is_develop:
+            return (
+                True,
+                f"http://{core_cfg.title.hostname}:{core_cfg.title.port}/{game_code}/$v/",
+                "",
+            )
+
+        return (True, f"http://{core_cfg.title.hostname}/{game_code}/$v/", "")
 
     def render_POST(self, request: Request, version: int, url_path: str) -> bytes:
+        if url_path.lower() == "ping":
+            return zlib.compress(b'{"returnCode": "1"}')
+
         req_raw = request.content.getvalue()
         url_split = url_path.split("/")
         encrtped = False
         internal_ver = 0
         endpoint = url_split[len(url_split) - 1]
+        client_ip = Utils.get_ip_addr(request)
 
-        if version < 105: # 1.0
+        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
 
         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 
-            # doing encrypted. The likelyhood of false positives is low but 
+            # If we get a 32 character long hex string, it's a hash and we're
+            # doing encrypted. The likelyhood of false positives is low but
             # technically not 0
-            endpoint = request.getHeader("User-Agent").split("#")[0]
+            if internal_ver < ChuniConstants.VER_CHUNITHM_NEW:
+                endpoint = request.getHeader("User-Agent").split("#")[0]
+            
+            else:
+                if internal_ver not in self.hash_table:
+                    self.logger.error(f"v{version} does not support encryption or no keys entered")
+                    return zlib.compress(b'{"stat": "0"}')
+                
+                elif endpoint.lower() not in self.hash_table[internal_ver]:
+                    self.logger.error(f"No hash found for v{version} endpoint {endpoint}")
+                    return zlib.compress(b'{"stat": "0"}')
+
+                endpoint = self.hash_table[internal_ver][endpoint.lower()]
+            
             try:
                 crypt = AES.new(
-                    bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][0]), 
-                    AES.MODE_CBC, 
-                    bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][1])
+                    bytes.fromhex(self.game_cfg.crypto.keys[internal_ver][0]),
+                    AES.MODE_CBC,
+                    bytes.fromhex(self.game_cfg.crypto.keys[internal_ver][1]),
                 )
 
                 req_raw = crypt.decrypt(req_raw)
 
-            except:
-                self.logger.error(f"Failed to decrypt v{version} request to {endpoint} -> {req_raw}")
-                return zlib.compress("{\"stat\": \"0\"}".encode("utf-8"))
+            except Exception as e:
+                self.logger.error(
+                    f"Failed to decrypt v{version} request to {endpoint} -> {e}"
+                )
+                return zlib.compress(b'{"stat": "0"}')
 
             encrtped = True
-        
-        if not encrtped and self.game_cfg.crypto.encrypted_only:
-            self.logger.error(f"Unencrypted v{version} {endpoint} request, but config is set to encrypted only: {req_raw}")
-            return zlib.compress("{\"stat\": \"0\"}".encode("utf-8"))
 
-        try:            
-            unzip = zlib.decompress(req_raw)
-            
-        except zlib.error as e:
-            self.logger.error(f"Failed to decompress v{version} {endpoint} request -> {e}")
-            return b""
-        
-        req_data = json.loads(unzip)
-        
-        self.logger.info(f"v{version} {endpoint} request - {req_data}")
-
-        func_to_find = "handle_" + inflection.underscore(endpoint) + "_request"
+        if not encrtped and self.game_cfg.crypto.encrypted_only and internal_ver >= ChuniConstants.VER_CHUNITHM_CRYSTAL_PLUS:
+            self.logger.error(
+                f"Unencrypted v{version} {endpoint} request, but config is set to encrypted only: {req_raw}"
+            )
+            return zlib.compress(b'{"stat": "0"}')
 
         try:
-            handler = getattr(self.versions[internal_ver], func_to_find)
-            resp = handler(req_data)
-            
-        except AttributeError as e: 
-            self.logger.warning(f"Unhandled v{version} request {endpoint} - {e}")
-            return zlib.compress("{\"stat\": \"0\"}".encode("utf-8"))
+            unzip = zlib.decompress(req_raw)
+
+        except zlib.error as e:
+            self.logger.error(
+                f"Failed to decompress v{version} {endpoint} request -> {e}"
+            )
+            return b""
+
+        req_data = json.loads(unzip)
+
+        self.logger.info(
+            f"v{version} {endpoint} request from {client_ip}"
+        )
+        self.logger.debug(req_data)
+
+        func_to_find = "handle_" + inflection.underscore(endpoint) + "_request"
+        handler_cls = self.versions[internal_ver](self.core_cfg, self.game_cfg)
+
+        if not hasattr(handler_cls, func_to_find):
+            self.logger.warning(f"Unhandled v{version} request {endpoint}")
+            resp = {"returnCode": 1}
+
+        else:
+            try:
+                handler = getattr(handler_cls, func_to_find)
+                resp = handler(req_data)
+
+            except Exception as e:
+                self.logger.error(f"Error handling v{version} method {endpoint} - {e}")
+                return zlib.compress(b'{"stat": "0"}')
 
-        except Exception as e:
-            self.logger.error(f"Error handling v{version} method {endpoint} - {e}")
-            return zlib.compress("{\"stat\": \"0\"}".encode("utf-8"))
-        
         if resp == None:
-            resp = {'returnCode': 1}
-        
-        self.logger.info(f"Response {resp}")
-        
+            resp = {"returnCode": 1}
+
+        self.logger.debug(f"Response {resp}")
+
         zipped = zlib.compress(json.dumps(resp, ensure_ascii=False).encode("utf-8"))
-        
+
         if not encrtped:
             return zipped
 
         padded = pad(zipped, 16)
 
         crypt = AES.new(
-            bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][0]), 
-            AES.MODE_CBC, 
-            bytes.fromhex(self.game_cfg.crypto.keys[str(internal_ver)][1])
+            bytes.fromhex(self.game_cfg.crypto.keys[internal_ver][0]),
+            AES.MODE_CBC,
+            bytes.fromhex(self.game_cfg.crypto.keys[internal_ver][1]),
         )
 
         return crypt.encrypt(padded)

titles/chuni/new.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime, timedelta
-
+from random import randint
 from typing import Dict
 
 from core.config import CoreConfig
@@ -9,13 +9,9 @@ from titles.chuni.database import ChuniData
 from titles.chuni.base import ChuniBase
 from titles.chuni.config import ChuniConfig
 
-class ChuniNew(ChuniBase):
 
-    ITEM_TYPE = {
-        "character": 20,
-        "story": 21,
-        "card": 22
-    }
+class ChuniNew(ChuniBase):
+    ITEM_TYPE = {"character": 20, "story": 21, "card": 22}
 
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         self.core_cfg = core_cfg
@@ -25,12 +21,20 @@ class ChuniNew(ChuniBase):
         self.logger = logging.getLogger("chuni")
         self.game = ChuniConstants.GAME_CODE
         self.version = ChuniConstants.VER_CHUNITHM_NEW
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        match_start = datetime.strftime(datetime.now() - timedelta(hours=10), self.date_time_format)
-        match_end = datetime.strftime(datetime.now() + timedelta(hours=10), self.date_time_format)
-        reboot_start = datetime.strftime(datetime.now() - timedelta(hours=11), self.date_time_format)
-        reboot_end = datetime.strftime(datetime.now() - timedelta(hours=10), self.date_time_format)
+        match_start = datetime.strftime(
+            datetime.now() - timedelta(hours=10), self.date_time_format
+        )
+        match_end = datetime.strftime(
+            datetime.now() + timedelta(hours=10), self.date_time_format
+        )
+        reboot_start = datetime.strftime(
+            datetime.now() - timedelta(hours=11), self.date_time_format
+        )
+        reboot_end = datetime.strftime(
+            datetime.now() - timedelta(hours=10), self.date_time_format
+        )
         return {
             "gameSetting": {
                 "isMaintenance": "false",
@@ -45,23 +49,26 @@ class ChuniNew(ChuniBase):
                 "matchEndTime": match_end,
                 "matchTimeLimit": 99,
                 "matchErrorLimit": 9999,
-                "romVersion": "2.00.00",
-                "dataVersion": "2.00.00",
-                "matchingUri": f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
-                "matchingUriX": f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
-                "udpHolePunchUri": f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
-                "reflectorUri": f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/200/ChuniServlet/",
+                "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/",
+                "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:
+        return {"returnCode": "1"}
+
     def handle_delete_token_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
-    
+        return {"returnCode": "1"}
+
     def handle_create_token_api_request(self, data: Dict) -> Dict:
-        return { "returnCode": "1" }
-        
+        return {"returnCode": "1"}
+
     def handle_get_user_map_area_api_request(self, data: Dict) -> Dict:
         user_map_areas = self.data.item.get_map_areas(data["userId"])
 
@@ -72,32 +79,29 @@ class ChuniNew(ChuniBase):
             tmp.pop("user")
             map_areas.append(tmp)
 
-        return {
-            "userId": data["userId"], 
-            "userMapAreaList": map_areas
-        }
-    
+        return {"userId": data["userId"], "userMapAreaList": map_areas}
+
     def handle_get_user_symbol_chat_setting_api_request(self, data: Dict) -> Dict:
-        return {
-            "userId": data["userId"], 
-            "symbolCharInfoList": []
-        }
+        return {"userId": data["userId"], "symbolCharInfoList": []}
 
     def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
         profile = self.data.profile.get_profile_preview(data["userId"], self.version)
-        if profile is None: return None
-        profile_character = self.data.item.get_character(data["userId"], profile["characterId"])
-        
+        if profile is None:
+            return None
+        profile_character = self.data.item.get_character(
+            data["userId"], profile["characterId"]
+        )
+
         if profile_character is None:
             chara = {}
         else:
             chara = profile_character._asdict()
             chara.pop("id")
             chara.pop("user")
-        
+
         data1 = {
-            "userId": data["userId"],    
-            # Current Login State            
+            "userId": data["userId"],
+            # Current Login State
             "isLogin": False,
             "lastLoginDate": profile["lastPlayDate"],
             # User Profile
@@ -109,20 +113,358 @@ class ChuniNew(ChuniBase):
             "lastGameId": profile["lastGameId"],
             "lastRomVersion": profile["lastRomVersion"],
             "lastDataVersion": profile["lastDataVersion"],
-            "lastPlayDate": profile["lastPlayDate"],          
+            "lastPlayDate": profile["lastPlayDate"],
             "emoneyBrandId": 0,
-            "trophyId": profile["trophyId"],            
+            "trophyId": profile["trophyId"],
             # Current Selected Character
             "userCharacter": chara,
             # User Game Options
-            "playerLevel": profile["playerLevel"], 
-            "rating": profile["rating"], 
+            "playerLevel": profile["playerLevel"],
+            "rating": profile["rating"],
             "headphone": profile["headphone"],
-            "chargeState": 0,
-            "userNameEx": "0",
+            # Enables favorites and teams
+            "chargeState": 1,
+            "userNameEx": "",
             "banState": 0,
             "classEmblemMedal": profile["classEmblemMedal"],
             "classEmblemBase": profile["classEmblemBase"],
             "battleRankId": profile["battleRankId"],
         }
         return data1
+
+    def handle_cm_get_user_preview_api_request(self, data: Dict) -> Dict:
+        p = self.data.profile.get_profile_data(data["userId"], self.version)
+        if p is None:
+            return {}
+
+        return {
+            "userName": p["userName"],
+            "level": p["level"],
+            "medal": p["medal"],
+            "lastDataVersion": "2.00.00",
+            "isLogin": False,
+        }
+
+    def handle_printer_login_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
+
+    def handle_printer_logout_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1}
+
+    def handle_get_game_gacha_api_request(self, data: Dict) -> Dict:
+        """
+        returns all current active banners (gachas)
+        """
+        game_gachas = self.data.static.get_gachas(self.version)
+
+        # clean the database rows
+        game_gacha_list = []
+        for gacha in game_gachas:
+            tmp = gacha._asdict()
+            tmp.pop("id")
+            tmp.pop("version")
+            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"
+            )
+
+            game_gacha_list.append(tmp)
+
+        return {
+            "length": len(game_gacha_list),
+            "gameGachaList": game_gacha_list,
+            # no clue
+            "registIdList": [],
+        }
+
+    def handle_get_game_gacha_card_by_id_api_request(self, data: Dict) -> Dict:
+        """
+        returns all valid cards for a given gachaId
+        """
+        game_gacha_cards = self.data.static.get_gacha_cards(data["gachaId"])
+
+        game_gacha_card_list = []
+        for gacha_card in game_gacha_cards:
+            tmp = gacha_card._asdict()
+            tmp.pop("id")
+            game_gacha_card_list.append(tmp)
+
+        return {
+            "gachaId": data["gachaId"],
+            "length": len(game_gacha_card_list),
+            # check isPickup from the chuni_static_gachas?
+            "isPickup": False,
+            "gameGachaCardList": game_gacha_card_list,
+            # again no clue
+            "emissionList": [],
+            "afterCalcList": [],
+            "ssrBookCalcList": [],
+        }
+
+    def handle_cm_get_user_data_api_request(self, data: Dict) -> Dict:
+        p = self.data.profile.get_profile_data(data["userId"], self.version)
+        if p is None:
+            return {}
+
+        profile = p._asdict()
+        profile.pop("id")
+        profile.pop("user")
+        profile.pop("version")
+
+        return {
+            "userId": data["userId"],
+            "userData": profile,
+            "userEmoney": [
+                {
+                    "type": 0,
+                    "emoneyCredit": 100,
+                    "emoneyBrand": 1,
+                    "ext1": 0,
+                    "ext2": 0,
+                    "ext3": 0,
+                }
+            ],
+        }
+
+    def handle_get_user_gacha_api_request(self, data: Dict) -> Dict:
+        user_gachas = self.data.item.get_user_gachas(data["userId"])
+        if user_gachas is None:
+            return {"userId": data["userId"], "length": 0, "userGachaList": []}
+
+        user_gacha_list = []
+        for gacha in user_gachas:
+            tmp = gacha._asdict()
+            tmp.pop("id")
+            tmp.pop("user")
+            tmp["dailyGachaDate"] = datetime.strftime(tmp["dailyGachaDate"], "%Y-%m-%d")
+            user_gacha_list.append(tmp)
+
+        return {
+            "userId": data["userId"],
+            "length": len(user_gacha_list),
+            "userGachaList": user_gacha_list,
+        }
+
+    def handle_get_user_printed_card_api_request(self, data: Dict) -> Dict:
+        user_print_list = self.data.item.get_user_print_states(
+            data["userId"], has_completed=True
+        )
+        if user_print_list is None:
+            return {
+                "userId": data["userId"],
+                "length": 0,
+                "nextIndex": -1,
+                "userPrintedCardList": [],
+            }
+
+        print_list = []
+        next_idx = int(data["nextIndex"])
+        max_ct = int(data["maxCount"])
+
+        for x in range(next_idx, len(user_print_list)):
+            tmp = user_print_list[x]._asdict()
+            print_list.append(tmp["cardId"])
+
+            if len(print_list) >= max_ct:
+                break
+
+        if len(print_list) >= max_ct:
+            next_idx = next_idx + max_ct
+        else:
+            next_idx = -1
+
+        return {
+            "userId": data["userId"],
+            "length": len(print_list),
+            "nextIndex": next_idx,
+            "userPrintedCardList": print_list,
+        }
+
+    def handle_get_user_card_print_error_api_request(self, data: Dict) -> Dict:
+        user_id = data["userId"]
+
+        user_print_states = self.data.item.get_user_print_states(
+            user_id, has_completed=False
+        )
+
+        card_print_state_list = []
+        for card in user_print_states:
+            tmp = card._asdict()
+            tmp["orderId"] = tmp["id"]
+            tmp.pop("user")
+            tmp["limitDate"] = datetime.strftime(tmp["limitDate"], "%Y-%m-%d")
+
+            card_print_state_list.append(tmp)
+
+        return {
+            "userId": user_id,
+            "length": len(card_print_state_list),
+            "userCardPrintStateList": card_print_state_list,
+        }
+
+    def handle_cm_get_user_character_api_request(self, data: Dict) -> Dict:
+        return super().handle_get_user_character_api_request(data)
+
+    def handle_cm_get_user_item_api_request(self, data: Dict) -> Dict:
+        return super().handle_get_user_item_api_request(data)
+
+    def handle_roll_gacha_api_request(self, data: Dict) -> Dict:
+        """
+        Handle a gacha roll API request, with:
+        gachaId: the gachaId where the cards should be pulled from
+        times: the number of gacha rolls
+        characterId: the character which the user wants
+        """
+        gacha_id = data["gachaId"]
+        num_rolls = data["times"]
+        chara_id = data["characterId"]
+
+        rolled_cards = []
+
+        # characterId is set after 10 rolls, where the user can select a card
+        # from all gameGachaCards, therefore the correct cardId for a given
+        # characterId should be returned
+        if chara_id != -1:
+            # get the
+            card = self.data.static.get_gacha_card_by_character(gacha_id, chara_id)
+
+            tmp = card._asdict()
+            tmp.pop("id")
+
+            rolled_cards.append(tmp)
+        else:
+            gacha_cards = self.data.static.get_gacha_cards(gacha_id)
+
+            # get the card id for each roll
+            for _ in range(num_rolls):
+                # get the index from all possible cards
+                card_idx = randint(0, len(gacha_cards) - 1)
+                # remove the index from the cards so it wont get pulled again
+                card = gacha_cards.pop(card_idx)
+
+                # remove the "id" fronm the card
+                tmp = card._asdict()
+                tmp.pop("id")
+
+                rolled_cards.append(tmp)
+
+        return {"length": len(rolled_cards), "gameGachaCardList": rolled_cards}
+
+    def handle_cm_upsert_user_gacha_api_request(self, data: Dict) -> Dict:
+        upsert = data["cmUpsertUserGacha"]
+        user_id = data["userId"]
+        place_id = data["placeId"]
+
+        # save the user data
+        user_data = upsert["userData"]
+        user_data.pop("rankUpChallengeResults")
+        user_data.pop("userEmoney")
+
+        self.data.profile.put_profile_data(user_id, self.version, user_data)
+
+        # save the user gacha
+        user_gacha = upsert["userGacha"]
+        gacha_id = user_gacha["gachaId"]
+        user_gacha.pop("gachaId")
+        user_gacha.pop("dailyGachaDate")
+
+        self.data.item.put_user_gacha(user_id, gacha_id, user_gacha)
+
+        # save all user items
+        if "userItemList" in upsert:
+            for item in upsert["userItemList"]:
+                self.data.item.put_item(user_id, item)
+
+        # add every gamegachaCard to database
+        for card in upsert["gameGachaCardList"]:
+            self.data.item.put_user_print_state(
+                user_id,
+                hasCompleted=False,
+                placeId=place_id,
+                cardId=card["cardId"],
+                gachaId=card["gachaId"],
+            )
+
+        # retrieve every game gacha card which has been added in order to get
+        # the orderId for the next request
+        user_print_states = self.data.item.get_user_print_states_by_gacha(
+            user_id, gacha_id, has_completed=False
+        )
+        card_print_state_list = []
+        for card in user_print_states:
+            tmp = card._asdict()
+            tmp["orderId"] = tmp["id"]
+            tmp.pop("user")
+            tmp["limitDate"] = datetime.strftime(tmp["limitDate"], "%Y-%m-%d")
+
+            card_print_state_list.append(tmp)
+
+        return {
+            "returnCode": "1",
+            "apiName": "CMUpsertUserGachaApi",
+            "userCardPrintStateList": card_print_state_list,
+        }
+
+    def handle_cm_upsert_user_printlog_api_request(self, data: Dict) -> Dict:
+        return {
+            "returnCode": 1,
+            "orderId": 0,
+            "serialId": "11111111111111111111",
+            "apiName": "CMUpsertUserPrintlogApi",
+        }
+
+    def handle_cm_upsert_user_print_api_request(self, data: Dict) -> Dict:
+        user_print_detail = data["userPrintDetail"]
+        user_id = data["userId"]
+
+        # generate random serial id
+        serial_id = "".join([str(randint(0, 9)) for _ in range(20)])
+
+        # not needed because are either zero or unset
+        user_print_detail.pop("orderId")
+        user_print_detail.pop("printNumber")
+        user_print_detail.pop("serialId")
+        user_print_detail["printDate"] = datetime.strptime(
+            user_print_detail["printDate"], "%Y-%m-%d"
+        )
+
+        # add the entry to the user print table with the random serialId
+        self.data.item.put_user_print_detail(user_id, serial_id, user_print_detail)
+
+        return {
+            "returnCode": 1,
+            "orderId": 0,
+            "serialId": serial_id,
+            "apiName": "CMUpsertUserPrintApi",
+        }
+
+    def handle_cm_upsert_user_print_subtract_api_request(self, data: Dict) -> Dict:
+        upsert = data["userCardPrintState"]
+        user_id = data["userId"]
+        place_id = data["placeId"]
+
+        # save all user items
+        if "userItemList" in data:
+            for item in data["userItemList"]:
+                self.data.item.put_item(user_id, item)
+
+        # set the card print state to success and use the orderId as the key
+        self.data.item.put_user_print_state(
+            user_id, id=upsert["orderId"], hasCompleted=True
+        )
+
+        return {"returnCode": "1", "apiName": "CMUpsertUserPrintSubtractApi"}
+
+    def handle_cm_upsert_user_print_cancel_api_request(self, data: Dict) -> Dict:
+        order_ids = data["orderIdList"]
+        user_id = data["userId"]
+
+        # set the card print state to success and use the orderId as the key
+        for order_id in order_ids:
+            self.data.item.put_user_print_state(user_id, id=order_id, hasCompleted=True)
+
+        return {"returnCode": "1", "apiName": "CMUpsertUserPrintCancelApi"}

titles/chuni/newplus.py

@@ -1,23 +1,37 @@
-from datetime import datetime, timedelta
 from typing import Dict, Any
-import pytz
 
 from core.config import CoreConfig
 from titles.chuni.new import ChuniNew
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniNewPlus(ChuniNew):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_NEW_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
         ret = super().handle_get_game_setting_api_request(data)
-        ret["gameSetting"]["romVersion"] = "2.05.00"
-        ret["gameSetting"]["dataVersion"] = "2.05.00"
-        ret["gameSetting"]["matchingUri"] = f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
-        ret["gameSetting"]["matchingUriX"] = f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
-        ret["gameSetting"]["udpHolePunchUri"] = f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
-        ret["gameSetting"]["reflectorUri"] = f"http://{self.core_cfg.server.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        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/205/ChuniServlet/"
+        ret["gameSetting"][
+            "matchingUriX"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        ret["gameSetting"][
+            "udpHolePunchUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/ChuniServlet/"
+        ret["gameSetting"][
+            "reflectorUri"
+        ] = f"http://{self.core_cfg.title.hostname}:{self.core_cfg.title.port}/SDHD/205/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
+        user_data["lastDataVersion"] = "2.05.00"
+        return user_data

titles/chuni/paradise.py

@@ -7,12 +7,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniParadise(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_PARADISE
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.50.00"
         return ret

titles/chuni/plus.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.05.00"
-        return ret
+        return ret

titles/chuni/read.py

@@ -7,48 +7,134 @@ from core.config import CoreConfig
 from titles.chuni.database import ChuniData
 from titles.chuni.const import ChuniConstants
 
+
 class ChuniReader(BaseReader):
-    def __init__(self, config: CoreConfig, version: int, bin_dir: Optional[str], opt_dir: Optional[str], extra: Optional[str]) -> None:
+    def __init__(
+        self,
+        config: CoreConfig,
+        version: int,
+        bin_dir: Optional[str],
+        opt_dir: Optional[str],
+        extra: Optional[str],
+    ) -> None:
         super().__init__(config, version, bin_dir, opt_dir, extra)
         self.data = ChuniData(config)
 
         try:
-            self.logger.info(f"Start importer for {ChuniConstants.game_ver_to_string(version)}")
+            self.logger.info(
+                f"Start importer for {ChuniConstants.game_ver_to_string(version)}"
+            )
         except IndexError:
             self.logger.error(f"Invalid chunithm version {version}")
             exit(1)
-        
+
     def read(self) -> None:
         data_dirs = []
         if self.bin_dir is not None:
             data_dirs += self.get_data_directories(self.bin_dir)
-        
+
         if self.opt_dir is not None:
-           data_dirs += self.get_data_directories(self.opt_dir)
-        
+            data_dirs += self.get_data_directories(self.opt_dir)
+
         for dir in data_dirs:
             self.logger.info(f"Read from {dir}")
             self.read_events(f"{dir}/event")
             self.read_music(f"{dir}/music")
             self.read_charges(f"{dir}/chargeItem")
             self.read_avatar(f"{dir}/avatarAccessory")
-                        
+            self.read_login_bonus(f"{dir}/")
+
+    def read_login_bonus(self, root_dir: str) -> None:
+        for root, dirs, files in walk(f"{root_dir}loginBonusPreset"):
+            for dir in dirs:
+                if path.exists(f"{root}/{dir}/LoginBonusPreset.xml"):
+                    with open(f"{root}/{dir}/LoginBonusPreset.xml", "rb") as fp:
+                        bytedata = fp.read()
+                        strdata = bytedata.decode("UTF-8")
+
+                    xml_root = ET.fromstring(strdata)
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    is_enabled = (
+                        True if xml_root.find("disableFlag").text == "false" else False
+                    )
+
+                    result = self.data.static.put_login_bonus_preset(
+                        self.version, id, name, is_enabled
+                    )
+
+                    if result is not None:
+                        self.logger.info(f"Inserted login bonus preset {id}")
+                    else:
+                        self.logger.warn(f"Failed to insert login bonus preset {id}")
+
+                    for bonus in xml_root.find("infos").findall("LoginBonusDataInfo"):
+                        for name in bonus.findall("loginBonusName"):
+                            bonus_id = name.find("id").text
+                            bonus_name = name.find("str").text
+
+                        if path.exists(
+                            f"{root_dir}/loginBonus/loginBonus{bonus_id}/LoginBonus.xml"
+                        ):
+                            with open(
+                                f"{root_dir}/loginBonus/loginBonus{bonus_id}/LoginBonus.xml",
+                                "rb",
+                            ) as fp:
+                                bytedata = fp.read()
+                                strdata = bytedata.decode("UTF-8")
+
+                                bonus_root = ET.fromstring(strdata)
+
+                                for present in bonus_root.findall("present"):
+                                    present_id = present.find("id").text
+                                    present_name = present.find("str").text
+
+                                item_num = int(bonus_root.find("itemNum").text)
+                                need_login_day_count = int(
+                                    bonus_root.find("needLoginDayCount").text
+                                )
+                                login_bonus_category_type = int(
+                                    bonus_root.find("loginBonusCategoryType").text
+                                )
+
+                                result = self.data.static.put_login_bonus(
+                                    self.version,
+                                    id,
+                                    bonus_id,
+                                    bonus_name,
+                                    present_id,
+                                    present_name,
+                                    item_num,
+                                    need_login_day_count,
+                                    login_bonus_category_type,
+                                )
+
+                                if result is not None:
+                                    self.logger.info(f"Inserted login bonus {bonus_id}")
+                                else:
+                                    self.logger.warn(
+                                        f"Failed to insert login bonus {bonus_id}"
+                                    )
+
     def read_events(self, evt_dir: str) -> None:
         for root, dirs, files in walk(evt_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/Event.xml"):
-                    with open(f"{root}/{dir}/Event.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/Event.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        id = name.find('id').text
-                        name = name.find('str').text
-                    for substances in xml_root.findall('substances'):
-                        event_type = substances.find('type').text
-                    
-                    result = self.data.static.put_event(self.version, id, event_type, name)
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    for substances in xml_root.findall("substances"):
+                        event_type = substances.find("type").text
+
+                    result = self.data.static.put_event(
+                        self.version, id, event_type, name
+                    )
                     if result is not None:
                         self.logger.info(f"Inserted event {id}")
                     else:
@@ -58,73 +144,90 @@ class ChuniReader(BaseReader):
         for root, dirs, files in walk(music_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/Music.xml"):
-                    with open(f"{root}/{dir}/Music.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/Music.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        song_id = name.find('id').text
-                        title = name.find('str').text
+                    for name in xml_root.findall("name"):
+                        song_id = name.find("id").text
+                        title = name.find("str").text
 
-                    for artistName in xml_root.findall('artistName'):
-                        artist = artistName.find('str').text
+                    for artistName in xml_root.findall("artistName"):
+                        artist = artistName.find("str").text
 
-                    for genreNames in xml_root.findall('genreNames'):
-                        for list_ in genreNames.findall('list'):
-                            for StringID in list_.findall('StringID'):
-                                genre = StringID.find('str').text
+                    for genreNames in xml_root.findall("genreNames"):
+                        for list_ in genreNames.findall("list"):
+                            for StringID in list_.findall("StringID"):
+                                genre = StringID.find("str").text
 
-                    for jaketFile in xml_root.findall('jaketFile'): #nice typo, SEGA
-                        jacket_path = jaketFile.find('path').text
+                    for jaketFile in xml_root.findall("jaketFile"):  # nice typo, SEGA
+                        jacket_path = jaketFile.find("path").text
 
-                    for fumens in xml_root.findall('fumens'):
-                        for MusicFumenData in fumens.findall('MusicFumenData'):
-                            fumen_path = MusicFumenData.find('file').find("path")
-                            
-                            if fumen_path.text is not None:
-                                chart_id = MusicFumenData.find('type').find('id').text
+                    for fumens in xml_root.findall("fumens"):
+                        for MusicFumenData in fumens.findall("MusicFumenData"):
+                            fumen_path = MusicFumenData.find("file").find("path")
+
+                            if fumen_path is not None:
+                                chart_id = MusicFumenData.find("type").find("id").text
                                 if chart_id == "4":
                                     level = float(xml_root.find("starDifType").text)
-                                    we_chara = xml_root.find("worldsEndTagName").find("str").text
+                                    we_chara = (
+                                        xml_root.find("worldsEndTagName")
+                                        .find("str")
+                                        .text
+                                    )
                                 else:
-                                    level = float(f"{MusicFumenData.find('level').text}.{MusicFumenData.find('levelDecimal').text}")
+                                    level = float(
+                                        f"{MusicFumenData.find('level').text}.{MusicFumenData.find('levelDecimal').text}"
+                                    )
                                     we_chara = None
-                                
+
                                 result = self.data.static.put_music(
                                     self.version,
                                     song_id,
-                                    chart_id, 
+                                    chart_id,
                                     title,
                                     artist,
                                     level,
                                     genre,
                                     jacket_path,
-                                    we_chara
+                                    we_chara,
                                 )
 
                                 if result is not None:
-                                    self.logger.info(f"Inserted music {song_id} chart {chart_id}")
+                                    self.logger.info(
+                                        f"Inserted music {song_id} chart {chart_id}"
+                                    )
                                 else:
-                                    self.logger.warn(f"Failed to insert music {song_id} chart {chart_id}")
+                                    self.logger.warn(
+                                        f"Failed to insert music {song_id} chart {chart_id}"
+                                    )
 
     def read_charges(self, charge_dir: str) -> None:
         for root, dirs, files in walk(charge_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/ChargeItem.xml"):
-                    with open(f"{root}/{dir}/ChargeItem.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/ChargeItem.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        id = name.find('id').text
-                        name = name.find('str').text
-                    expirationDays = xml_root.find('expirationDays').text
-                    consumeType = xml_root.find('consumeType').text
-                    sellingAppeal = bool(xml_root.find('sellingAppeal').text)
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    expirationDays = xml_root.find("expirationDays").text
+                    consumeType = xml_root.find("consumeType").text
+                    sellingAppeal = bool(xml_root.find("sellingAppeal").text)
 
-                    result = self.data.static.put_charge(self.version, id, name, expirationDays, consumeType, sellingAppeal)
+                    result = self.data.static.put_charge(
+                        self.version,
+                        id,
+                        name,
+                        expirationDays,
+                        consumeType,
+                        sellingAppeal,
+                    )
 
                     if result is not None:
                         self.logger.info(f"Inserted charge {id}")
@@ -135,21 +238,23 @@ class ChuniReader(BaseReader):
         for root, dirs, files in walk(avatar_dir):
             for dir in dirs:
                 if path.exists(f"{root}/{dir}/AvatarAccessory.xml"):
-                    with open(f"{root}/{dir}/AvatarAccessory.xml", 'rb') as fp:
+                    with open(f"{root}/{dir}/AvatarAccessory.xml", "rb") as fp:
                         bytedata = fp.read()
-                        strdata = bytedata.decode('UTF-8')
+                        strdata = bytedata.decode("UTF-8")
 
                     xml_root = ET.fromstring(strdata)
-                    for name in xml_root.findall('name'):
-                        id = name.find('id').text
-                        name = name.find('str').text
-                    category = xml_root.find('category').text
-                    for image in xml_root.findall('image'):
-                        iconPath = image.find('path').text
-                    for texture in xml_root.findall('texture'):
-                        texturePath = texture.find('path').text
+                    for name in xml_root.findall("name"):
+                        id = name.find("id").text
+                        name = name.find("str").text
+                    category = xml_root.find("category").text
+                    for image in xml_root.findall("image"):
+                        iconPath = image.find("path").text
+                    for texture in xml_root.findall("texture"):
+                        texturePath = texture.find("path").text
 
-                    result = self.data.static.put_avatar(self.version, id, name, category, iconPath, texturePath)
+                    result = self.data.static.put_avatar(
+                        self.version, id, name, category, iconPath, texturePath
+                    )
 
                     if result is not None:
                         self.logger.info(f"Inserted avatarAccessory {id}")

titles/chuni/schema/__init__.py

@@ -3,4 +3,4 @@ from titles.chuni.schema.score import ChuniScoreData
 from titles.chuni.schema.item import ChuniItemData
 from titles.chuni.schema.static import ChuniStaticData
 
-__all__ = ["ChuniProfileData", "ChuniScoreData", "ChuniItemData", "ChuniStaticData"]
+__all__ = ["ChuniProfileData", "ChuniScoreData", "ChuniItemData", "ChuniStaticData"]

titles/chuni/schema/item.py

@@ -13,7 +13,11 @@ character = Table(
     "chuni_item_character",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("characterId", Integer),
     Column("level", Integer),
     Column("param1", Integer),
@@ -26,27 +30,35 @@ character = Table(
     Column("assignIllust", Integer),
     Column("exMaxLv", Integer),
     UniqueConstraint("user", "characterId", name="chuni_item_character_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 item = Table(
     "chuni_item_item",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("itemId", Integer),
     Column("itemKind", Integer),
     Column("stock", Integer),
     Column("isValid", Boolean),
     UniqueConstraint("user", "itemId", "itemKind", name="chuni_item_item_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 duel = Table(
     "chuni_item_duel",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("duelId", Integer),
     Column("progress", Integer),
     Column("point", Integer),
@@ -57,14 +69,18 @@ duel = Table(
     Column("param3", Integer),
     Column("param4", Integer),
     UniqueConstraint("user", "duelId", name="chuni_item_duel_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 map = Table(
     "chuni_item_map",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("mapId", Integer),
     Column("position", Integer),
     Column("isClear", Boolean),
@@ -72,17 +88,21 @@ map = Table(
     Column("routeNumber", Integer),
     Column("eventId", Integer),
     Column("rate", Integer),
-    Column("statusCount", Integer),    
+    Column("statusCount", Integer),
     Column("isValid", Boolean),
     UniqueConstraint("user", "mapId", name="chuni_item_map_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 map_area = Table(
     "chuni_item_map_area",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("mapAreaId", Integer),
     Column("rate", Integer),
     Column("isClear", Boolean),
@@ -91,10 +111,146 @@ map_area = Table(
     Column("statusCount", Integer),
     Column("remainGridCount", Integer),
     UniqueConstraint("user", "mapAreaId", name="chuni_item_map_area_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+gacha = Table(
+    "chuni_item_gacha",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("gachaId", Integer, nullable=False),
+    Column("totalGachaCnt", Integer, server_default="0"),
+    Column("ceilingGachaCnt", Integer, server_default="0"),
+    Column("dailyGachaCnt", Integer, server_default="0"),
+    Column("fiveGachaCnt", Integer, server_default="0"),
+    Column("elevenGachaCnt", Integer, server_default="0"),
+    Column("dailyGachaDate", TIMESTAMP, nullable=False, server_default=func.now()),
+    UniqueConstraint("user", "gachaId", name="chuni_item_gacha_uk"),
+    mysql_charset="utf8mb4",
+)
+
+print_state = Table(
+    "chuni_item_print_state",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("hasCompleted", Boolean, nullable=False, server_default="0"),
+    Column(
+        "limitDate", TIMESTAMP, nullable=False, server_default="2038-01-01 00:00:00.0"
+    ),
+    Column("placeId", Integer),
+    Column("cardId", Integer),
+    Column("gachaId", Integer),
+    UniqueConstraint("id", "user", name="chuni_item_print_state_uk"),
+    mysql_charset="utf8mb4",
+)
+
+print_detail = Table(
+    "chuni_item_print_detail",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
+    Column("cardId", Integer, nullable=False),
+    Column("printDate", TIMESTAMP, nullable=False),
+    Column("serialId", String(20), nullable=False),
+    Column("placeId", Integer, nullable=False),
+    Column("clientId", String(11), nullable=False),
+    Column("printerSerialId", String(20), nullable=False),
+    Column("printOption1", Boolean, server_default="0"),
+    Column("printOption2", Boolean, server_default="0"),
+    Column("printOption3", Boolean, server_default="0"),
+    Column("printOption4", Boolean, server_default="0"),
+    Column("printOption5", Boolean, server_default="0"),
+    Column("printOption6", Boolean, server_default="0"),
+    Column("printOption7", Boolean, server_default="0"),
+    Column("printOption8", Boolean, server_default="0"),
+    Column("printOption9", Boolean, server_default="0"),
+    Column("printOption10", Boolean, server_default="0"),
+    Column("created", String(255), server_default=""),
+    UniqueConstraint("serialId", name="chuni_item_print_detail_uk"),
+    mysql_charset="utf8mb4",
+)
+
+login_bonus = Table(
+    "chuni_item_login_bonus",
+    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("presetId", Integer, nullable=False),
+    Column("bonusCount", Integer, nullable=False, server_default="0"),
+    Column("lastUpdateDate", TIMESTAMP, server_default="2018-01-01 00:00:00.0"),
+    Column("isWatched", Boolean, server_default="0"),
+    Column("isFinished", Boolean, server_default="0"),
+    UniqueConstraint("version", "user", "presetId", name="chuni_item_login_bonus_uk"),
+    mysql_charset="utf8mb4",
+)
+
+
 class ChuniItemData(BaseData):
+    def put_login_bonus(
+        self, user_id: int, version: int, preset_id: int, **login_bonus_data
+    ) -> Optional[int]:
+        sql = insert(login_bonus).values(
+            version=version, user=user_id, presetId=preset_id, **login_bonus_data
+        )
+
+        conflict = sql.on_duplicate_key_update(presetId=preset_id, **login_bonus_data)
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def get_all_login_bonus(
+        self, user_id: int, version: int, is_finished: bool = False
+    ) -> Optional[List[Row]]:
+        sql = login_bonus.select(
+            and_(
+                login_bonus.c.version == version,
+                login_bonus.c.user == user_id,
+                login_bonus.c.isFinished == is_finished,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_login_bonus(
+        self, user_id: int, version: int, preset_id: int
+    ) -> Optional[Row]:
+        sql = login_bonus.select(
+            and_(
+                login_bonus.c.version == version,
+                login_bonus.c.user == user_id,
+                login_bonus.c.presetId == preset_id,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
     def put_character(self, user_id: int, character_data: Dict) -> Optional[int]:
         character_data["user"] = user_id
 
@@ -104,24 +260,26 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**character_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_character(self, user_id: int, character_id: int) -> Optional[Dict]:
-        sql = select(character).where(and_(
-            character.c.user == user_id,
-            character.c.characterId == character_id
-        ))
-        
+        sql = select(character).where(
+            and_(character.c.user == user_id, character.c.characterId == character_id)
+        )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
+
     def get_characters(self, user_id: int) -> Optional[List[Row]]:
         sql = select(character).where(character.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_item(self, user_id: int, item_data: Dict) -> Optional[int]:
@@ -133,22 +291,23 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**item_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_items(self, user_id: int, kind: int = None) -> Optional[List[Row]]:
         if kind is None:
             sql = select(item).where(item.c.user == user_id)
         else:
-            sql = select(item).where(and_(
-                item.c.user == user_id,
-                item.c.itemKind == kind
-            ))
-        
+            sql = select(item).where(
+                and_(item.c.user == user_id, item.c.itemKind == kind)
+            )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_duel(self, user_id: int, duel_data: Dict) -> Optional[int]:
         duel_data["user"] = user_id
 
@@ -158,14 +317,16 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**duel_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_duels(self, user_id: int) -> Optional[List[Row]]:
         sql = select(duel).where(duel.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_map(self, user_id: int, map_data: Dict) -> Optional[int]:
@@ -177,16 +338,18 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**map_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_maps(self, user_id: int) -> Optional[List[Row]]:
         sql = select(map).where(map.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_map_area(self, user_id: int, map_area_data: Dict) -> Optional[int]:
         map_area_data["user"] = user_id
 
@@ -196,12 +359,98 @@ class ChuniItemData(BaseData):
         conflict = sql.on_duplicate_key_update(**map_area_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_map_areas(self, user_id: int) -> Optional[List[Row]]:
         sql = select(map_area).where(map_area.c.user == user_id)
-        
+
         result = self.execute(sql)
-        if result is None: return None
-        return result.fetchall()
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_user_gachas(self, aime_id: int) -> Optional[List[Row]]:
+        sql = gacha.select(gacha.c.user == aime_id)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def put_user_gacha(
+        self, aime_id: int, gacha_id: int, gacha_data: Dict
+    ) -> Optional[int]:
+        sql = insert(gacha).values(user=aime_id, gachaId=gacha_id, **gacha_data)
+
+        conflict = sql.on_duplicate_key_update(
+            user=aime_id, gachaId=gacha_id, **gacha_data
+        )
+        result = self.execute(conflict)
+
+        if result is None:
+            self.logger.warn(f"put_user_gacha: Failed to insert! aime_id: {aime_id}")
+            return None
+        return result.lastrowid
+
+    def get_user_print_states(
+        self, aime_id: int, has_completed: bool = False
+    ) -> Optional[List[Row]]:
+        sql = print_state.select(
+            and_(
+                print_state.c.user == aime_id,
+                print_state.c.hasCompleted == has_completed,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_user_print_states_by_gacha(
+        self, aime_id: int, gacha_id: int, has_completed: bool = False
+    ) -> Optional[List[Row]]:
+        sql = print_state.select(
+            and_(
+                print_state.c.user == aime_id,
+                print_state.c.gachaId == gacha_id,
+                print_state.c.hasCompleted == has_completed,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def put_user_print_state(self, aime_id: int, **print_data) -> Optional[int]:
+        sql = insert(print_state).values(user=aime_id, **print_data)
+
+        conflict = sql.on_duplicate_key_update(user=aime_id, **print_data)
+        result = self.execute(conflict)
+
+        if result is None:
+            self.logger.warn(
+                f"put_user_print_state: Failed to insert! aime_id: {aime_id}"
+            )
+            return None
+        return result.lastrowid
+
+    def put_user_print_detail(
+        self, aime_id: int, serial_id: str, user_print_data: Dict
+    ) -> Optional[int]:
+        sql = insert(print_detail).values(
+            user=aime_id, serialId=serial_id, **user_print_data
+        )
+
+        conflict = sql.on_duplicate_key_update(user=aime_id, **user_print_data)
+        result = self.execute(conflict)
+
+        if result is None:
+            self.logger.warn(
+                f"put_user_print_detail: Failed to insert! aime_id: {aime_id}"
+            )
+            return None
+        return result.lastrowid

titles/chuni/schema/profile.py

@@ -13,7 +13,11 @@ profile = Table(
     "chuni_profile_data",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("version", Integer, nullable=False),
     Column("exp", Integer),
     Column("level", Integer),
@@ -62,7 +66,7 @@ profile = Table(
     Column("firstTutorialCancelNum", Integer),
     Column("totalAdvancedHighScore", Integer),
     Column("masterTutorialCancelNum", Integer),
-    Column("ext1", Integer), # Added in chunew
+    Column("ext1", Integer),  # Added in chunew
     Column("ext2", Integer),
     Column("ext3", Integer),
     Column("ext4", Integer),
@@ -71,16 +75,20 @@ profile = Table(
     Column("ext7", Integer),
     Column("ext8", Integer),
     Column("ext9", Integer),
-    Column("ext10", Integer),    
+    Column("ext10", Integer),
     Column("extStr1", String(255)),
     Column("extStr2", String(255)),
     Column("extLong1", Integer),
     Column("extLong2", Integer),
     Column("mapIconId", Integer),
     Column("compatibleCmVersion", String(25)),
-    Column("medal", Integer),    
+    Column("medal", Integer),
     Column("voiceId", Integer),
-    Column("teamId", Integer, ForeignKey("chuni_profile_team.id", ondelete="SET NULL", onupdate="SET NULL")),
+    Column(
+        "teamId",
+        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"),
@@ -121,14 +129,18 @@ profile = Table(
     Column("netBattleEndState", Integer, server_default="0"),
     Column("avatarHead", Integer, server_default="0"),
     UniqueConstraint("user", "version", name="chuni_profile_profile_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 profile_ex = Table(
     "chuni_profile_data_ex",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("version", Integer, nullable=False),
     Column("ext1", Integer),
     Column("ext2", Integer),
@@ -165,14 +177,18 @@ profile_ex = Table(
     Column("mapIconId", Integer),
     Column("compatibleCmVersion", String(25)),
     UniqueConstraint("user", "version", name="chuni_profile_data_ex_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 option = Table(
     "chuni_profile_option",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("speed", Integer),
     Column("bgInfo", Integer),
     Column("rating", Integer),
@@ -195,7 +211,7 @@ option = Table(
     Column("successSkill", Integer),
     Column("successSlideHold", Integer),
     Column("successTapTimbre", Integer),
-    Column("ext1", Integer), # Added in chunew
+    Column("ext1", Integer),  # Added in chunew
     Column("ext2", Integer),
     Column("ext3", Integer),
     Column("ext4", Integer),
@@ -224,14 +240,18 @@ option = Table(
     Column("playTimingOffset", Integer, server_default="0"),
     Column("fieldWallPosition_120", Integer, server_default="0"),
     UniqueConstraint("user", name="chuni_profile_option_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 option_ex = Table(
     "chuni_profile_option_ex",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("ext1", Integer),
     Column("ext2", Integer),
     Column("ext3", Integer),
@@ -253,51 +273,69 @@ option_ex = Table(
     Column("ext19", Integer),
     Column("ext20", Integer),
     UniqueConstraint("user", name="chuni_profile_option_ex_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 recent_rating = Table(
     "chuni_profile_recent_rating",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("recentRating", JSON),
     UniqueConstraint("user", name="chuni_profile_recent_rating_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 region = Table(
     "chuni_profile_region",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("regionId", Integer),
     Column("playCount", Integer),
     UniqueConstraint("user", "regionId", name="chuni_profile_region_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 activity = Table(
     "chuni_profile_activity",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("kind", Integer),
-    Column("activityId", Integer), # Reminder: Change this to ID in base.py or the game will be sad
+    Column(
+        "activityId", Integer
+    ),  # Reminder: Change this to ID in base.py or the game will be sad
     Column("sortNumber", Integer),
     Column("param1", Integer),
     Column("param2", Integer),
     Column("param3", Integer),
     Column("param4", Integer),
     UniqueConstraint("user", "kind", "activityId", name="chuni_profile_activity_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 charge = Table(
     "chuni_profile_charge",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("chargeId", Integer),
     Column("stock", Integer),
     Column("purchaseDate", String(25)),
@@ -306,14 +344,18 @@ charge = Table(
     Column("param2", Integer),
     Column("paramDate", String(25)),
     UniqueConstraint("user", "chargeId", name="chuni_profile_charge_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 emoney = Table(
     "chuni_profile_emoney",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("ext1", Integer),
     Column("ext2", Integer),
     Column("ext3", Integer),
@@ -321,20 +363,24 @@ emoney = Table(
     Column("emoneyBrand", Integer),
     Column("emoneyCredit", Integer),
     UniqueConstraint("user", "emoneyBrand", name="chuni_profile_emoney_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 overpower = Table(
     "chuni_profile_overpower",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("genreId", Integer),
     Column("difficulty", Integer),
     Column("rate", Integer),
     Column("point", Integer),
     UniqueConstraint("user", "genreId", "difficulty", name="chuni_profile_emoney_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 team = Table(
@@ -343,18 +389,21 @@ team = Table(
     Column("id", Integer, primary_key=True, nullable=False),
     Column("teamName", String(255)),
     Column("teamPoint", Integer),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class ChuniProfileData(BaseData):
-    def put_profile_data(self, aime_id: int, version: int, profile_data: Dict) -> Optional[int]:
+    def put_profile_data(
+        self, aime_id: int, version: int, profile_data: Dict
+    ) -> Optional[int]:
         profile_data["user"] = aime_id
         profile_data["version"] = version
         if "accessCode" in profile_data:
             profile_data.pop("accessCode")
-        
+
         profile_data = self.fix_bools(profile_data)
-        
+
         sql = insert(profile).values(**profile_data)
         conflict = sql.on_duplicate_key_update(**profile_data)
         result = self.execute(conflict)
@@ -363,51 +412,64 @@ class ChuniProfileData(BaseData):
             self.logger.warn(f"put_profile_data: Failed to update! aime_id: {aime_id}")
             return None
         return result.lastrowid
-        
+
     def get_profile_preview(self, aime_id: int, version: int) -> Optional[Row]:
-        sql = select([profile, option]).join(option, profile.c.user == option.c.user).filter(
-            and_(profile.c.user == aime_id, profile.c.version == version)
+        sql = (
+            select([profile, option])
+            .join(option, profile.c.user == option.c.user)
+            .filter(and_(profile.c.user == aime_id, profile.c.version == version))
         )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def get_profile_data(self, aime_id: int, version: int) -> Optional[Row]:
-        sql = select(profile).where(and_(
-            profile.c.user == aime_id,
-            profile.c.version == version,
-        ))
+        sql = select(profile).where(
+            and_(
+                profile.c.user == aime_id,
+                profile.c.version == version,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
-    def put_profile_data_ex(self, aime_id: int, version: int, profile_ex_data: Dict) -> Optional[int]:
+
+    def put_profile_data_ex(
+        self, aime_id: int, version: int, profile_ex_data: Dict
+    ) -> Optional[int]:
         profile_ex_data["user"] = aime_id
         profile_ex_data["version"] = version
         if "accessCode" in profile_ex_data:
             profile_ex_data.pop("accessCode")
-        
+
         sql = insert(profile_ex).values(**profile_ex_data)
         conflict = sql.on_duplicate_key_update(**profile_ex_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_data_ex: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_data_ex: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
-    
+
     def get_profile_data_ex(self, aime_id: int, version: int) -> Optional[Row]:
-        sql = select(profile_ex).where(and_(
-            profile_ex.c.user == aime_id,
-            profile_ex.c.version == version,
-        ))
+        sql = select(profile_ex).where(
+            and_(
+                profile_ex.c.user == aime_id,
+                profile_ex.c.version == version,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
+
     def put_profile_option(self, aime_id: int, option_data: Dict) -> Optional[int]:
         option_data["user"] = aime_id
 
@@ -416,7 +478,9 @@ class ChuniProfileData(BaseData):
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_option: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_option: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
@@ -424,18 +488,23 @@ class ChuniProfileData(BaseData):
         sql = select(option).where(option.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
-    
-    def put_profile_option_ex(self, aime_id: int, option_ex_data: Dict) -> Optional[int]:
+
+    def put_profile_option_ex(
+        self, aime_id: int, option_ex_data: Dict
+    ) -> Optional[int]:
         option_ex_data["user"] = aime_id
-        
+
         sql = insert(option_ex).values(**option_ex_data)
         conflict = sql.on_duplicate_key_update(**option_ex_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_option_ex: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_option_ex: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
@@ -443,27 +512,32 @@ class ChuniProfileData(BaseData):
         sql = select(option_ex).where(option_ex.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
-    def put_profile_recent_rating(self, aime_id: int, recent_rating_data: List[Dict]) -> Optional[int]:
+    def put_profile_recent_rating(
+        self, aime_id: int, recent_rating_data: List[Dict]
+    ) -> Optional[int]:
         sql = insert(recent_rating).values(
-            user = aime_id,
-            recentRating = recent_rating_data
+            user=aime_id, recentRating=recent_rating_data
         )
-        conflict = sql.on_duplicate_key_update(recentRating = recent_rating_data)
+        conflict = sql.on_duplicate_key_update(recentRating=recent_rating_data)
 
         result = self.execute(conflict)
         if result is None:
-            self.logger.warn(f"put_profile_recent_rating: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_recent_rating: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
-    
+
     def get_profile_recent_rating(self, aime_id: int) -> Optional[Row]:
         sql = select(recent_rating).where(recent_rating.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def put_profile_activity(self, aime_id: int, activity_data: Dict) -> Optional[int]:
@@ -471,35 +545,41 @@ class ChuniProfileData(BaseData):
         activity_data["user"] = aime_id
         activity_data["activityId"] = activity_data["id"]
         activity_data.pop("id")
-        
+
         sql = insert(activity).values(**activity_data)
         conflict = sql.on_duplicate_key_update(**activity_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_activity: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_activity: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
     def get_profile_activity(self, aime_id: int, kind: int) -> Optional[List[Row]]:
-        sql = select(activity).where(and_(
-            activity.c.user == aime_id,
-            activity.c.kind == kind
-        ))
+        sql = (
+            select(activity)
+            .where(and_(activity.c.user == aime_id, activity.c.kind == kind))
+            .order_by(activity.c.sortNumber.desc())  # to get the last played track
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_profile_charge(self, aime_id: int, charge_data: Dict) -> Optional[int]:
         charge_data["user"] = aime_id
-        
+
         sql = insert(charge).values(**charge_data)
         conflict = sql.on_duplicate_key_update(**charge_data)
         result = self.execute(conflict)
 
         if result is None:
-            self.logger.warn(f"put_profile_charge: Failed to update! aime_id: {aime_id}")
+            self.logger.warn(
+                f"put_profile_charge: Failed to update! aime_id: {aime_id}"
+            )
             return None
         return result.lastrowid
 
@@ -507,9 +587,10 @@ class ChuniProfileData(BaseData):
         sql = select(charge).where(charge.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def add_profile_region(self, aime_id: int, region_id: int) -> Optional[int]:
         pass
 
@@ -523,29 +604,35 @@ class ChuniProfileData(BaseData):
         conflict = sql.on_duplicate_key_update(**emoney_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_profile_emoney(self, aime_id: int) -> Optional[List[Row]]:
         sql = select(emoney).where(emoney.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
-    def put_profile_overpower(self, aime_id: int, overpower_data: Dict) -> Optional[int]:
+    def put_profile_overpower(
+        self, aime_id: int, overpower_data: Dict
+    ) -> Optional[int]:
         overpower_data["user"] = aime_id
 
         sql = insert(overpower).values(**overpower_data)
         conflict = sql.on_duplicate_key_update(**overpower_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_profile_overpower(self, aime_id: int) -> Optional[List[Row]]:
         sql = select(overpower).where(overpower.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()

titles/chuni/schema/score.py

@@ -13,7 +13,11 @@ course = Table(
     "chuni_score_course",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("courseId", Integer),
     Column("classId", Integer),
     Column("playCount", Integer),
@@ -29,15 +33,22 @@ course = Table(
     Column("param3", Integer),
     Column("param4", Integer),
     Column("isClear", Boolean),
+    Column("theoryCount", Integer),
+    Column("orderId", Integer),
+    Column("playerRating", Integer),
     UniqueConstraint("user", "courseId", name="chuni_score_course_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 best_score = Table(
     "chuni_score_best",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("musicId", Integer),
     Column("level", Integer),
     Column("playCount", Integer),
@@ -57,14 +68,18 @@ best_score = Table(
     Column("ext1", Integer),
     Column("theoryCount", Integer),
     UniqueConstraint("user", "musicId", "level", name="chuni_score_best_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 playlog = Table(
     "chuni_score_playlog",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column(
+        "user",
+        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    ),
     Column("orderId", Integer),
     Column("sortNumber", Integer),
     Column("placeId", Integer),
@@ -119,15 +134,17 @@ playlog = Table(
     Column("charaIllustId", Integer),
     Column("romVersion", String(255)),
     Column("judgeHeaven", Integer),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+
 class ChuniScoreData(BaseData):
     def get_courses(self, aime_id: int) -> Optional[Row]:
         sql = select(course).where(course.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def put_course(self, aime_id: int, course_data: Dict) -> Optional[int]:
@@ -138,16 +155,18 @@ class ChuniScoreData(BaseData):
         conflict = sql.on_duplicate_key_update(**course_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_scores(self, aime_id: int) -> Optional[Row]:
         sql = select(best_score).where(best_score.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_score(self, aime_id: int, score_data: Dict) -> Optional[int]:
         score_data["user"] = aime_id
         score_data = self.fix_bools(score_data)
@@ -156,16 +175,18 @@ class ChuniScoreData(BaseData):
         conflict = sql.on_duplicate_key_update(**score_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
 
     def get_playlogs(self, aime_id: int) -> Optional[Row]:
         sql = select(playlog).where(playlog.c.user == aime_id)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def put_playlog(self, aime_id: int, playlog_data: Dict) -> Optional[int]:
         playlog_data["user"] = aime_id
         playlog_data = self.fix_bools(playlog_data)
@@ -174,5 +195,6 @@ class ChuniScoreData(BaseData):
         conflict = sql.on_duplicate_key_update(**playlog_data)
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid

titles/chuni/schema/static.py

@@ -19,7 +19,7 @@ events = Table(
     Column("name", String(255)),
     Column("enabled", Boolean, server_default="1"),
     UniqueConstraint("version", "eventId", name="chuni_static_events_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 music = Table(
@@ -30,13 +30,13 @@ music = Table(
     Column("songId", Integer),
     Column("chartId", Integer),
     Column("title", String(255)),
-    Column("artist", String(255)),    
+    Column("artist", String(255)),
     Column("level", Float),
     Column("genre", String(255)),
     Column("jacketPath", String(255)),
-    Column("worldsEndTag", String(20)),
+    Column("worldsEndTag", String(7)),
     UniqueConstraint("version", "songId", "chartId", name="chuni_static_music_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 charge = Table(
@@ -51,7 +51,7 @@ charge = Table(
     Column("sellingAppeal", Boolean),
     Column("enabled", Boolean, server_default="1"),
     UniqueConstraint("version", "chargeId", name="chuni_static_charge_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
 avatar = Table(
@@ -65,159 +65,503 @@ avatar = Table(
     Column("iconPath", String(255)),
     Column("texturePath", String(255)),
     UniqueConstraint("version", "avatarAccessoryId", name="chuni_static_avatar_uk"),
-    mysql_charset='utf8mb4'
+    mysql_charset="utf8mb4",
 )
 
+gachas = Table(
+    "chuni_static_gachas",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer, nullable=False),
+    Column("gachaId", Integer, nullable=False),
+    Column("gachaName", String(255), nullable=False),
+    Column("type", Integer, nullable=False, server_default="0"),
+    Column("kind", Integer, nullable=False, server_default="0"),
+    Column("isCeiling", Boolean, server_default="0"),
+    Column("ceilingCnt", Integer, server_default="10"),
+    Column("changeRateCnt1", Integer, server_default="0"),
+    Column("changeRateCnt2", Integer, server_default="0"),
+    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("noticeStartDate", TIMESTAMP, server_default="2018-01-01 00:00:00.0"),
+    Column("noticeEndDate", TIMESTAMP, server_default="2038-01-01 00:00:00.0"),
+    UniqueConstraint("version", "gachaId", "gachaName", name="chuni_static_gachas_uk"),
+    mysql_charset="utf8mb4",
+)
+
+cards = Table(
+    "chuni_static_cards",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("version", Integer, nullable=False),
+    Column("cardId", Integer, nullable=False),
+    Column("charaName", String(255), nullable=False),
+    Column("charaId", Integer, nullable=False),
+    Column("presentName", String(255), nullable=False),
+    Column("rarity", Integer, server_default="2"),
+    Column("labelType", Integer, nullable=False),
+    Column("difType", Integer, nullable=False),
+    Column("miss", Integer, nullable=False),
+    Column("combo", Integer, nullable=False),
+    Column("chain", Integer, nullable=False),
+    Column("skillName", String(255), nullable=False),
+    UniqueConstraint("version", "cardId", name="chuni_static_cards_uk"),
+    mysql_charset="utf8mb4",
+)
+
+gacha_cards = Table(
+    "chuni_static_gacha_cards",
+    metadata,
+    Column("id", Integer, primary_key=True, nullable=False),
+    Column("gachaId", Integer, nullable=False),
+    Column("cardId", Integer, nullable=False),
+    Column("rarity", Integer, nullable=False),
+    Column("weight", Integer, server_default="1"),
+    Column("isPickup", Boolean, server_default="0"),
+    UniqueConstraint("gachaId", "cardId", name="chuni_static_gacha_cards_uk"),
+    mysql_charset="utf8mb4",
+)
+
+login_bonus_preset = Table(
+    "chuni_static_login_bonus_preset",
+    metadata,
+    Column("id", Integer, primary_key=True, 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"),
+    mysql_charset="utf8mb4",
+)
+
+login_bonus = Table(
+    "chuni_static_login_bonus",
+    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("loginBonusId", Integer, nullable=False),
+    Column("loginBonusName", String(255), nullable=False),
+    Column("presentId", Integer, nullable=False),
+    Column("presentName", String(255), nullable=False),
+    Column("itemNum", Integer, nullable=False),
+    Column("needLoginDayCount", Integer, nullable=False),
+    Column("loginBonusCategoryType", Integer, nullable=False),
+    UniqueConstraint(
+        "version", "presetId", "loginBonusId", name="chuni_static_login_bonus_uk"
+    ),
+    mysql_charset="utf8mb4",
+)
+
+
 class ChuniStaticData(BaseData):
-    def put_event(self, version: int, event_id: int, type: int, name: str) -> Optional[int]:
-        sql = insert(events).values(
-            version = version,
-            eventId = event_id,
-            type = type,
-            name = name
+    def put_login_bonus(
+        self,
+        version: int,
+        preset_id: int,
+        login_bonus_id: int,
+        login_bonus_name: str,
+        present_id: int,
+        present_ame: str,
+        item_num: int,
+        need_login_day_count: int,
+        login_bonus_category_type: int,
+    ) -> Optional[int]:
+        sql = insert(login_bonus).values(
+            version=version,
+            presetId=preset_id,
+            loginBonusId=login_bonus_id,
+            loginBonusName=login_bonus_name,
+            presentId=present_id,
+            presentName=present_ame,
+            itemNum=item_num,
+            needLoginDayCount=need_login_day_count,
+            loginBonusCategoryType=login_bonus_category_type,
         )
 
         conflict = sql.on_duplicate_key_update(
-            name = name
+            loginBonusName=login_bonus_name,
+            presentName=present_ame,
+            itemNum=item_num,
+            needLoginDayCount=need_login_day_count,
+            loginBonusCategoryType=login_bonus_category_type,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
-    def update_event(self, version: int, event_id: int, enabled: bool) -> Optional[bool]:
-        sql = events.update(and_(events.c.version == version, events.c.eventId == event_id)).values(
-            enabled = enabled
+
+    def get_login_bonus(
+        self, version: int, preset_id: int,
+    ) -> Optional[List[Row]]:
+        sql = login_bonus.select(
+            and_(
+                login_bonus.c.version == version,
+                login_bonus.c.presetId == preset_id,
+            )
+        ).order_by(login_bonus.c.needLoginDayCount.desc())
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_login_bonus_by_required_days(
+        self, version: int, preset_id: int, need_login_day_count: int
+    ) -> Optional[Row]:
+        sql = login_bonus.select(
+            and_(
+                login_bonus.c.version == version,
+                login_bonus.c.presetId == preset_id,
+                login_bonus.c.needLoginDayCount == need_login_day_count,
+            )
         )
 
         result = self.execute(sql)
-        if result is None: 
-            self.logger.warn(f"update_event: failed to update event! version: {version}, event_id: {event_id}, enabled: {enabled}")
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def put_login_bonus_preset(
+        self, version: int, preset_id: int, preset_name: str, is_enabled: bool
+    ) -> Optional[int]:
+        sql = insert(login_bonus_preset).values(
+            id=preset_id,
+            version=version,
+            presetName=preset_name,
+            isEnabled=is_enabled,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            presetName=preset_name, isEnabled=is_enabled
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def get_login_bonus_presets(
+        self, version: int, is_enabled: bool = True
+    ) -> Optional[List[Row]]:
+        sql = login_bonus_preset.select(
+            and_(
+                login_bonus_preset.c.version == version,
+                login_bonus_preset.c.isEnabled == is_enabled,
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def put_event(
+        self, version: int, event_id: int, type: int, name: str
+    ) -> Optional[int]:
+        sql = insert(events).values(
+            version=version, eventId=event_id, type=type, name=name
+        )
+
+        conflict = sql.on_duplicate_key_update(name=name)
+
+        result = self.execute(conflict)
+        if result is None:
+            return None
+        return result.lastrowid
+
+    def update_event(
+        self, version: int, event_id: int, enabled: bool
+    ) -> Optional[bool]:
+        sql = events.update(
+            and_(events.c.version == version, events.c.eventId == event_id)
+        ).values(enabled=enabled)
+
+        result = self.execute(sql)
+        if result is None:
+            self.logger.warn(
+                f"update_event: failed to update event! version: {version}, event_id: {event_id}, enabled: {enabled}"
+            )
             return None
 
         event = self.get_event(version, event_id)
         if event is None:
-            self.logger.warn(f"update_event: failed to fetch event {event_id} after updating")
+            self.logger.warn(
+                f"update_event: failed to fetch event {event_id} after updating"
+            )
             return None
         return event["enabled"]
 
     def get_event(self, version: int, event_id: int) -> Optional[Row]:
-        sql = select(events).where(and_(events.c.version == version, events.c.eventId == event_id))
-        
+        sql = select(events).where(
+            and_(events.c.version == version, events.c.eventId == event_id)
+        )
+
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
     def get_enabled_events(self, version: int) -> Optional[List[Row]]:
-        sql = select(events).where(and_(events.c.version == version, events.c.enabled == True))
+        sql = select(events).where(
+            and_(events.c.version == version, events.c.enabled == True)
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
 
     def get_events(self, version: int) -> Optional[List[Row]]:
         sql = select(events).where(events.c.version == version)
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
-    def put_music(self, version: int, song_id: int, chart_id: int, title: int, artist: str, 
-        level: float, genre: str, jacketPath: str, we_tag: str) -> Optional[int]:
 
+    def put_music(
+        self,
+        version: int,
+        song_id: int,
+        chart_id: int,
+        title: int,
+        artist: str,
+        level: float,
+        genre: str,
+        jacketPath: str,
+        we_tag: str,
+    ) -> Optional[int]:
         sql = insert(music).values(
-            version = version,
-            songId = song_id,
-            chartId = chart_id,
-            title = title,
-            artist = artist,
-            level = level,
-            genre = genre,
-            jacketPath = jacketPath,
-            worldsEndTag = we_tag,
+            version=version,
+            songId=song_id,
+            chartId=chart_id,
+            title=title,
+            artist=artist,
+            level=level,
+            genre=genre,
+            jacketPath=jacketPath,
+            worldsEndTag=we_tag,
         )
 
         conflict = sql.on_duplicate_key_update(
-            title = title,
-            artist = artist,
-            level = level,
-            genre = genre,
-            jacketPath = jacketPath,
-            worldsEndTag = we_tag,
+            title=title,
+            artist=artist,
+            level=level,
+            genre=genre,
+            jacketPath=jacketPath,
+            worldsEndTag=we_tag,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
-    def put_charge(self, version: int, charge_id: int, name: str, expiration_days: int, 
-        consume_type: int, selling_appeal: bool) -> Optional[int]:
+
+    def put_charge(
+        self,
+        version: int,
+        charge_id: int,
+        name: str,
+        expiration_days: int,
+        consume_type: int,
+        selling_appeal: bool,
+    ) -> Optional[int]:
         sql = insert(charge).values(
-            version = version,
-            chargeId = charge_id,
-            name = name,
-            expirationDays = expiration_days,
-            consumeType = consume_type,
-            sellingAppeal = selling_appeal,
+            version=version,
+            chargeId=charge_id,
+            name=name,
+            expirationDays=expiration_days,
+            consumeType=consume_type,
+            sellingAppeal=selling_appeal,
         )
 
         conflict = sql.on_duplicate_key_update(
-            name = name,
-            expirationDays = expiration_days,
-            consumeType = consume_type,
-            sellingAppeal = selling_appeal,
+            name=name,
+            expirationDays=expiration_days,
+            consumeType=consume_type,
+            sellingAppeal=selling_appeal,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
     def get_enabled_charges(self, version: int) -> Optional[List[Row]]:
-        sql = select(charge).where(and_(
-            charge.c.version == version,
-            charge.c.enabled == True
-        ))
+        sql = select(charge).where(
+            and_(charge.c.version == version, charge.c.enabled == True)
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchall()
-    
+
     def get_charges(self, version: int) -> Optional[List[Row]]:
         sql = select(charge).where(charge.c.version == version)
 
         result = self.execute(sql)
-        if result is None: return None
+        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]]:
-        sql = select(music).where(and_(
-            music.c.version == version,
-            music.c.songId == song_id,
-            music.c.chartId == chart_id
-            ))
+    def get_music_chart(
+        self, version: int, song_id: int, chart_id: int
+    ) -> Optional[List[Row]]:
+        sql = select(music).where(
+            and_(
+                music.c.version == version,
+                music.c.songId == song_id,
+                music.c.chartId == chart_id,
+            )
+        )
 
         result = self.execute(sql)
-        if result is None: return None
+        if result is None:
+            return None
         return result.fetchone()
 
-    def put_avatar(self, version: int, avatarAccessoryId: int, name: str, category: int, iconPath: str, texturePath: str) -> Optional[int]:
+    def put_avatar(
+        self,
+        version: int,
+        avatarAccessoryId: int,
+        name: str,
+        category: int,
+        iconPath: str,
+        texturePath: str,
+    ) -> Optional[int]:
         sql = insert(avatar).values(
-            version = version,
-            avatarAccessoryId = avatarAccessoryId,
-            name = name,
-            category = category,
-            iconPath = iconPath,
-            texturePath = texturePath,
+            version=version,
+            avatarAccessoryId=avatarAccessoryId,
+            name=name,
+            category=category,
+            iconPath=iconPath,
+            texturePath=texturePath,
         )
 
         conflict = sql.on_duplicate_key_update(
-            name = name,
-            category = category,
-            iconPath = iconPath,
-            texturePath = texturePath,
+            name=name,
+            category=category,
+            iconPath=iconPath,
+            texturePath=texturePath,
         )
 
         result = self.execute(conflict)
-        if result is None: return None
+        if result is None:
+            return None
         return result.lastrowid
-    
+
+    def put_gacha(
+        self,
+        version: int,
+        gacha_id: int,
+        gacha_name: int,
+        **gacha_data,
+    ) -> Optional[int]:
+        sql = insert(gachas).values(
+            version=version,
+            gachaId=gacha_id,
+            gachaName=gacha_name,
+            **gacha_data,
+        )
+
+        conflict = sql.on_duplicate_key_update(
+            version=version,
+            gachaId=gacha_id,
+            gachaName=gacha_name,
+            **gacha_data,
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.warn(f"Failed to insert gacha! gacha_id {gacha_id}")
+            return None
+        return result.lastrowid
+
+    def get_gachas(self, version: int) -> Optional[List[Dict]]:
+        sql = gachas.select(gachas.c.version <= version).order_by(
+            gachas.c.gachaId.asc()
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_gacha(self, version: int, gacha_id: int) -> Optional[Dict]:
+        sql = gachas.select(
+            and_(gachas.c.version <= version, gachas.c.gachaId == gacha_id)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def put_gacha_card(
+        self, gacha_id: int, card_id: int, **gacha_card
+    ) -> Optional[int]:
+        sql = insert(gacha_cards).values(gachaId=gacha_id, cardId=card_id, **gacha_card)
+
+        conflict = sql.on_duplicate_key_update(
+            gachaId=gacha_id, cardId=card_id, **gacha_card
+        )
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.warn(f"Failed to insert gacha card! gacha_id {gacha_id}")
+            return None
+        return result.lastrowid
+
+    def get_gacha_cards(self, gacha_id: int) -> Optional[List[Dict]]:
+        sql = gacha_cards.select(gacha_cards.c.gachaId == gacha_id)
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchall()
+
+    def get_gacha_card_by_character(
+        self, gacha_id: int, chara_id: int
+    ) -> Optional[Dict]:
+        sql_sub = (
+            select(cards.c.cardId).filter(cards.c.charaId == chara_id).scalar_subquery()
+        )
+
+        # Perform the main query, also rename the resulting column to ranking
+        sql = gacha_cards.select(
+            and_(gacha_cards.c.gachaId == gacha_id, gacha_cards.c.cardId == sql_sub)
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()
+
+    def put_card(self, version: int, card_id: int, **card_data) -> Optional[int]:
+        sql = insert(cards).values(version=version, cardId=card_id, **card_data)
+
+        conflict = sql.on_duplicate_key_update(**card_data)
+
+        result = self.execute(conflict)
+        if result is None:
+            self.logger.warn(f"Failed to insert card! card_id {card_id}")
+            return None
+        return result.lastrowid
+
+    def get_card(self, version: int, card_id: int) -> Optional[Dict]:
+        sql = cards.select(and_(cards.c.version <= version, cards.c.cardId == card_id))
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return result.fetchone()

titles/chuni/star.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniStar(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_STAR
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.20.00"
-        return ret
+        return ret

titles/chuni/starplus.py

@@ -5,12 +5,13 @@ from titles.chuni.base import ChuniBase
 from titles.chuni.const import ChuniConstants
 from titles.chuni.config import ChuniConfig
 
+
 class ChuniStarPlus(ChuniBase):
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
         super().__init__(core_cfg, game_cfg)
         self.version = ChuniConstants.VER_CHUNITHM_STAR_PLUS
-    
+
     def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
-        ret =  super().handle_get_game_setting_api_request(data)
+        ret = super().handle_get_game_setting_api_request(data)
         ret["gameSetting"]["dataVersion"] = "1.25.00"
-        return ret
+        return ret

titles/cm/__init__.py

@@ -0,0 +1,12 @@
+from titles.cm.index import CardMakerServlet
+from titles.cm.const import CardMakerConstants
+from titles.cm.read import CardMakerReader
+from titles.cm.database import CardMakerData
+
+index = CardMakerServlet
+reader = CardMakerReader
+database = CardMakerData
+
+game_codes = [CardMakerConstants.GAME_CODE]
+
+current_schema_version = 1

titles/cm/base.py

@@ -0,0 +1,77 @@
+from datetime import date, datetime, timedelta
+from typing import Any, Dict, List
+import json
+import logging
+from enum import Enum
+
+from core.config import CoreConfig
+from core.data.cache import cached
+from titles.cm.const import CardMakerConstants
+from titles.cm.config import CardMakerConfig
+
+
+class CardMakerBase:
+    def __init__(self, core_cfg: CoreConfig, game_cfg: CardMakerConfig) -> None:
+        self.core_cfg = core_cfg
+        self.game_cfg = game_cfg
+        self.date_time_format = "%Y-%m-%d %H:%M:%S"
+        self.date_time_format_ext = (
+            "%Y-%m-%d %H:%M:%S.%f"  # needs to be lopped off at [:-5]
+        )
+        self.date_time_format_short = "%Y-%m-%d"
+        self.logger = logging.getLogger("cardmaker")
+        self.game = CardMakerConstants.GAME_CODE
+        self.version = CardMakerConstants.VER_CARD_MAKER
+
+    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
+        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/"},
+            ],
+        }
+
+    def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
+        reboot_start = date.strftime(
+            datetime.now() + timedelta(hours=3), self.date_time_format
+        )
+        reboot_end = date.strftime(
+            datetime.now() + timedelta(hours=4), self.date_time_format
+        )
+
+        return {
+            "gameSetting": {
+                "dataVersion": "1.30.00",
+                "ongekiCmVersion": "1.30.01",
+                "chuniCmVersion": "2.00.00",
+                "maimaiCmVersion": "1.20.00",
+                "requestInterval": 10,
+                "rebootStartTime": reboot_start,
+                "rebootEndTime": reboot_end,
+                "maxCountCharacter": 100,
+                "maxCountItem": 100,
+                "maxCountCard": 100,
+                "watermark": False,
+                "isMaintenance": False,
+                "isBackgroundDistribute": False,
+            },
+            "isDumpUpload": False,
+            "isAou": False,
+        }
+
+    def handle_get_client_bookkeeping_api_request(self, data: Dict) -> Dict:
+        return {"placeId": data["placeId"], "length": 0, "clientBookkeepingList": []}
+
+    def handle_upsert_client_setting_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1, "apiName": "UpsertClientSettingApi"}
+
+    def handle_upsert_client_bookkeeping_api_request(self, data: Dict) -> Dict:
+        return {"returnCode": 1, "apiName": "UpsertClientBookkeepingApi"}

titles/cm/cm135.py

@@ -0,0 +1,38 @@
+from datetime import date, datetime, timedelta
+from typing import Any, Dict, List
+import json
+import logging
+from enum import Enum
+
+from core.config import CoreConfig
+from core.data.cache import cached
+from titles.cm.base import CardMakerBase
+from titles.cm.const import CardMakerConstants
+from titles.cm.config import CardMakerConfig
+
+
+class CardMaker135(CardMakerBase):
+    def __init__(self, core_cfg: CoreConfig, game_cfg: CardMakerConfig) -> None:
+        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/cm_data/MU3/static_gacha_cards.csv

@@ -0,0 +1,501 @@
+"gachaId","cardId","rarity","weight","isPickup","isSelect"
+1070,100984,4,1,0,1
+1070,100997,3,2,0,1
+1070,100998,3,2,0,1
+1070,101020,2,3,0,1
+1070,101021,2,3,0,1
+1070,101022,2,3,0,1
+1067,100982,4,1,0,0
+1067,100983,4,1,0,0
+1067,100996,3,2,0,0
+1068,100075,2,3,0,0
+1068,100182,2,3,0,0
+1068,100348,2,3,0,0
+1068,100232,2,3,0,0
+1068,100417,2,3,0,0
+1068,100755,2,3,0,0
+1068,100077,3,2,0,0
+1068,100271,3,2,0,0
+1068,100425,3,2,0,0
+1068,100758,3,2,0,0
+1068,101000,3,2,0,0
+1068,100284,4,1,0,0
+1068,100767,4,1,0,0
+1068,101293,4,1,0,0
+1069,100069,2,3,0,0
+1069,100183,2,3,0,0
+1069,100349,2,3,0,0
+1069,100233,2,3,0,0
+1069,100416,2,3,0,0
+1069,100071,3,2,0,0
+1069,100272,3,2,0,0
+1069,100427,3,2,0,0
+1069,100805,3,2,0,0
+1069,101300,3,2,0,0
+1069,100285,4,1,0,0
+1069,100768,4,1,0,0
+1069,100988,4,1,0,0
+1071,100275,4,1,0,0
+1071,100437,4,1,0,0
+1071,100780,4,1,0,0
+1071,100006,3,2,0,0
+1071,100007,3,2,0,0
+1071,100249,3,2,0,0
+1071,100262,3,2,0,0
+1071,100418,3,2,0,0
+1071,100003,2,3,0,0
+1071,100004,2,3,0,0
+1071,100173,2,3,0,0
+1071,100223,2,3,0,0
+1071,100339,2,3,0,0
+1071,100692,2,3,0,0
+1072,100017,4,1,0,0
+1072,100276,4,1,0,0
+1072,100760,4,1,0,0
+1072,100015,3,2,0,0
+1072,100016,3,2,0,0
+1072,100250,3,2,0,0
+1072,100263,3,2,0,0
+1072,100423,3,2,0,0
+1072,100765,3,2,0,0
+1072,100012,2,3,0,0
+1072,100013,2,3,0,0
+1072,100174,2,3,0,0
+1072,100224,2,3,0,0
+1072,100340,2,3,0,0
+1072,100693,2,3,0,0
+1073,100026,4,1,0,0
+1073,100277,4,1,0,0
+1073,100761,4,1,0,0
+1073,100024,3,2,0,0
+1073,100025,3,2,0,0
+1073,100251,3,2,0,0
+1073,100264,3,2,0,0
+1073,100430,3,2,0,0
+1073,100021,2,3,0,0
+1073,100022,2,3,0,0
+1073,100175,2,3,0,0
+1073,100225,2,3,0,0
+1073,100341,2,3,0,0
+1073,100694,2,3,0,0
+1011,100454,4,1,0,0
+1011,100980,4,1,0,0
+1011,101553,4,1,0,0
+1011,100253,3,1,0,0
+1011,100241,3,1,0,0
+1011,100240,3,1,0,0
+1011,100239,3,1,0,0
+1011,100238,3,1,0,0
+1011,100237,3,1,0,0
+1011,100236,3,1,0,0
+1011,100261,3,1,0,0
+1011,100246,3,1,0,0
+1011,100245,3,1,0,0
+1011,100242,3,1,0,0
+1011,100243,3,1,0,0
+1011,100254,3,1,0,0
+1011,100338,3,1,0,0
+1011,100337,3,1,0,0
+1011,100336,3,1,0,0
+1011,100248,3,1,0,0
+1011,100247,3,1,0,0
+1011,100244,3,1,0,0
+1011,100259,3,1,0,0
+1011,100257,3,1,0,0
+1011,100258,3,1,0,0
+1011,100636,3,1,0,0
+1011,100634,3,1,0,0
+1011,100255,3,1,0,0
+1011,100256,3,1,0,0
+1011,100252,3,1,0,0
+1011,100638,3,1,0,0
+1011,100639,3,1,0,0
+1011,100637,3,1,0,0
+1011,100772,3,1,0,0
+1011,100667,3,1,0,0
+1011,100666,3,1,0,0
+1011,100665,3,1,0,0
+1011,100643,3,1,0,0
+1011,100640,3,1,0,0
+1011,100641,3,1,0,0
+1011,100642,3,1,0,0
+1011,100688,3,1,0,0
+1011,100645,3,1,0,0
+1011,100646,3,1,0,0
+1011,100644,3,1,0,0
+1012,100644,3,1,0,0
+1012,100646,3,1,0,0
+1012,100645,3,1,0,0
+1012,100688,3,1,0,0
+1012,100642,3,1,0,0
+1012,100641,3,1,0,0
+1012,100640,3,1,0,0
+1012,100643,3,1,0,0
+1012,100665,3,1,0,0
+1012,100666,3,1,0,0
+1012,100667,3,1,0,0
+1012,100634,3,1,0,0
+1012,100636,3,1,0,0
+1012,100772,3,1,0,0
+1012,100638,3,1,0,0
+1012,100637,3,1,0,0
+1012,100639,3,1,0,0
+1012,100252,3,1,0,0
+1012,100256,3,1,0,0
+1012,100255,3,1,0,0
+1012,100258,3,1,0,0
+1012,100257,3,1,0,0
+1012,100259,3,1,0,0
+1012,100244,3,1,0,0
+1012,100247,3,1,0,0
+1012,100248,3,1,0,0
+1012,100336,3,1,0,0
+1012,100337,3,1,0,0
+1012,100338,3,1,0,0
+1012,100254,3,1,0,0
+1012,100243,3,1,0,0
+1012,100242,3,1,0,0
+1012,100245,3,1,0,0
+1012,100246,3,1,0,0
+1012,100261,3,1,0,0
+1012,100236,3,1,0,0
+1012,100237,3,1,0,0
+1012,100238,3,1,0,0
+1012,100239,3,1,0,0
+1012,100240,3,1,0,0
+1012,100241,3,1,0,0
+1012,100253,3,1,0,0
+1012,100454,4,1,0,0
+1012,100980,4,1,0,0
+1012,101553,4,1,0,0
+1074,100985,4,1,0,0
+1074,100999,3,1,0,0
+1074,101000,3,1,0,0
+1074,101023,2,1,0,0
+1074,101024,2,1,0,0
+1075,100060,4,1,0,0
+1075,100434,4,1,0,0
+1075,100059,3,1,0,0
+1075,100268,3,1,0,0
+1075,100420,3,1,0,0
+1075,100763,3,1,0,0
+1075,101003,3,1,0,0
+1075,100057,2,1,0,0
+1075,100179,2,1,0,0
+1075,100229,2,1,0,0
+1075,100345,2,1,0,0
+1075,100415,2,1,0,0
+1076,100054,4,1,0,0
+1076,100282,4,1,0,0
+1076,100726,4,1,0,0
+1076,100053,3,1,0,0
+1076,100269,3,1,0,0
+1076,100422,3,1,0,0
+1076,100757,3,1,0,0
+1076,100051,2,1,0,0
+1076,100180,2,1,0,0
+1076,100230,2,1,0,0
+1076,100346,2,1,0,0
+1076,100414,2,1,0,0
+1077,100984,4,1,0,1
+1077,100997,3,1,0,1
+1077,100998,3,1,0,1
+1077,100986,4,1,0,1
+1077,101001,3,1,0,1
+1077,101002,3,1,0,1
+1077,101025,2,1,0,1
+1077,101026,2,1,0,1
+1077,101027,2,1,0,1
+1081,100987,4,1,0,0
+1081,100988,4,1,0,0
+1081,101003,3,1,0,0
+1085,100008,4,1,0,1
+1085,100017,4,1,0,1
+1085,100026,4,1,0,1
+1085,100034,4,1,0,1
+1085,100041,4,1,0,1
+1085,100048,4,1,0,1
+1085,100054,4,1,0,1
+1085,100060,4,1,0,1
+1085,100066,4,1,0,1
+1085,100078,4,1,0,1
+1085,100072,4,1,0,1
+1085,100084,4,1,0,1
+1085,100090,4,1,0,1
+1085,100282,4,1,0,1
+1085,100285,4,1,0,1
+1085,100284,4,1,0,1
+1085,100286,4,1,0,1
+1085,100280,4,1,0,1
+1085,100276,4,1,0,1
+1085,100277,4,1,0,1
+1085,100275,4,1,0,1
+1085,100278,4,1,0,1
+1085,100431,4,1,0,1
+1085,100407,4,1,0,1
+1085,100432,4,1,0,1
+1085,100433,4,1,0,1
+1085,100434,4,1,0,1
+1085,100435,4,1,0,1
+1085,100436,4,1,0,1
+1085,100437,4,1,0,1
+1085,100438,4,1,0,1
+1085,100439,4,1,0,1
+1085,100760,4,1,0,1
+1085,100761,4,1,0,1
+1085,100779,4,1,0,1
+1085,100767,4,1,0,1
+1085,100780,4,1,0,1
+1085,100784,4,1,0,1
+1085,100768,4,1,0,1
+1085,100725,4,1,0,1
+1085,100726,4,1,0,1
+1085,100984,4,1,0,1
+1085,100985,4,1,0,1
+1085,100987,4,1,0,1
+1085,100988,4,1,0,1
+1085,100986,4,1,0,1
+1085,100989,4,1,0,1
+1085,100982,4,1,0,1
+1085,100983,4,1,0,1
+1085,100787,4,1,0,1
+1085,101293,4,1,0,1
+1085,101294,4,1,0,1
+1085,101295,4,1,0,1
+1085,101296,4,1,0,1
+1085,101297,4,1,0,1
+1085,101320,4,1,0,1
+1085,101567,4,1,0,1
+1085,101592,4,1,0,1
+1085,101593,4,1,0,1
+1085,101594,4,1,0,1
+1085,101595,4,1,0,1
+1089,100989,4,1,0,0
+1089,101004,3,1,0,0
+1089,101005,3,1,0,0
+1104,101293,4,1,0,0
+1104,101294,4,1,0,0
+1104,101298,3,1,0,0
+1111,100008,4,1,0,1
+1111,100017,4,1,0,1
+1111,100026,4,1,0,1
+1111,100034,4,1,0,1
+1111,100041,4,1,0,1
+1111,100048,4,1,0,1
+1111,100054,4,1,0,1
+1111,100060,4,1,0,1
+1111,100066,4,1,0,1
+1111,100078,4,1,0,1
+1111,100072,4,1,0,1
+1111,100084,4,1,0,1
+1111,100090,4,1,0,1
+1111,100282,4,1,0,1
+1111,100285,4,1,0,1
+1111,100284,4,1,0,1
+1111,100286,4,1,0,1
+1111,100280,4,1,0,1
+1111,100276,4,1,0,1
+1111,100277,4,1,0,1
+1111,100275,4,1,0,1
+1111,100278,4,1,0,1
+1111,100431,4,1,0,1
+1111,100407,4,1,0,1
+1111,100432,4,1,0,1
+1111,100433,4,1,0,1
+1111,100434,4,1,1,1
+1111,100435,4,1,1,1
+1111,100436,4,1,0,1
+1111,100437,4,1,0,1
+1111,100438,4,1,0,1
+1111,100439,4,1,0,1
+1111,100760,4,1,1,1
+1111,100761,4,1,0,1
+1111,100779,4,1,0,1
+1111,100767,4,1,0,1
+1111,100780,4,1,1,1
+1111,100784,4,1,1,1
+1111,100768,4,1,0,1
+1111,100725,4,1,1,1
+1111,100726,4,1,1,1
+1111,100985,4,1,1,1
+1111,100988,4,1,1,1
+1111,100989,4,1,1,1
+1111,100982,4,1,1,1
+1111,100983,4,1,1,1
+1111,101293,4,1,1,1
+1111,101294,4,1,1,1
+1111,101295,4,1,1,1
+1111,101320,4,1,1,1
+1135,101567,4,1,0,0
+1135,101592,4,1,0,0
+1135,101594,4,1,0,0
+1135,101595,4,1,0,0
+1135,101566,3,1,0,0
+1135,101602,3,1,0,0
+1135,101603,3,1,0,0
+1135,101619,2,1,0,0
+1156,101604,3,1,0,0
+1156,101605,3,1,0,0
+1156,101607,3,1,0,0
+1156,101608,3,1,0,0
+1156,101596,4,1,0,0
+1156,101597,4,1,0,0
+1156,101599,4,1,0,0
+1156,101600,4,1,0,0
+1149,100003,2,1,0,0
+1149,100004,2,1,0,0
+1149,100012,2,1,0,0
+1149,100013,2,1,0,0
+1149,100021,2,1,0,0
+1149,100022,2,1,0,0
+1149,100173,2,1,0,0
+1149,100174,2,1,0,0
+1149,100175,2,1,0,0
+1149,100339,2,1,0,0
+1149,100340,2,1,0,0
+1149,100341,2,1,0,0
+1149,100223,2,1,0,0
+1149,100224,2,1,0,0
+1149,100225,2,1,0,0
+1149,100692,2,1,0,0
+1149,100693,2,1,0,0
+1149,100694,2,1,0,0
+1149,101020,2,1,0,0
+1149,101025,2,1,0,0
+1149,100418,3,1,0,0
+1149,101005,3,1,0,0
+1149,100785,3,1,0,0
+1149,100786,3,1,0,0
+1149,101602,3,1,0,0
+1149,101604,3,1,0,0
+1149,100760,4,1,0,0
+1149,100780,4,1,0,0
+1149,100987,4,1,0,0
+1149,101295,4,1,0,0
+1149,101296,4,1,0,0
+1149,101592,4,1,0,0
+1163,100008,4,1,0,1
+1163,100017,4,1,0,1
+1163,100026,4,1,0,1
+1163,100034,4,1,0,1
+1163,100041,4,1,0,1
+1163,100048,4,1,0,1
+1163,100054,4,1,0,1
+1163,100060,4,1,0,1
+1163,100066,4,1,0,1
+1163,100078,4,1,0,1
+1163,100072,4,1,0,1
+1163,100084,4,1,0,1
+1163,100090,4,1,0,1
+1163,100282,4,1,0,1
+1163,100285,4,1,0,1
+1163,100284,4,1,0,1
+1163,100286,4,1,0,1
+1163,100280,4,1,0,1
+1163,100276,4,1,0,1
+1163,100277,4,1,0,1
+1163,100275,4,1,0,1
+1163,100278,4,1,0,1
+1163,100431,4,1,0,1
+1163,100407,4,1,0,1
+1163,100432,4,1,0,1
+1163,100433,4,1,0,1
+1163,100434,4,1,0,1
+1163,100435,4,1,0,1
+1163,100436,4,1,0,1
+1163,100437,4,1,0,1
+1163,100438,4,1,0,1
+1163,100439,4,1,0,1
+1163,100760,4,1,0,1
+1163,100761,4,1,0,1
+1163,100779,4,1,0,1
+1163,100767,4,1,0,1
+1163,100780,4,1,0,1
+1163,100784,4,1,0,1
+1163,100768,4,1,0,1
+1163,100725,4,1,0,1
+1163,100726,4,1,0,1
+1163,100984,4,1,0,1
+1163,100985,4,1,0,1
+1163,100987,4,1,0,1
+1163,100988,4,1,0,1
+1163,100986,4,1,0,1
+1163,100989,4,1,0,1
+1163,100982,4,1,0,1
+1163,100983,4,1,0,1
+1163,100787,4,1,0,1
+1163,101293,4,1,0,1
+1163,101294,4,1,0,1
+1163,101295,4,1,0,1
+1163,101296,4,1,0,1
+1163,101297,4,1,0,1
+1163,101320,4,1,0,1
+1163,101567,4,1,0,1
+1164,100008,4,1,0,1
+1164,100017,4,1,0,1
+1164,100026,4,1,0,1
+1164,100034,4,1,0,1
+1164,100041,4,1,0,1
+1164,100048,4,1,0,1
+1164,100054,4,1,0,1
+1164,100060,4,1,0,1
+1164,100066,4,1,0,1
+1164,100078,4,1,0,1
+1164,100072,4,1,0,1
+1164,100084,4,1,0,1
+1164,100090,4,1,0,1
+1164,100282,4,1,0,1
+1164,100285,4,1,0,1
+1164,100284,4,1,0,1
+1164,100286,4,1,0,1
+1164,100280,4,1,0,1
+1164,100276,4,1,0,1
+1164,100277,4,1,0,1
+1164,100275,4,1,0,1
+1164,100278,4,1,0,1
+1164,100431,4,1,0,1
+1164,100407,4,1,0,1
+1164,100432,4,1,0,1
+1164,100433,4,1,0,1
+1164,100434,4,1,0,1
+1164,100435,4,1,0,1
+1164,100436,4,1,0,1
+1164,100437,4,1,0,1
+1164,100438,4,1,0,1
+1164,100439,4,1,0,1
+1164,100760,4,1,0,1
+1164,100761,4,1,0,1
+1164,100779,4,1,0,1
+1164,100767,4,1,0,1
+1164,100780,4,1,0,1
+1164,100784,4,1,0,1
+1164,100768,4,1,0,1
+1164,100725,4,1,0,1
+1164,100726,4,1,0,1
+1164,100984,4,1,0,1
+1164,100985,4,1,0,1
+1164,100987,4,1,0,1
+1164,100988,4,1,0,1
+1164,100986,4,1,0,1
+1164,100989,4,1,0,1
+1164,100982,4,1,0,1
+1164,100983,4,1,0,1
+1164,100787,4,1,0,1
+1164,101293,4,1,0,1
+1164,101294,4,1,0,1
+1164,101295,4,1,0,1
+1164,101296,4,1,0,1
+1164,101297,4,1,0,1
+1164,101320,4,1,0,1
+1164,101567,4,1,0,1
+1164,101592,4,1,0,1
+1164,101593,4,1,0,1
+1164,101594,4,1,0,1
+1164,101595,4,1,0,1
+1164,101598,4,1,0,1
+1164,101596,4,1,0,1
+1164,101597,4,1,0,1
+1164,101599,4,1,0,1
+1164,101600,4,1,0,1
+1141,101600,4,1,0,1
+1141,101608,3,1,0,1

titles/cm/cm_data/MU3/static_gachas.csv

@@ -0,0 +1,69 @@
+"version","gachaId","gachaName","type","kind","isCeiling","maxSelectPoint"
+6,1011,"無料ガチャ",0,3,0,0
+6,1012,"無料ガチャ（SR確定）",0,3,0,0
+6,1043,"レギュラーガチャ",0,0,0,0
+6,1067,"例えるなら大人のパッションフルーツ
+リゾートプールガチャ",0,1,0,0
+6,1068,"柏木 咲姫
+ピックアップガチャ",0,2,0,0
+6,1069,"井之原 小星
+ピックアップガチャ",0,2,0,0
+6,1070,"目指すは優勝！
+炎の体育祭リミテッドガチャ",0,1,1,110
+6,1071,"星咲 あかり
+ピックアップガチャ",0,2,0,0
+6,1072,"藤沢 柚子
+ピックアップガチャ",0,2,0,0
+6,1073,"三角 葵
+ピックアップガチャ",0,2,0,0
+6,1074,"おくれてきた
+Halloweenガチャ",0,1,0,0
+6,1075,"早乙女 彩華
+ピックアップガチャ",0,2,0,0
+6,1076,"桜井 春菜
+ピックアップガチャ",0,2,0,0
+6,1077,"ふわふわすぺーす
+お仕事体験リミテッドガチャ",0,1,1,110
+6,1078,"高瀬 梨緒
+ピックアップガチャ",0,2,0,0
+6,1079,"結城 莉玖
+ピックアップガチャ",0,2,0,0
+6,1080,"藍原 椿
+ピックアップガチャ",0,2,0,0
+6,1081,"今夜はおうちでパーティ☆
+メリクリガチャ",0,1,0,0
+6,1082,"日向 千夏
+ピックアップガチャ",0,2,0,0
+6,1083,"柏木 美亜
+ピックアップガチャ",0,2,0,0
+6,1084,"東雲 つむぎ
+ピックアップガチャ",0,2,0,0
+6,1085,"謹賀新年
+福袋ガチャ",0,0,1,33
+6,1086,"逢坂 茜
+ピックアップガチャ",0,2,0,0
+6,1087,"珠洲島 有栖
+ピックアップガチャ",0,2,0,0
+6,1088,"九條 楓
+ピックアップガチャ",0,2,0,0
+6,1089,"冬の魔法
+スーパーウルトラウィンターガチャ",0,1,0,0
+6,1093,"高瀬 梨緒ピックアップガチャ",0,2,0,0
+6,1094,"結城 莉玖ピックアップガチャ",0,2,0,0
+6,1095,"藍原 椿ピックアップガチャ",0,2,0,0
+6,1096,"早乙女 彩華ピックアップガチャ",0,2,0,0
+6,1097,"桜井 春菜ピックアップガチャ",0,2,0,0
+6,1098,"逢坂 茜ピックアップガチャ",0,2,0,0
+6,1099,"九條 楓ピックアップガチャ",0,2,0,0
+6,1100,"珠洲島 有栖ピックアップガチャ",0,2,0,0
+6,1101,"LEAF属性オンリーガチャ",0,2,0,0
+6,1102,"AQUA属性オンリーガチャ",0,2,0,0
+6,1103,"FIRE属性オンリーガチャ",0,2,0,0
+6,1104,"夜明け前の双星ガチャ",0,1,0,0
+6,1105,"謎の洞窟 黄金は実在した!!ガチャ",0,1,0,0
+6,1106,"スウィートブライダルリミテッドガチャ",0,1,0,0
+6,1107,"忘れられない、愛（ピュア）とロックがここにある。ガチャ",0,1,0,0
+6,1108,"メルティ夜ふかしガチャ",0,1,0,0
+6,1109,"絵本の国のシューターズガチャ",0,1,0,0
+6,1110,"オンゲキ R.E.D. PLUS 大感謝祭ガチャ",0,1,0,0
+6,1111,"オンゲキ 3rd Anniversaryガチャ",0,1,1,33

titles/cm/config.py

@@ -0,0 +1,25 @@
+from core.config import CoreConfig
+
+
+class CardMakerServerConfig:
+    def __init__(self, parent_config: "CardMakerConfig") -> None:
+        self.__config = parent_config
+
+    @property
+    def enable(self) -> bool:
+        return CoreConfig.get_config_field(
+            self.__config, "cardmaker", "server", "enable", default=True
+        )
+
+    @property
+    def loglevel(self) -> int:
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "cardmaker", "server", "loglevel", default="info"
+            )
+        )
+
+
+class CardMakerConfig(dict):
+    def __init__(self) -> None:
+        self.server = CardMakerServerConfig(self)

titles/cm/const.py

@@ -0,0 +1,13 @@
+class CardMakerConstants:
+    GAME_CODE = "SDED"
+
+    CONFIG_NAME = "cardmaker.yaml"
+
+    VER_CARD_MAKER = 0
+    VER_CARD_MAKER_135 = 1
+
+    VERSION_NAMES = ("Card Maker 1.34", "Card Maker 1.35")
+
+    @classmethod
+    def game_ver_to_string(cls, ver: int):
+        return cls.VERSION_NAMES[ver]

titles/cm/database.py

@@ -0,0 +1,8 @@
+from core.data import Data
+from core.config import CoreConfig
+
+
+class CardMakerData(Data):
+    def __init__(self, cfg: CoreConfig) -> None:
+        super().__init__(cfg)
+        # empty Card Maker database