diva: fix render_POST

.gitignore

@@ -145,7 +145,6 @@ dmypy.json
 cython_debug/
 
 .vscode/*
-.vs/*
 
 # Local History for Visual Studio Code
 .history/

LICENSE.txt

@@ -1,13 +0,0 @@
-           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                   Version 2, December 2004
- 
-Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
-
-Everyone is permitted to copy and distribute verbatim or modified
-copies of this license document, and changing it is allowed as long
-as the name is changed.
- 
-           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. You just DO WHAT THE FUCK YOU WANT TO.

changelog.md

@@ -1,118 +1,6 @@
 # Changelog
 Documenting updates to ARTEMiS, to be updated every time the master branch is pushed to.
 
-## 20250803
-+ CHUNITHM VERSE support added
-
-## 20250327
-+ O.N.G.E.K.I. bright MEMORY Act.3 support added
-+ CardMaker support updated
-
-## 20240811
-### System
-+ Change backend from Twisted to Starlette
-+ Implement async handlers
-+ Reboot times for multiple games have been fixed (thanks zaphkito!)
-
-### Frontend
-+ Edit button changed to View on the user page, and is where you can edit the card memo
-+ Add card now works as it should
-+ Add event log viewer in the `sys` page for sysadmins
-+ Add pages for Pokken, SAO, and maimai
-
-### AimeDB
-+ Now rejects all-zero access codes
-+ Stores card IDm (for AmusementIC) and MiFare ID (for old aime/banapass)
-  + ...unless that MiFare ID is 0x01020304 (the default for segatools)
-
-### maimai
-+ Add support for BUDDiES
-+ Rivals and Favorite Music support
-
-### Wacca
-+ Add option to block unregistered serials from accessing the title server
-
-### DIVA
-+ Fix for reading modded content (Thanks ThatzOkay!)
-
-### CHUNITHM
-+ Save net battle info
-
-## 20240630
-### DIVA
-+ Added configurable festa options'
-
-## 20240629
-### CHUNITHM
-+ Add team points
-
-## 20240628
-### maimai
-+ Add present support
-
-## 20240627
-### SAO
-+ Fix ghost items, character and player XP, EX Bonuses, unlocks, and much much more
-
-## 20240620
-### CHUNITHM
-+ CHUNITHM LUMINOUS support
-
-## 20240616
-### CHUNITHM
-+ Support network encryption for Export/International versions
-
-### DIVA
-+ Working frontend with name and level strings edit and playlog
-
-## 20240530
-### DIVA
-+ Fix reader for when dificulty is not a int
-
-## 20240526
-### DIVA
-+ Fixed missing awaits causing coroutine error
-
-## 20240524
-### DIVA
-+ Fixed new profile start request causing coroutine error
-
-## 20240523
-### DIVA
-+ Fixed binary handler & render_POST errors
-
-## 20240408
-### System
-+ Modified the game specific documentation
-
-## 20240407
-### Maimai
-+ Support maimai DX International [#118](https://gitea.tendokyu.moe/Hay1tsme/artemis/pulls/118) (Thanks beerpsi!)
-+ Fixed the maimai DX reboot time from config [#120](https://gitea.tendokyu.moe/Hay1tsme/artemis/pulls/120) (Thanks topty!)
-
-## 20240318
-### CXB
-+ Fixing handle_data_shop_list_detail_request for Sunrise S1
-
-## 20240302
-### SAO
-+ Fixing new profile creation with right heroes and start VP
-+ Fix to the Unanalyzed Log responses returning the wrong rewards
-+ Documentation revised
-
-## 20240226
-### CXB
-+ Fixing paths for rev.py
-+ Changed encoding for handle_data_item_list_icon_request
-
-## 20240202
-### SAO
-+ Added reader assets and edited the game specific documentation
-
-## 20240118
-### System
-+ Added game version names to the readme
-
 ## 20240109
 ### System
 + Removed `ADD config config` from dockerfile [#83](https://gitea.tendokyu.moe/Hay1tsme/artemis/pulls/83) (Thanks zaphkito!)

contributing.md

@@ -1,182 +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). This guide assume you're familiar with both git, python, and the libraries that artemis uses.
-
-This document is a work in progress. If you have any questions or notice any errors, please report it to the discord.
+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
-### Step 0
-+ Follow the "n-1" rule of thumb. PRs for game versions that are currently active in arcades will be deleted. If you're unsure, ask!
-+ Always PR against the `develop` branch.
-+ Check to see if somebody else is already PRing the features/games you want to add. If they are, consider contributing to them rather then making an entirely new PR.
-+ We don't technically have a written code style guide (TODO) but try to keep your code consistant with code that's already there where possible.
-
-### Step 1 (Setup)
-1) Fork the gitea repo, clone your fork, and checkout the develop branch.
-2) Make a new folder in the `titles` folder, name it some recogniseable shorthand for your game (Chunithm becomes chuni, maimai dx is mai2, etc)
-3) In this new folder, create a file named `__init__.py`. This is the first thing that will load when your title module is loaded by the core system, and it acts as sort of a directory for where everything lives in your module. This file will contain the following required items:
-    + `index`: must point to a subclass of `BaseServlet` that will handle setup and dispatching of your game.
-    + `game_codes`: must be a list of 4 letter SEGA game codes as strings.
-
-    It can also contain the following optional fields:
-    + `database`: points to a subclass of `Data` that contains one or more subclasses of `BaseData` that act as database transaction handlers. Required for the class to store and retrieve data from the database.
-    + `reader`: points to a subclass of `BaseReader` that handles importing static data from game files into the database.
-    + `frontend`: points to a subclass of `FE_Base` that handles frontend routes for your game.
-
-    The next step will focus on `index`
-
-### Step 2 (Index)
-1) Create another file in your game's folder. By convention, it should be called `index.py`.
-
-2) Inside `index.py`, add the following code, replacing {Game name here} with the name of your game, without spaces or special characters. Look at other titles for examples.
-```py
-from core.title import BaseServlet
-from core import CoreConfig
-
-class {Game name here}Servlet(BaseServlet):
-    def __init__(self, core_cfg: CoreConfig, cfg_dir: str) -> None:
-        pass
-```
-3) The `__init__` function should acomplish the following:
-    + Reading your game's config
-    + Setting up your games logger
-    + Instancing your games versions
-    
-    It's usually safe to copy and paste the `__init__` functions from other games, just make sure you change everything that needs to be changed!
-
-4) Go back to the `__init__.py` that you created and add the following:
-```py
-from .index import {Game name here}Servlet
-
-index = {Game name here}Servlet
-```
-
-5) Going back to `index.py`, within the Servlet class, define the following functions from `BaseServlet` as needed (see function documentation):
-    + `is_game_enabled`: Returns true if the game is enabled and should be served, false otherwise. Returns false by default, so override this to allow your game to be served.
-    + `get_routes`: Returns a list of Starlette routes that your game will serve.
-    + `get_allnet_info`: Returns a tuple of strings where the first is the allnet uri and the second is the allnet host. The function takes the game ID, version and keychip ID as parameters, so you can send different responses if need be.
-    + `get_mucha_info`: Only used by games that use Mucha as authentication. Returns a tuple where the first is a bool that is weather or not the game is enabled, the 2nd is a list of game CDs as strings that this servlet should handle, and the 3rd is a list of netID prefixes that each game CD should use. If your game does not use mucha, do not define this function.
-    + `setup`: Preforms any setup your servlet requires, such as spinning up matching servers. It is run once when the server starts. If you don't need any setup, do not define.
-
-6) Make sure any functions you specify to handle routes in `get_routes` are defined as async, as follows: `async def handle_thing(self, request: Request) -> Response:` where Response is whatever kind of Response class you'll be returning. Make sure all paths in this function return some subclass of Response, otherwise you'll get an error when serving.
-
-### Step 3 (Constants)
-1) In your game's folder, create a file to store static values for your game. By convention, we call this `const.py`
-
-2) Inside, create a class called `{Game name here}Constants`. Do not define an `__init__` function.
-
-3) Put constants related to your game here. A good example of something to put here is game codes.
-```py
-class {Game name here}Constants:
-    GAME_CODE = "SBXX"
-    CONFIG_NAME = "{game name}.yaml"
-```
-
-4) If you choose to put game codes in here, add this to your `__init__.py` file:
-```py
-from .const import {Game name here}Constants
-...
-game_codes = [{Game name here}Constants.GAME_CODE]
-```
-
-### Step 4 (Config)
-1) Make a file to store your game's config. By convention, it should be called `config.py`
-
-2) Inside that file, add the following:
-```py
-from core.config import CoreConfig
-
-class {game name}ServerConfig:
-    def __init__(self, parent_config: "{game name}Config") -> None:
-        self.__config = parent_config
-
-    @property
-    def enable(self) -> bool:
-        return CoreConfig.get_config_field(
-            self.__config, "{game name}", "server", "enable", default=True
-        )
-
-    @property
-    def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(
-            CoreConfig.get_config_field(
-                self.__config, "{game name}", "server", "loglevel", default="info"
-            )
-        )
-
-class {game name}Config(dict):
-    def __init__(self) -> None:
-        self.server = {game name}ServerConfig(self)
-```
-
-3) In the `example_config` folder, create a yaml file for your game. By convention, it should be called `{game folder name}.ymal`. Add the following:
-```yaml
-server:
-    enable: True
-    loglevel: "info"
-```
-
-4) Add any additional config options that you feel the game needs. Look to other games for config examples.
-
-5) In `index.py` import your config and instance it in `__init__` with:
-```py
-self.game_cfg = {game folder name}Config()
-if path.exists(f"{cfg_dir}/{game folder name}Constants.CONFIG_NAME}"):
-    self.game_cfg.update(
-        yaml.safe_load(open(f"{cfg_dir}/{game folder name}Constants.CONFIG_NAME}"))
-    )
-```
-This will attempt to load the config file you specified in your constants, and if not, go with the defaults specified in `config.py`. This game_cfg object can then be passed down to your handlers when you create them.
-
-At this stage your game should be loaded by allnet, and serve whatever routes you put in `get_routes`. See the next section about adding versions and handlers.
-
-### Step 5 (Database)
-TODO
-
-### Step 6 (Frontend)
-TODO
-
-### Step 7 (Reader)
-TODO
+Guide WIP
 
 ## Adding game versions
-See the above section about code expectations and how to PR.
-1) In the game's folder, create a python file to contain the version handlers. By convention, the first version is version 0, and is stored in `base.py`. Versions following that increment the version number, and are stored in `{short version name}.py`. See Wacca's folder for an example of how to name versions.
-
-2) Internal version numbers should be defined in `const.py`. The version should change any time the game gets a major update (i.e. a new version or plus version.)
-```py
-# in const.py
-VERSION_{game name} = 0
-VERSION_{game name}_PLUS = 1
-```
-
-3) Inside `base.py` (or whatever your version is named) add the following:
-```py
-class {game name}Base:
-    def __init__(self, cfg: CoreConfig, game_cfg: {game name}Config) -> None:
-        self.game_config = game_cfg
-        self.core_config = cfg
-        self.version = {game name}Constants.VERSION_{game name}
-        self.data = {game name}Data(cfg)
-        # Any other initialization stuff
-```
-
-4) Define your handlers. This will vary wildly by game, but best practice is to keep the naming consistant, so that the main dispatch function in `index.py` can use `getattr` to get the handler, rather then having a static list of what endpoint or request type goes to which handler. See Wacca's `index.py` and `base.py` for examples of how to do this.
-
-5) If your version is not the base version, make sure it inherits from the base version:
-```py
-class {game name}Plus({game name}Base):
-    def __init__(self, cfg: CoreConfig, game_cfg: {game name}Config) -> None:
-        super().__init__(cfg, game_cfg)
-        self.version = {game name}Constants.VERSION_{game name}_PLUS
-```
-
-6) Back in `index.py` make sure to import your new class, and add it to `__init__`. Some games may opt to just a single list called `self.versions` that contains all the version classes at their internal version's index. Others may simply define them as seperate members. See Wacca for an example of `self.versions`
-
-7) Add your version to your game's dispatching logic.
-
-8) Test to make sure your game is being handled properly.
-
-9) Submit a PR.
-
-## Adding/improving core services
-If you intend to submit improvements or additions to core services (allnet, mucha, billing, aimedb, database, etc) please get in touch with a maintainer.
+Guide WIP

core/__init__.py

@@ -1,5 +1,7 @@
 from core.config import CoreConfig
+from core.allnet import AllnetServlet, BillingServlet
 from core.aimedb import AimedbServlette
 from core.title import TitleServlet
 from core.utils import Utils
 from core.mucha import MuchaServlet
+from core.frontend import FrontendServlet

core/adb_handlers/__init__.py

@@ -2,5 +2,5 @@ from .base import ADBBaseRequest, ADBBaseResponse, ADBHeader, ADBHeaderException
 from .base import CompanyCodes, ReaderFwVer, CMD_CODE_GOODBYE, HEADER_SIZE
 from .lookup import ADBLookupRequest, ADBLookupResponse, ADBLookupExResponse
 from .campaign import ADBCampaignClearRequest, ADBCampaignClearResponse, ADBCampaignResponse, ADBOldCampaignRequest, ADBOldCampaignResponse
-from .felica import ADBFelicaLookupRequest, ADBFelicaLookupResponse, ADBFelicaLookupExRequest, ADBFelicaLookupExResponse
+from .felica import ADBFelicaLookupRequest, ADBFelicaLookupResponse, ADBFelicaLookup2Request, ADBFelicaLookup2Response
 from .log import ADBLogExRequest, ADBLogRequest, ADBStatusLogRequest, ADBLogExResponse

core/adb_handlers/base.py

@@ -120,7 +120,7 @@ class ADBHeader:
         if self.store_id == 0:
             raise ADBHeaderException(f"Store ID cannot be 0!")
 
-        if re.fullmatch(r"^A[0-9]{2}[A-Z][0-9]{2}[A-HJ-NP-Z][0-9]{4}$", self.keychip_id) is None:
+        if re.fullmatch(r"^A[0-9]{2}[E|X][0-9]{2}[A-HJ-NP-Z][0-9]{4}$", self.keychip_id) is None:
             raise ADBHeaderException(f"Keychip ID {self.keychip_id} is invalid!")
         
         return True

core/adb_handlers/felica.py

@@ -10,14 +10,13 @@ class ADBFelicaLookupRequest(ADBBaseRequest):
         self.pmm = hex(pmm)[2:].upper()
 
 class ADBFelicaLookupResponse(ADBBaseResponse):
-    def __init__(self, access_code: str = None, idx: int = 0, game_id: str = "SXXX", store_id: int = 1, keychip_id: str = "A69E01A8888", code: int = 0x03, length: int = 0x30, status: int = 1) -> None:
+    def __init__(self, access_code: str = None, game_id: str = "SXXX", store_id: int = 1, keychip_id: str = "A69E01A8888", code: int = 0x03, length: int = 0x30, status: int = 1) -> None:
         super().__init__(code, length, status, game_id, store_id, keychip_id)
         self.access_code = access_code if access_code is not None else "00000000000000000000"
-        self.idx = idx
     
     @classmethod
-    def from_req(cls, req: ADBHeader, access_code: str = None, idx: int = 0) -> "ADBFelicaLookupResponse":
-        c = cls(access_code, idx, req.game_id, req.store_id, req.keychip_id)
+    def from_req(cls, req: ADBHeader, access_code: str = None) -> "ADBFelicaLookupResponse":
+        c = cls(access_code, req.game_id, req.store_id, req.keychip_id)
         c.head.protocol_ver = req.protocol_ver
         return c
     
@@ -27,7 +26,7 @@ class ADBFelicaLookupResponse(ADBBaseResponse):
             "access_code" / Int8ub[10],
             Padding(2)
         ).build(dict(
-            felica_idx = self.idx,
+            felica_idx = 0,
             access_code = bytes.fromhex(self.access_code)
         ))
 
@@ -35,18 +34,18 @@ class ADBFelicaLookupResponse(ADBBaseResponse):
 
         return self.head.make() + resp_struct
 
-class ADBFelicaLookupExRequest(ADBBaseRequest):
+class ADBFelicaLookup2Request(ADBBaseRequest):
     def __init__(self, data: bytes) -> None:
         super().__init__(data)
         self.random = struct.unpack_from("<16s", data, 0x20)[0]
-        idm, dfc, self.arbitrary = struct.unpack_from(">QH6s", data, 0x30)
+        idm, pmm = struct.unpack_from(">QQ", data, 0x30)
         self.card_key_ver, self.write_ct, self.maca, company, fw_ver, self.dfc = struct.unpack_from("<16s16sQccH", data, 0x40)
         self.idm = hex(idm)[2:].upper()
-        self.dfc = hex(dfc)[2:].upper()
+        self.pmm = hex(pmm)[2:].upper()
         self.company = CompanyCodes(int.from_bytes(company, 'little'))
         self.fw_ver = ReaderFwVer.from_byte(fw_ver)
 
-class ADBFelicaLookupExResponse(ADBBaseResponse):
+class ADBFelicaLookup2Response(ADBBaseResponse):
     def __init__(self, user_id: Union[int, None] = None, access_code: Union[str, None] = None, game_id: str = "SXXX", store_id: int = 1, keychip_id: str = "A69E01A8888", code: int = 0x12, length: int = 0x130, status: int = 1) -> None:
         super().__init__(code, length, status, game_id, store_id, keychip_id)
         self.user_id = user_id if user_id is not None else -1
@@ -56,7 +55,7 @@ class ADBFelicaLookupExResponse(ADBBaseResponse):
         self.auth_key = [0] * 256
 
     @classmethod
-    def from_req(cls, req: ADBHeader, user_id: Union[int, None] = None, access_code: Union[str, None] = None) -> "ADBFelicaLookupExResponse":
+    def from_req(cls, req: ADBHeader, user_id: Union[int, None] = None, access_code: Union[str, None] = None) -> "ADBFelicaLookup2Response":
         c = cls(user_id, access_code, req.game_id, req.store_id, req.keychip_id)
         c.head.protocol_ver = req.protocol_ver
         return c

core/aimedb.py

@@ -66,8 +66,7 @@ class AimedbServlette():
     
     def start(self) -> None:
         self.logger.info(f"Start on port {self.config.aimedb.port}")
-        addr = self.config.aimedb.listen_address if self.config.aimedb.listen_address else self.config.server.listen_address
-        asyncio.create_task(asyncio.start_server(self.dataReceived, addr, self.config.aimedb.port))
+        asyncio.create_task(asyncio.start_server(self.dataReceived, self.config.server.listen_address, self.config.aimedb.port))
     
     async def dataReceived(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
         self.logger.debug(f"Connection made from {writer.get_extra_info('peername')[0]}")
@@ -137,7 +136,7 @@ class AimedbServlette():
             resp_bytes = resp
         
         elif resp is None: # Nothing to send, probably a goodbye
-            self.logger.warning(f"None return by handler for {name}")
+            self.logger.warn(f"None return by handler for {name}")
             return
         
         else:
@@ -176,12 +175,6 @@ class AimedbServlette():
 
     async def handle_lookup(self, data: bytes, resp_code: int) -> ADBBaseResponse:
         req = ADBLookupRequest(data)
-        if req.access_code == "00000000000000000000":
-            self.logger.warning(f"All-zero access code from {req.head.keychip_id}")
-            ret = ADBLookupResponse.from_req(req.head, -1)
-            ret.head.status = ADBStatus.BAN_SYS
-            return ret
-        
         user_id = await self.data.card.get_user_id_from_card(req.access_code)
         is_banned = await self.data.card.get_card_banned(req.access_code)
         is_locked = await self.data.card.get_card_locked(req.access_code)
@@ -197,22 +190,10 @@ class AimedbServlette():
         self.logger.info(
             f"access_code {req.access_code} -> user_id {ret.user_id}"
         )
-        
-        if user_id and user_id > 0:
-            await self.data.card.update_card_last_login(req.access_code)
-            if (req.access_code.startswith("010") or req.access_code.startswith("3")) and req.serial_number != 0x04030201: # Default segatools sn
-                await self.data.card.set_chip_id_by_access_code(req.access_code, req.serial_number)
-                self.logger.info(f"Attempt to set chip id to {req.serial_number:08X} for access code {req.access_code}")
         return ret
 
     async def handle_lookup_ex(self, data: bytes, resp_code: int) -> ADBBaseResponse:
         req = ADBLookupRequest(data)
-        if req.access_code == "00000000000000000000":
-            self.logger.warning(f"All-zero access code from {req.head.keychip_id}")
-            ret = ADBLookupExResponse.from_req(req.head, -1)
-            ret.head.status = ADBStatus.BAN_SYS
-            return ret
-        
         user_id = await self.data.card.get_user_id_from_card(req.access_code)
 
         is_banned = await self.data.card.get_card_banned(req.access_code)
@@ -238,56 +219,29 @@ class AimedbServlette():
                 self.logger.debug(f"Generated auth token {auth_key}")
                 ret.auth_key = auth_key_full
 
-        if user_id and user_id > 0:
-            await self.data.card.update_card_last_login(req.access_code)
         return ret
 
     async def handle_felica_lookup(self, data: bytes, resp_code: int) -> bytes:
         """
-        On official, the IDm is used as a key to look up the stored access code in a large
-        database. We do not have access to that database so we have to make due with what we got.
-        Interestingly, namco games are able to read S_PAD0 and send the server the correct access
-        code, but aimedb doesn't. Until somebody either enters the correct code manually, or scans
-        on a game that reads it correctly from the card, this will have to do. It's the same conversion
-        used on the big boy networks.
+        On official, I think a card has to be registered for this to actually work, but 
+        I'm making the executive decision to not implement that and just kick back our
+        faux generated access code. The real felica IDm -> access code conversion is done
+        on the ADB server, which we do not and will not ever have access to. Because we can
+        assure that all IDms will be unique, this basic 0-padded hex -> int conversion will
+        be fine.
         """
         req = ADBFelicaLookupRequest(data)
-        idm = req.idm.zfill(16)
-        if idm == "0000000000000000":
-            self.logger.warning(f"All-zero IDm from {req.head.keychip_id}")
-            ret = ADBFelicaLookupResponse.from_req(req.head, "00000000000000000000")
-            ret.head.status = ADBStatus.BAN_SYS
-            return ret
-
-        card = await self.data.card.get_card_by_idm(idm)
-        if not card:
-            ac = self.data.card.to_access_code(idm)
-            test = await self.data.card.get_card_by_access_code(ac)
-            if test:
-                await self.data.card.set_idm_by_access_code(ac, idm)
-        
-        else:
-            ac = card['access_code']
-        
+        ac = self.data.card.to_access_code(req.idm)
         self.logger.info(
-            f"idm {idm} pmm {req.pmm.zfill(16)} -> access_code {ac}"
+            f"idm {req.idm} ipm {req.pmm} -> access_code {ac}"
         )
         return ADBFelicaLookupResponse.from_req(req.head, ac)
 
     async def handle_felica_register(self, data: bytes, resp_code: int) -> bytes:
         """
-        Used to register felica moble access codes. Will never be used on our network
-        because we don't implement felica_lookup properly.
+        I've never seen this used.
         """
         req = ADBFelicaLookupRequest(data)
-        idm = req.idm.zfill(16)
-        
-        if idm == "0000000000000000":
-            self.logger.warning(f"All-zero IDm from {req.head.keychip_id}")
-            ret = ADBFelicaLookupResponse.from_req(req.head, "00000000000000000000")
-            ret.head.status = ADBStatus.BAN_SYS
-            return ret
-        
         ac = self.data.card.to_access_code(req.idm)
         
         if self.config.server.allow_user_registration:
@@ -313,49 +267,21 @@ class AimedbServlette():
                 f"Registration blocked!: access code {ac} (IDm: {req.idm} PMm: {req.pmm})"
             )
 
-        if user_id > 0:
-            await self.data.card.update_card_last_login(ac)
         return ADBFelicaLookupResponse.from_req(req.head, ac)
 
     async def handle_felica_lookup_ex(self, data: bytes, resp_code: int) -> bytes:
-        req = ADBFelicaLookupExRequest(data)
-        user_id = None
-        idm = req.idm.zfill(16)
-        
-        if idm == "0000000000000000":
-            self.logger.warning(f"All-zero IDm from {req.head.keychip_id}")
-            ret = ADBFelicaLookupExResponse.from_req(req.head, -1, "00000000000000000000")
-            ret.head.status = ADBStatus.BAN_SYS
-            return ret
-        
-        card = await self.data.card.get_card_by_idm(idm)
-        if not card:
-            access_code = self.data.card.to_access_code(idm)
-            card = await self.data.card.get_card_by_access_code(access_code)
-            if card:
-                user_id = card['user']
-                await self.data.card.set_idm_by_access_code(access_code, idm)
-        
-        else:
-            user_id = card['user']
-            access_code = card['access_code']
+        req = ADBFelicaLookup2Request(data)
+        access_code = self.data.card.to_access_code(req.idm)
+        user_id = await self.data.card.get_user_id_from_card(access_code=access_code)
 
         if user_id is None:
             user_id = -1
 
         self.logger.info(
-            f"idm {idm} dfc {req.dfc} -> access_code {access_code} user_id {user_id}"
+            f"idm {req.idm} ipm {req.pmm} -> access_code {access_code} user_id {user_id}"
         )
 
-        resp = ADBFelicaLookupExResponse.from_req(req.head, user_id, access_code)
-        
-        if user_id > 0:
-            if card['is_banned'] and card['is_locked']:
-                resp.head.status = ADBStatus.BAN_SYS_USER
-            elif card['is_banned']:
-                resp.head.status = ADBStatus.BAN_SYS
-            elif card['is_locked']:
-                resp.head.status = ADBStatus.LOCK_USER
+        resp = ADBFelicaLookup2Response.from_req(req.head, user_id, access_code)
 
         if user_id and user_id > 0 and self.config.aimedb.id_secret:
             auth_key = create_sega_auth_key(user_id, req.head.game_id, req.head.store_id, req.head.keychip_id, self.config.aimedb.id_secret, self.config.aimedb.id_lifetime_seconds)
@@ -364,9 +290,7 @@ class AimedbServlette():
                 auth_key_full = auth_key.encode() + (b"\0" * auth_key_extra_len)
                 self.logger.debug(f"Generated auth token {auth_key}")
                 resp.auth_key = auth_key_full
-        
-        if user_id and user_id > 0:
-            await self.data.card.update_card_last_login(access_code)
+
         return resp
 
     async def handle_campaign_clear(self, data: bytes, resp_code: int) -> ADBBaseResponse:
@@ -380,12 +304,6 @@ class AimedbServlette():
     async def handle_register(self, data: bytes, resp_code: int) -> bytes:
         req = ADBLookupRequest(data)
         user_id = -1
-        
-        if req.access_code == "00000000000000000000":
-            self.logger.warning(f"All-zero access code from {req.head.keychip_id}")
-            ret = ADBLookupResponse.from_req(req.head, -1)
-            ret.head.status = ADBStatus.BAN_SYS
-            return ret
 
         if self.config.server.allow_user_registration:
             user_id = await self.data.user.create_user()
@@ -409,24 +327,11 @@ class AimedbServlette():
             self.logger.info(
                 f"Registration blocked!: access code {req.access_code}"
             )
-        
-        if user_id > 0:
-            if (req.access_code.startswith("010") or req.access_code.startswith("3")) and req.serial_number != 0x04030201: # Default segatools sn:
-                await self.data.card.set_chip_id_by_access_code(req.access_code, req.serial_number)
-                self.logger.info(f"Attempt to set chip id to {req.serial_number} for access code {req.access_code}")
-            
-            elif req.access_code.startswith("0008"):
-                idm = self.data.card.to_idm(req.access_code)
-                await self.data.card.set_idm_by_access_code(req.access_code, idm)
-                self.logger.info(f"Attempt to set IDm to {idm} for access code {req.access_code}")
 
         resp = ADBLookupResponse.from_req(req.head, user_id)
         if resp.user_id <= 0:
             resp.head.status = ADBStatus.BAN_SYS # Closest we can get to a "You cannot register"
 
-        else:
-            await self.data.card.update_card_last_login(req.access_code)
-
         return resp
 
     # TODO: Save these in some capacity, as deemed relevant

core/allnet.py

@@ -7,7 +7,6 @@ import logging
 import coloredlogs
 import urllib.parse
 import math
-import random
 from typing import Dict, List, Any, Optional, Union, Final
 from logging.handlers import TimedRotatingFileHandler
 from starlette.requests import Request
@@ -18,10 +17,7 @@ from datetime import datetime
 from enum import Enum
 from Crypto.PublicKey import RSA
 from Crypto.Hash import SHA
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import pad
 from Crypto.Signature import PKCS1_v1_5
-import os
 from os import path, environ, mkdir, access, W_OK
 
 from .config import CoreConfig
@@ -98,7 +94,6 @@ class DLI_STATUS(Enum):
             return cls.UNKNOWN
 
 class AllnetServlet:
-    allnet_registry: Dict[str, Any] = {}
     def __init__(self, core_cfg: CoreConfig, cfg_folder: str):
         self.config = core_cfg
         self.config_folder = cfg_folder
@@ -130,35 +125,16 @@ class AllnetServlet:
 
     def startup(self) -> None:
         self.logger.info(f"Ready on port {self.config.allnet.port if self.config.allnet.standalone else self.config.server.port}")
-        if not TitleServlet.title_registry:
-            TitleServlet(self.config, self.config_folder)
 
     async def handle_poweron(self, request: Request):
         request_ip = Utils.get_ip_addr(request)
         pragma_header = request.headers.get('Pragma', "")
-        useragent_header = request.headers.get('User-Agent', "")
-        is_dfi = pragma_header == "DFI"
-        is_lite = useragent_header[5:] == "Windows/Lite"
-        lite_id = useragent_header[:4]
+        is_dfi = pragma_header is not None and pragma_header == "DFI"
         data = await request.body()
-
-        if not self.config.allnet.allnet_lite_keys and is_lite:
-            self.logger.error("!!!LITE KEYS NOT SET!!!")
-            raise AllnetRequestException()
-        elif is_lite:
-            for gameids, key in self.config.allnet.allnet_lite_keys.items():
-                if gameids == lite_id:
-                    litekey = key
-
-        if is_lite and "litekey" not in locals():
-            self.logger.error("!!!UNIQUE LITE KEY NOT FOUND!!!")
-            raise AllnetRequestException()
         
         try:
             if is_dfi:
                 req_urlencode = self.from_dfi(data)
-            elif is_lite:
-                req_urlencode = self.dec_lite(litekey, data[:16], data)
             else:
                 req_urlencode = data
 
@@ -166,30 +142,20 @@ class AllnetServlet:
             if req_dict is None:
                 raise AllnetRequestException()
 
-            if is_lite:
-                req = AllnetPowerOnRequestLite(req_dict[0])
-            else:
-                req = AllnetPowerOnRequest(req_dict[0])
+            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.serial or not req.token and is_lite:
+            if not req.game_id or not req.ver or not req.serial or not req.ip or not req.firm_ver or not req.boot_ver:
                 raise AllnetRequestException(
                     f"Bad auth request params from {request_ip} - {vars(req)}"
                 )
-            elif not is_lite:
-                if not req.game_id or not req.ver or not req.serial or not req.ip or not req.firm_ver or not req.boot_ver:
-                    raise AllnetRequestException( 
-                        f"Bad auth request params from {request_ip} - {vars(req)}"
-                    )
 
         except AllnetRequestException as e:
             if e.message != "":
                 self.logger.error(e)
             return PlainTextResponse()
 
-        if is_lite:
-            resp = AllnetPowerOnResponseLite(req.token)
-        elif req.format_ver == 3:
+        if req.format_ver == 3:
             resp = AllnetPowerOnResponse3(req.token)
         elif req.format_ver == 2:
             resp = AllnetPowerOnResponse2()
@@ -202,24 +168,21 @@ class AllnetServlet:
         if machine is None and not self.config.server.allow_unregistered_serials:
             msg = f"Unrecognised serial {req.serial} attempted allnet auth from {request_ip}."
             await self.data.base.log_event(
-                "allnet", "ALLNET_AUTH_UNKNOWN_SERIAL", logging.WARN, msg, {"serial": req.serial}, None, None, None, request_ip, req.game_id, req.ver
+                "allnet", "ALLNET_AUTH_UNKNOWN_SERIAL", logging.WARN, msg
             )
             self.logger.warning(msg)
 
-            if is_lite:
-                resp.result = ALLNET_STAT.bad_machine.value
-            else:
-                resp.stat = ALLNET_STAT.bad_machine.value
+            resp.stat = ALLNET_STAT.bad_machine.value
             resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
             return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
 
-        if machine is not None and not is_lite:
+        if machine is not None:
             arcade = await self.data.arcade.get_arcade(machine["arcade"])
             if self.config.server.check_arcade_ip:
                 if arcade["ip"] and arcade["ip"] is not None and arcade["ip"] != req.ip:
-                    msg = f"{req.serial} attempted allnet auth from bad IP {req.ip} (expected {arcade['ip']})."
+                    msg = f"Serial {req.serial} attempted allnet auth from bad IP {req.ip} (expected {arcade['ip']})."
                     await self.data.base.log_event(
-                        "allnet", "ALLNET_AUTH_BAD_IP", logging.ERROR, msg, {}, None, arcade['id'], machine['id'], request_ip, req.game_id, req.ver
+                        "allnet", "ALLNET_AUTH_BAD_IP", logging.ERROR, msg
                     )
                     self.logger.warning(msg)
 
@@ -228,9 +191,9 @@ class AllnetServlet:
                     return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
                 
                 elif (not arcade["ip"] or arcade["ip"] is None) and self.config.server.strict_ip_checking:
-                    msg = f"{req.serial} attempted allnet auth from bad IP {req.ip}, but arcade {arcade['id']} has no IP set! (strict checking enabled)."
+                    msg = f"Serial {req.serial} attempted allnet auth from bad IP {req.ip}, but arcade {arcade['id']} has no IP set! (strict checking enabled)."
                     await self.data.base.log_event(
-                        "allnet", "ALLNET_AUTH_NO_SHOP_IP", logging.ERROR, msg, {}, None, arcade['id'], machine['id'], request_ip, req.game_id, req.ver
+                        "allnet", "ALLNET_AUTH_NO_SHOP_IP", logging.ERROR, msg
                     )
                     self.logger.warning(msg)
 
@@ -238,17 +201,7 @@ class AllnetServlet:
                     resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
                     return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
 
-            if machine['game'] and machine['game'] != req.game_id:
-                msg = f"{req.serial} attempted allnet auth with bad game ID {req.game_id} (expected {machine['game']})."
-                await self.data.base.log_event(
-                    "allnet", "ALLNET_AUTH_BAD_GAME", logging.ERROR, msg, {}, None, arcade['id'], machine['id'], request_ip, req.game_id, req.ver
-                )
-                self.logger.warning(msg)
 
-                resp.stat = ALLNET_STAT.bad_game.value
-                resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
-                return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
-            
             country = (
                 arcade["country"] if machine["country"] is None else machine["country"]
             )
@@ -256,7 +209,7 @@ class AllnetServlet:
                 country = AllnetCountryCode.JAPAN.value
 
             resp.country = country
-            resp.place_id = f"{arcade['id']:04X}"
+            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 ""
@@ -280,21 +233,15 @@ class AllnetServlet:
                 arcade["timezone"] if arcade["timezone"] is not None else "+0900" if req.format_ver == 3 else "+09:00"
             )
         
-        else:
-            arcade = None
-
         if req.game_id not in TitleServlet.title_registry:
             if not self.config.server.is_develop:
                 msg = f"Unrecognised game {req.game_id} attempted allnet auth from {request_ip}."
                 await self.data.base.log_event(
-                    "allnet", "ALLNET_AUTH_UNKNOWN_GAME", logging.WARN, msg, {}, None, arcade['id'] if arcade else None, machine['id'] if machine else None, request_ip, req.game_id, req.ver
+                    "allnet", "ALLNET_AUTH_UNKNOWN_GAME", logging.WARN, msg
                 )
                 self.logger.warning(msg)
 
-                if is_lite:
-                    resp.result = ALLNET_STAT.bad_game.value
-                else:
-                    resp.stat = ALLNET_STAT.bad_game.value
+                resp.stat = ALLNET_STAT.bad_game.value
                 resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
                 return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
 
@@ -302,12 +249,8 @@ class AllnetServlet:
                 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}"
                 )
-                if is_lite:
-                    resp.uri1 = f"http://{self.config.server.hostname}:{self.config.server.port}/{req.game_id}/{req.ver.replace('.', '')}/"
-                    resp.uri2 = f"{self.config.server.hostname}:{self.config.server.port}"
-                else:
-                    resp.uri = f"http://{self.config.server.hostname}:{self.config.server.port}/{req.game_id}/{req.ver.replace('.', '')}/"
-                    resp.host = f"{self.config.server.hostname}:{self.config.server.port}"
+                resp.uri = f"http://{self.config.server.hostname}:{self.config.server.port}/{req.game_id}/{req.ver.replace('.', '')}/"
+                resp.host = f"{self.config.server.hostname}:{self.config.server.port}"
                 
                 resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
                 resp_str = urllib.parse.unquote(urllib.parse.urlencode(resp_dict))
@@ -317,76 +260,32 @@ class AllnetServlet:
 
         
         int_ver = req.ver.replace(".", "")
-        try:
-            if is_lite:
-                resp.uri1, resp.uri2 = TitleServlet.title_registry[req.game_id].get_allnet_info(req.game_id, int(int_ver), req.serial)
-            else:
-                resp.uri, resp.host = TitleServlet.title_registry[req.game_id].get_allnet_info(req.game_id, int(int_ver), req.serial)
-        except Exception as e:
-            self.logger.error(f"Error running get_allnet_info for {req.game_id} - {e}")
-            if is_lite:
-                resp.result = ALLNET_STAT.bad_game.value
-            else:
-                resp.stat = ALLNET_STAT.bad_game.value
-            resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
-            return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
+        resp.uri, resp.host = TitleServlet.title_registry[req.game_id].get_allnet_info(req.game_id, int(int_ver), req.serial)
 
-        if machine and arcade:
-            msg = f"{req.serial} authenticated from {request_ip}: {req.game_id} v{req.ver}"
-            await self.data.base.log_event(
-                "allnet", "ALLNET_AUTH_SUCCESS", logging.INFO, msg, {}, None, arcade['id'], machine['id'], request_ip, req.game_id, req.ver
-                )
-        else:
-            msg = f"Allow unregistered serial {req.serial} to authenticate from {request_ip}: {req.game_id} v{req.ver}"
-            await self.data.base.log_event(
-                "allnet", "ALLNET_AUTH_SUCCESS_UNREG", logging.INFO, msg, {"serial": req.serial}, None, None, None, request_ip, req.game_id, req.ver
-                )
-        
+        msg = f"{req.serial} authenticated from {request_ip}: {req.game_id} v{req.ver}"
+        await self.data.base.log_event("allnet", "ALLNET_AUTH_SUCCESS", logging.INFO, msg)
         self.logger.info(msg)
 
         resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
-        resp_str = urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n"
+        resp_str = urllib.parse.unquote(urllib.parse.urlencode(resp_dict))
         self.logger.debug(f"Allnet response: {resp_dict}")        
+        resp_str += "\n"
 
-        if is_dfi:
-            return PlainTextResponse(
-                content=self.to_dfi(resp_str) + b"\r\n",
-                headers={
-                    "Pragma": "DFI",
-                },
-            )
-        elif is_lite:
-            iv = bytes([random.randint(2, 255) for _ in range(16)])
-            return PlainTextResponse(content=self.enc_lite(litekey, iv, resp_str)) 
+        """if is_dfi:
+            request.responseHeaders.addRawHeader('Pragma', 'DFI')
+            return self.to_dfi(resp_str)"""
 
         return PlainTextResponse(resp_str)
 
     async def handle_dlorder(self, request: Request):
         request_ip = Utils.get_ip_addr(request)
         pragma_header = request.headers.get('Pragma', "")
-        useragent_header = request.headers.get('User-Agent', "")
-        is_dfi = pragma_header == "DFI"
-        is_lite = useragent_header[5:] == "Windows/Lite"
-        lite_id = useragent_header[:4]
+        is_dfi = pragma_header is not None and pragma_header == "DFI"
         data = await request.body()
         
-        if not self.config.allnet.allnet_lite_keys and is_lite:
-            self.logger.error("!!!LITE KEYS NOT SET!!!")
-            raise AllnetRequestException()
-        elif is_lite:
-            for gameids, key in self.config.allnet.allnet_lite_keys.items():
-                if gameids == lite_id:
-                    litekey = key
-
-        if is_lite and "litekey" not in locals():
-            self.logger.error("!!!UNIQUE LITE KEY NOT FOUND!!!")
-            raise AllnetRequestException()
-
         try:
             if is_dfi:
                 req_urlencode = self.from_dfi(data)
-            elif is_lite:
-                req_urlencode = self.dec_lite(litekey, data[:16], data)
             else:
                 req_urlencode = data.decode()
 
@@ -394,10 +293,7 @@ class AllnetServlet:
             if req_dict is None:
                 raise AllnetRequestException()
 
-            if is_lite:
-                req = AllnetDownloadOrderRequestLite(req_dict[0])
-            else:
-                req = AllnetDownloadOrderRequest(req_dict[0])
+            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.serial:
@@ -413,39 +309,15 @@ class AllnetServlet:
         self.logger.info(
             f"DownloadOrder from {request_ip} -> {req.game_id} v{req.ver} serial {req.serial}"
         )
-
-        if is_lite:
-            resp = AllnetDownloadOrderResponseLite()
-        else:
-            resp = AllnetDownloadOrderResponse(serial=req.serial)
+        resp = AllnetDownloadOrderResponse(serial=req.serial)
 
         if (
             not self.config.allnet.allow_online_updates
             or not self.config.allnet.update_cfg_folder
         ):
-            resp = urllib.parse.unquote(urllib.parse.urlencode(vars(resp))) + "\n"
-            if is_dfi:
-                return PlainTextResponse(
-                    self.to_dfi(resp) + b"\r\n", headers={ "Pragma": "DFI" }
-                )
-            elif is_lite:
-                iv = bytes([random.randint(2, 255) for _ in range(16)])
-                return PlainTextResponse(content=self.enc_lite(litekey, iv, resp)) 
-            return PlainTextResponse(resp)
-
-        else:
-            machine = await self.data.arcade.get_machine(req.serial)
-            if not machine or not machine['ota_enable'] or not machine['is_cab']:
-                resp = urllib.parse.unquote(urllib.parse.urlencode(vars(resp))) + "\n"
-                if is_dfi:
-                    return PlainTextResponse(
-                        self.to_dfi(resp) + b"\r\n", headers={ "Pragma": "DFI" }
-                    )
-                elif is_lite:
-                    iv = bytes([random.randint(2, 255) for _ in range(16)])
-                    return PlainTextResponse(content=self.enc_lite(litekey, iv, resp)) 
-                return PlainTextResponse(resp)
+            return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(vars(resp))) + "\n")
 
+        else:  # TODO: Keychip check
             if path.exists(
                 f"{self.config.allnet.update_cfg_folder}/{req.game_id}-{req.ver.replace('.', '')}-app.ini"
             ):
@@ -456,41 +328,25 @@ class AllnetServlet:
             ):
                 resp.uri += f"|http://{self.config.server.hostname}:{self.config.server.port}/dl/ini/{req.game_id}-{req.ver.replace('.', '')}-opt.ini"
 
-            if resp.uri:
-                self.logger.info(f"Sending download uri {resp.uri}")
-                await self.data.base.log_event(
-                    "allnet", "DLORDER_REQ_SUCCESS", logging.INFO, f"Send download URI to {req.serial} for {req.game_id} v{req.ver} from {Utils.get_ip_addr(request)}", {"uri": resp.uri}, None,
-                    machine['arcade'], machine['id'], request_ip, req.game_id, req.ver
-                )
-            # Maybe add a log event for checkin but no url sent?
+            self.logger.debug(f"Sending download uri {resp.uri}")
+            await self.data.base.log_event("allnet", "DLORDER_REQ_SUCCESS", logging.INFO, f"{Utils.get_ip_addr(request)} requested DL Order for {req.serial} {req.game_id} v{req.ver}")
 
             res_str = urllib.parse.unquote(urllib.parse.urlencode(vars(resp))) + "\n"
-            
-            if is_dfi:
-                return PlainTextResponse(
-                    content=self.to_dfi(res_str) + b"\r\n",
-                    headers={
-                        "Pragma": "DFI",
-                    },
-                )
-            elif is_lite:
-                iv = bytes([random.randint(2, 255) for _ in range(16)])
-                return PlainTextResponse(content=self.enc_lite(litekey, iv, res_str)) 
+            """if is_dfi:
+                request.responseHeaders.addRawHeader('Pragma', 'DFI')
+                return self.to_dfi(res_str)"""
 
             return PlainTextResponse(res_str)
 
     async def handle_dlorder_ini(self, request: Request) -> bytes:
         req_file = request.path_params.get("file", "").replace("%0A", "").replace("\n", "")
-        request_ip = Utils.get_ip_addr(request)
 
         if not req_file:
             return PlainTextResponse(status_code=404)
 
         if path.exists(f"{self.config.allnet.update_cfg_folder}/{req_file}"):
-            self.logger.info(f"Request for DL INI file {req_file} from {request_ip} successful")
-            await self.data.base.log_event(
-                "allnet", "DLORDER_INI_SENT", logging.INFO, f"{request_ip} successfully recieved {req_file}", {"file": req_file}, ip=request_ip
-            )
+            self.logger.info(f"Request for DL INI file {req_file} from {Utils.get_ip_addr(request)} successful")
+            await self.data.base.log_event("allnet", "DLORDER_INI_SENT", logging.INFO, f"{Utils.get_ip_addr(request)} successfully recieved {req_file}")
             
             return PlainTextResponse(open(
                 f"{self.config.allnet.update_cfg_folder}/{req_file}", "r", encoding="utf-8"
@@ -528,13 +384,7 @@ class AllnetServlet:
         msg = f"{rep.serial} @ {client_ip} reported {rep.rep_type.name} download state {rep.rf_state.name} for {rep.gd} v{rep.dav}:"\
               f" {rep.tdsc}/{rep.tsc} segments downloaded for working files {rep.wfl} with {rep.dfl if rep.dfl else 'none'} complete."
         
-        machine = await self.data.arcade.get_machine(rep.serial)
-        if machine:
-            await self.data.base.log_event("allnet", "DL_REPORT", logging.INFO, msg, dl_data, None, machine['arcade'], machine['id'], client_ip, rep.gd, rep.dav)
-        
-        else:
-            msg = "Unknown serial " + msg
-            await self.data.base.log_event("allnet", "DL_REPORT_UNREG", logging.INFO, msg, dl_data, None, None, None, client_ip, rep.gd, rep.dav)
+        await self.data.base.log_event("allnet", "DL_REPORT", logging.INFO, msg, dl_data)
         self.logger.info(msg)
 
         return PlainTextResponse("OK")
@@ -554,24 +404,14 @@ class AllnetServlet:
         if serial is None or num_files_dld is None or num_files_to_dl is None or dl_state is None:
             return PlainTextResponse("NG")
 
-        msg = f"LoaderStateRecorder Request from {ip} {serial}: {num_files_dld}/{num_files_to_dl} Files download (State: {dl_state})"
-        machine = await self.data.arcade.get_machine(serial)
-        if machine:
-            await self.data.base.log_event("allnet", "LSR_REPORT", logging.INFO, msg, req_dict, None, machine['arcade'], machine['id'], ip)
-        
-        else:
-            msg = "Unregistered " + msg
-            await self.data.base.log_event("allnet", "LSR_REPORT_UNREG", logging.INFO, msg, req_dict, None, None, None, ip)
-        
-        self.logger.info(msg)
+        self.logger.info(f"LoaderStateRecorder Request from {ip} {serial}: {num_files_dld}/{num_files_to_dl} Files download (State: {dl_state})")
         return PlainTextResponse("OK")
     
     async def handle_alive(self, request: Request) -> bytes:
         return PlainTextResponse("OK")
 
     async def handle_naomitest(self, request: Request) -> bytes:
-        # This could be spam-able, removing
-        #self.logger.info(f"Ping from {Utils.get_ip_addr(request)}")
+        self.logger.info(f"Ping from {Utils.get_ip_addr(request)}")
         return PlainTextResponse("naomi ok")
 
     def allnet_req_to_dict(self, data: str) -> Optional[List[Dict[str, Any]]]:
@@ -600,17 +440,6 @@ class AllnetServlet:
         zipped = zlib.compress(unzipped)
         return base64.b64encode(zipped)
 
-    def dec_lite(self, key, iv, data):
-        cipher = AES.new(bytes(key), AES.MODE_CBC, iv)
-        decrypted = cipher.decrypt(data)
-        return decrypted[16:].decode("utf-8")
-
-    def enc_lite(self, key, iv, data):
-        unencrypted = pad(bytes([0] * 16) + data.encode('utf-8'), 16)
-        cipher = AES.new(bytes(key), AES.MODE_CBC, iv)
-        encrypted = cipher.encrypt(unencrypted)
-        return encrypted
-
 class BillingServlet:
     def __init__(self, core_cfg: CoreConfig, cfg_folder: str) -> None:
         self.config = core_cfg
@@ -680,138 +509,61 @@ class BillingServlet:
         rsa = RSA.import_key(open(self.config.billing.signing_key, "rb").read())
         signer = PKCS1_v1_5.new(rsa)
         digest = SHA.new()
+        traces: List[TraceData] = []
         try:
             req = BillingInfo(req_dict[0])
         except KeyError as e:
             self.logger.error(f"Billing request failed to parse: {e}")
             return PlainTextResponse("result=5&linelimit=&message=field is missing or formatting is incorrect\r\n")
 
+        for x in range(1, len(req_dict)):
+            if not req_dict[x]:
+                continue
+            
+            try:
+                tmp = TraceData(req_dict[x])
+                if tmp.trace_type == TraceDataType.CHARGE:
+                    tmp = TraceDataCharge(req_dict[x])
+                elif tmp.trace_type == TraceDataType.EVENT:
+                    tmp = TraceDataEvent(req_dict[x])
+                elif tmp.trace_type == TraceDataType.CREDIT:
+                    tmp = TraceDataCredit(req_dict[x])
+                
+                traces.append(tmp)
+            
+            except KeyError as e:
+                self.logger.warn(f"Tracelog failed to parse: {e}")
+
         kc_serial_bytes = req.keychipid.encode()
+        
 
         machine = await self.data.arcade.get_machine(req.keychipid)
         if machine is None and not self.config.server.allow_unregistered_serials:
             msg = f"Unrecognised serial {req.keychipid} attempted billing checkin from {request_ip} for {req.gameid} v{req.gamever}."
             await self.data.base.log_event(
-                "allnet", "BILLING_CHECKIN_NG_SERIAL", logging.WARN, msg, ip=request_ip, game=req.gameid, version=str(req.gamever)
+                "allnet", "BILLING_CHECKIN_NG_SERIAL", logging.WARN, msg
             )
             self.logger.warning(msg)
 
             return PlainTextResponse(f"result=1&requestno={req.requestno}&message=Keychip Serial bad\r\n")
-        
-        log_details = {
-            "playcount": req.playcnt,
-            "billing_type": req.billingtype.name,
-            "nearfull": req.nearfull,
-            "playlimit": req.playlimit,
-            "messages": []
-        }
-        playhist = "000000/0:000000/0:000000/0"
-        
-        if machine is not None:
-            if self.config.allnet.save_billing:
-                lastcredit = await self.data.arcade.billing_get_last_playcount(machine['id'], req.gameid)
-                if lastcredit is not None:
-                    last_playct = lastcredit['playct']
-                else:
-                    last_playct = 0
-                
-                # Technically if a cab resets it's playcount and then does more plays then the previous
-                # playcount before a billing checkin occours, we will lose plays equal to the current playcount.
-                if req.playcnt < last_playct: await self.data.arcade.billing_add_playcount(machine['id'], req.gameid, req.playcnt)
-                elif req.playcnt == last_playct: pass # No plays since last checkin, skip update
-                else: await self.data.arcade.billing_add_playcount(machine['id'], req.gameid, req.playcnt - last_playct)
-
-                plays = await self.data.arcade.billing_get_playcount_3mo(machine['id'], req.gameid)
-                if plays is not None and len(plays) > 0:
-                    playhist = ""
-                    
-                    for x in range(len(plays) - 1, -1, -1): playhist += f"{plays[x]['year']:04d}{plays[x]['month']:02d}/{plays[x]['playct']}:"
-                    playhist = playhist[:-1]
-            
-            for x in range(1, len(req_dict)):
-                if not req_dict[x]:
-                    continue
-                
-                try:
-                    tmp = TraceData(req_dict[x])
-                    if tmp.trace_type == TraceDataType.CHARGE:
-                        tmp = TraceDataCharge(req_dict[x])
-                        if self.config.allnet.save_billing:
-                            await self.data.arcade.billing_add_charge(
-                                machine['id'],
-                                tmp.game_id,
-                                float(tmp.game_version),
-                                tmp.play_count,
-                                tmp.play_limit,
-                                tmp.product_code,
-                                tmp.product_count,
-                                tmp.func_type,
-                                tmp.player_number
-                            )
-
-                        self.logger.info(
-                            f"Charge Trace from {req.keychipid}: {tmp.game_id} v{tmp.game_version} - player {tmp.player_number} got {tmp.product_count} of {tmp.product_code} func {tmp.func_type}"
-                        )
-
-                    elif tmp.trace_type == TraceDataType.EVENT:
-                        tmp = TraceDataEvent(req_dict[x])
-                        log_details['messages'].append(tmp.message)
-                        self.logger.info(f"Event Trace from {req.keychipid}: {tmp.message}")
-
-                    elif tmp.trace_type == TraceDataType.CREDIT:
-                        tmp = TraceDataCredit(req_dict[x])
-                        if self.config.allnet.save_billing:
-                            await self.data.arcade.billing_set_credit(
-                                machine['id'],
-                                req.gameid,
-                                tmp.chute_type.value,
-                                tmp.service_type.value,
-                                tmp.operation_type.value,
-                                tmp.coin_rate0,
-                                tmp.coin_rate1,
-                                tmp.bonus_addition,
-                                tmp.credit_rate,
-                                tmp.credit0,
-                                tmp.credit1,
-                                tmp.credit2,
-                                tmp.credit3,
-                                tmp.credit4,
-                                tmp.credit5,
-                                tmp.credit6,
-                                tmp.credit7
-                            )
-
-                        self.logger.info(
-                            f"Credit Trace from {req.keychipid}: {tmp.operation_type} mode, {tmp.credit_rate} coins per credit, breakdown: {tmp.credit0} | {tmp.credit1} | {tmp.credit2} | {tmp.credit3} | {tmp.credit4} | {tmp.credit5} | {tmp.credit6} | {tmp.credit7} | "
-                        )
-                
-                except KeyError as e:
-                    self.logger.warning(f"Tracelog failed to parse: {e}")
-
-            await self.data.base.log_event("billing", "BILLING_CHECKIN_OK", logging.INFO, "", log_details, None, machine['arcade'], machine['id'], request_ip, req.gameid, str(req.gamever))
-            
-            self.logger.info(
-                f"Billing checkin from {request_ip}: game {req.gameid} ver {req.gamever} keychip {req.keychipid} playcount "
-                f"{req.playcnt} billing_type {req.billingtype.name} nearfull {req.nearfull} playlimit {req.playlimit}"
-            )
-
-        else:
-            log_details['serial'] = req.keychipid
-            await self.data.base.log_event("billing", "BILLING_CHECKIN_OK_UNREG", logging.INFO, "", log_details, None, None, None, request_ip, req.gameid, str(req.gamever))
-        
-            self.logger.info(
-                f"Unregistered Billing checkin from {request_ip}: game {req.gameid} ver {req.gamever} keychip {req.keychipid} playcount "
-                f"{req.playcnt} billing_type {req.billingtype.name} nearfull {req.nearfull} playlimit {req.playlimit}"
-            )
 
+        msg = (
+            f"Billing checkin from {request_ip}: game {req.gameid} ver {req.gamever} keychip {req.keychipid} playcount "
+            f"{req.playcnt} billing_type {req.billingtype.name} nearfull {req.nearfull} playlimit {req.playlimit}"
+        )
+        self.logger.info(msg)
+        await self.data.base.log_event("billing", "BILLING_CHECKIN_OK", logging.INFO, msg)
         if req.traceleft > 0:
-            self.logger.warning(f"{req.traceleft} unsent tracelogs")
+            self.logger.warn(f"{req.traceleft} unsent tracelogs")
+        kc_playlimit = req.playlimit
+        kc_nearfull = req.nearfull
 
-        playlimit = req.playlimit
-        while req.playcnt > playlimit:
-            playlimit += 1024
+        while req.playcnt > req.playlimit:
+            kc_playlimit += 1024
+            kc_nearfull += 1024
 
-        nearfull = req.nearfull + (req.billingtype.value * 0x00010000)
+        playlimit = kc_playlimit
+        nearfull = kc_nearfull + (req.billingtype.value * 0x00010000)
 
         digest.update(playlimit.to_bytes(4, "little") + kc_serial_bytes)
         playlimit_sig = signer.sign(digest).hex()
@@ -820,12 +572,14 @@ class BillingServlet:
         digest.update(nearfull.to_bytes(4, "little") + kc_serial_bytes)
         nearfull_sig = signer.sign(digest).hex()
 
-        resp = BillingResponse(playlimit, playlimit_sig, nearfull, nearfull_sig, req.requestno, req.protocolver, playhist)
+        # TODO: playhistory
+
+        resp = BillingResponse(playlimit, playlimit_sig, nearfull, nearfull_sig, req.requestno, req.protocolver)
 
         resp_str = urllib.parse.unquote(urllib.parse.urlencode(vars(resp))) + "\r\n"
 
         self.logger.debug(f"response {vars(resp)}")
-        if req.traceleft > 0: # TODO: should probably move this up so we don't do a ton of work that doesn't get used
+        if req.traceleft > 0:
             self.logger.info(f"Requesting 20 more of {req.traceleft} unsent tracelogs")
             return PlainTextResponse("result=6&waittime=0&linelimit=20\r\n")
         
@@ -867,15 +621,6 @@ class AllnetPowerOnResponse:
         self.minute = datetime.now().minute
         self.second = datetime.now().second
 
-class AllnetPowerOnRequestLite:
-    def __init__(self, req: Dict) -> None:
-        if req is None:
-            raise AllnetRequestException("Request processing failed")
-        self.game_id: str = req.get("title_id", None)
-        self.ver: str = req.get("title_ver", None)
-        self.serial: str = req.get("client_id", None)
-        self.token: str = req.get("token", None)
-
 class AllnetPowerOnResponse3(AllnetPowerOnResponse):
     def __init__(self, token) -> None:
         super().__init__()
@@ -907,30 +652,6 @@ class AllnetPowerOnResponse2(AllnetPowerOnResponse):
         self.timezone = "+09:00"
         self.res_class = "PowerOnResponseV2"
 
-class AllnetPowerOnResponseLite:
-    def __init__(self, token) -> None:
-        # Custom Allnet Lite response
-        self.result = 1
-        self.place_id = "0123"
-        self.uri1 = ""
-        self.uri2 = ""
-        self.name = "ARTEMiS"
-        self.nickname = "ARTEMiS"
-        self.setting = "1"
-        self.region0 = "1"
-        self.region_name0 = "W"
-        self.region_name1 = ""
-        self.region_name2 = ""
-        self.region_name3 = ""
-        self.country = "CHN"
-        self.location_type = "1"
-        self.utc_time = datetime.now(tz=pytz.timezone("UTC")).strftime(
-            "%Y-%m-%dT%H:%M:%SZ"
-        )
-        self.client_timezone = "+0800"
-        self.res_ver = "3"
-        self.token = token
-
 class AllnetDownloadOrderRequest:
     def __init__(self, req: Dict) -> None:
         self.game_id = req.get("game_id", "")
@@ -938,23 +659,12 @@ class AllnetDownloadOrderRequest:
         self.serial = req.get("serial", "")
         self.encode = req.get("encode", "")
 
-class AllnetDownloadOrderRequestLite:
-    def __init__(self, req: Dict) -> None:
-        self.game_id = req.get("title_id", "")
-        self.ver = req.get("title_ver", "")
-        self.serial = req.get("client_id", "")
-
 class AllnetDownloadOrderResponse:
-    def __init__(self, stat: int = 1, serial: str = "", uri: str = "null") -> None:
+    def __init__(self, stat: int = 1, serial: str = "", uri: str = "") -> None:
         self.stat = stat
         self.serial = serial
         self.uri = uri
 
-class AllnetDownloadOrderResponseLite:
-    def __init__(self, result: int = 1, uri: str = "null") -> None:
-        self.result = result
-        self.uri = uri
-
 class TraceDataType(Enum):
     CHARGE = 0
     EVENT = 1
@@ -964,27 +674,14 @@ class BillingType(Enum):
     A = 1
     B = 0
 
-class TraceDataCreditChuteType(Enum):
-    COMMON = 0
-    INDIVIDUAL = 1
-
-class TraceDataCreditOperationType(Enum):
-    COIN = 0
-    FREEPLAY = 1
-
 class float5:
-    def __init__(self, n: str = "0"):
+    def __init__(self, n: str = "0") -> None:
         nf = float(n)
         if nf > 999.9 or nf < 0:
             raise ValueError('float5 must be between 0.000 and 999.9 inclusive')
-        self.val = nf
+        
+        return nf
     
-    def __float__(self) -> float:
-        return self.val
-
-    def __str__(self) -> str:
-        return f"%.{2 - int(math.log10(self.val))+1}f" % self.val
-
     @classmethod
     def to_str(cls, f: float):
         return f"%.{2 - int(math.log10(f))+1}f" % f
@@ -995,13 +692,13 @@ class BillingInfo:
             self.keychipid = str(data.get("keychipid", None))
             self.functype = int(data.get("functype", None))
             self.gameid = str(data.get("gameid", None))
-            self.gamever = float5(data.get("gamever", None))
+            self.gamever = float(data.get("gamever", None))
             self.boardid = str(data.get("boardid", None))
             self.tenpoip = str(data.get("tenpoip", None))
-            self.libalibver = float5(data.get("libalibver", None))
-            self.datamax = int(data.get("datamax", None))
+            self.libalibver = float(data.get("libalibver", None))
+            self.data.max = int(data.get("datamax", None))
             self.billingtype = BillingType(int(data.get("billingtype", None)))
-            self.protocolver = float5(data.get("protocolver", None))
+            self.protocolver = float(data.get("protocolver", None))
             self.operatingfix = bool(data.get("operatingfix", None))
             self.traceleft = int(data.get("traceleft", None))
             self.requestno = int(data.get("requestno", None))
@@ -1034,7 +731,7 @@ class TraceData:
                 self.date = datetime.strptime(data.get("dt", None), BILLING_DT_FORMAT)
             
             self.keychip = str(data.get("kn", None))
-            self.lib_ver = float5(data.get("alib", 0))
+            self.lib_ver = float(data.get("alib", 0))
         except Exception as e:
             raise KeyError(e)
 
@@ -1043,7 +740,7 @@ class TraceDataCharge(TraceData):
         super().__init__(data)
         try:
             self.game_id = str(data.get("gi", None)) # these seem optional...?
-            self.game_version = float5(data.get("gv", 0))
+            self.game_version = float(data.get("gv", 0))
             self.board_serial = str(data.get("bn", None))
             self.shop_ip = str(data.get("ti", None))
             self.play_count = int(data.get("pc", None))
@@ -1067,9 +764,9 @@ class TraceDataCredit(TraceData):
     def __init__(self, data: Dict) -> None:
         super().__init__(data)
         try:
-            self.chute_type = TraceDataCreditChuteType(int(data.get("cct", None)))
-            self.service_type = TraceDataCreditChuteType(int(data.get("cst", None)))
-            self.operation_type = TraceDataCreditOperationType(int(data.get("cop", None)))
+            self.chute_type = int(data.get("cct", None))
+            self.service_type = int(data.get("cst", None))
+            self.operation_type = int(data.get("cop", None))
             self.coin_rate0 = int(data.get("cr0", None))
             self.coin_rate1 = int(data.get("cr1", None))
             self.bonus_addition = int(data.get("cba", None))
@@ -1093,7 +790,7 @@ class BillingResponse:
         nearfull: str = "",
         nearfull_sig: str = "",
         request_num: int = 1,
-        protocol_ver: float5 = float5("1.000"),
+        protocol_ver: float = 1.000,
         playhistory: str = "000000/0:000000/0:000000/0",
     ) -> None:
         self.result = 0
@@ -1107,7 +804,7 @@ class BillingResponse:
         self.nearfull = nearfull
         self.nearfullsig = nearfull_sig
         self.linelimit = 100
-        self.protocolver = str(protocol_ver)
+        self.protocolver = float5.to_str(protocol_ver)
         # playhistory -> YYYYMM/C:...
         # YYYY -> 4 digit year, MM -> 2 digit month, C -> Playcount during that period
 
@@ -1179,7 +876,7 @@ class DLReport:
         
         return True
 
-cfg_dir = environ.get("ARTEMIS_CFG_DIR", "config")
+cfg_dir = environ.get("DIANA_CFG_DIR", "config")
 cfg: CoreConfig = CoreConfig()
 if path.exists(f"{cfg_dir}/core.yaml"):
     cfg.update(yaml.safe_load(open(f"{cfg_dir}/core.yaml")))
@@ -1206,9 +903,7 @@ app_billing = Starlette(
 allnet = AllnetServlet(cfg, cfg_dir)
 route_lst = [
     Route("/sys/servlet/PowerOn", allnet.handle_poweron, methods=["GET", "POST"]),
-    Route("/net/initialize", allnet.handle_poweron, methods=["GET", "POST"]),
     Route("/sys/servlet/DownloadOrder", allnet.handle_dlorder, methods=["GET", "POST"]),
-    Route("/net/delivery/instruction", allnet.handle_dlorder, methods=["GET", "POST"]),
     Route("/sys/servlet/LoaderStateRecorder", allnet.handle_loaderstaterecorder, methods=["GET", "POST"]),
     Route("/sys/servlet/Alive", allnet.handle_alive, methods=["GET", "POST"]),
     Route("/naomitest.html", allnet.handle_naomitest),

core/app.py

@@ -9,9 +9,7 @@ from starlette.responses import PlainTextResponse
 from os import environ, path, mkdir, W_OK, access
 from typing import List
 
-from core import CoreConfig, TitleServlet, MuchaServlet
-from core.allnet import AllnetServlet, BillingServlet
-from core.chimedb import ChimeServlet
+from core import CoreConfig, TitleServlet, MuchaServlet, AllnetServlet, BillingServlet, AimedbServlette
 from core.frontend import FrontendServlet
 
 async def dummy_rt(request: Request):
@@ -76,9 +74,7 @@ if not cfg.allnet.standalone:
     allnet = AllnetServlet(cfg, cfg_dir)
     route_lst += [
         Route("/sys/servlet/PowerOn", allnet.handle_poweron, methods=["GET", "POST"]),
-        Route("/net/initialize", allnet.handle_poweron, methods=["GET", "POST"]),
         Route("/sys/servlet/DownloadOrder", allnet.handle_dlorder, methods=["GET", "POST"]),
-        Route("/net/delivery/instruction", allnet.handle_dlorder, methods=["GET", "POST"]),
         Route("/sys/servlet/LoaderStateRecorder", allnet.handle_loaderstaterecorder, methods=["GET", "POST"]),
         Route("/sys/servlet/Alive", allnet.handle_alive, methods=["GET", "POST"]),
         Route("/naomitest.html", allnet.handle_naomitest),
@@ -90,14 +86,6 @@ if not cfg.allnet.standalone:
             Route("/dl/ini/{file:str}", allnet.handle_dlorder_ini),
         ]
 
-if cfg.chimedb.enable:
-    chimedb = ChimeServlet(cfg, cfg_dir)
-    route_lst += [
-        Route("/wc_aime/api/alive_check", chimedb.handle_qr_alive, methods=["POST"]),
-        Route("/qrcode/api/alive_check", chimedb.handle_qr_alive, methods=["POST"]),
-        Route("/wc_aime/api/get_data", chimedb.handle_qr_lookup, methods=["POST"])
-    ]
-
 for code, game in title.title_registry.items():
     route_lst += game.get_routes()
 

core/chimedb.py

@@ -1,139 +0,0 @@
-import hashlib
-import json
-import logging
-from enum import Enum
-from logging.handlers import TimedRotatingFileHandler
-
-import coloredlogs
-from starlette.responses import PlainTextResponse
-from starlette.requests import Request
-
-from core.config import CoreConfig
-from core.data import Data
-
-class ChimeDBStatus(Enum):
-    NONE = 0
-    READER_SETUP_FAIL = 1
-    READER_ACCESS_FAIL = 2
-    READER_INCOMPATIBLE = 3
-    DB_RESOLVE_FAIL = 4
-    DB_ACCESS_TIMEOUT = 5
-    DB_ACCESS_FAIL = 6
-    AIME_ID_INVALID = 7
-    NO_BOARD_INFO = 8
-    LOCK_BAN_SYSTEM_USER = 9
-    LOCK_BAN_SYSTEM = 10
-    LOCK_BAN_USER = 11
-    LOCK_BAN = 12
-    LOCK_SYSTEM_USER = 13
-    LOCK_SYSTEM = 14
-    LOCK_USER = 15
-
-class ChimeServlet:
-    def __init__(self, core_cfg: CoreConfig, cfg_folder: str) -> None:
-        self.config = core_cfg
-        self.config_folder = cfg_folder
-
-        self.data = Data(core_cfg)
-
-        self.logger = logging.getLogger("chimedb")
-        if not hasattr(self.logger, "initted"):
-            log_fmt_str = "[%(asctime)s] Chimedb | %(levelname)s | %(message)s"
-            log_fmt = logging.Formatter(log_fmt_str)
-
-            fileHandler = TimedRotatingFileHandler(
-                "{0}/{1}.log".format(self.config.server.log_dir, "chimedb"),
-                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=core_cfg.aimedb.loglevel, logger=self.logger, fmt=log_fmt_str
-            )
-            self.logger.initted = True
-
-        if not core_cfg.chimedb.key:
-            self.logger.error("!!!KEY NOT SET!!!")
-            exit(1)
-
-        self.logger.info("Serving")
-
-    async def handle_qr_alive(self, request: Request):
-        return PlainTextResponse("alive")
-
-    async def handle_qr_lookup(self, request: Request) -> bytes:
-        req = json.loads(await request.body())
-        access_code = req["qrCode"][-20:]
-        timestamp = req["timestamp"]
-
-        try:
-            userId = await self._lookup(access_code)
-            data = json.dumps({
-                "userID": userId,
-                "errorID": 0,
-                "timestamp": timestamp,
-                "key": self._hash_key(userId, timestamp)
-            })
-        except Exception as e:
-
-            self.logger.error(e.with_traceback(None))
-
-            data = json.dumps({
-                "userID": -1,
-                "errorID": ChimeDBStatus.DB_ACCESS_FAIL,
-                "timestamp": timestamp,
-                "key": self._hash_key(-1, timestamp)
-            })
-
-        return PlainTextResponse(data)
-
-    def _hash_key(self, chip_id, timestamp):
-        input_string = f"{chip_id}{timestamp}{self.config.chimedb.key}"
-        hash_object = hashlib.sha256(input_string.encode('utf-8'))
-        hex_dig = hash_object.hexdigest()
-
-        formatted_hex = format(int(hex_dig, 16), '064x').upper()
-
-        return formatted_hex
-
-    async def _lookup(self, access_code):
-        user_id = await self.data.card.get_user_id_from_card(access_code)
-
-        self.logger.info(f"access_code {access_code} -> user_id {user_id}")
-
-        if not user_id or user_id <= 0:
-            user_id = await self._register(access_code)
-
-        return user_id
-
-    async def _register(self, access_code):
-        user_id = -1
-
-        if self.config.server.allow_user_registration:
-            user_id = await self.data.user.create_user()
-
-            if user_id is None:
-                self.logger.error("Failed to register user!")
-                user_id = -1
-            else:
-                card_id = await self.data.card.create_card(user_id, access_code)
-
-                if card_id is None:
-                    self.logger.error("Failed to register card!")
-                    user_id = -1
-
-            self.logger.info(
-                f"Register access code {access_code} -> user_id {user_id}"
-            )
-        else:
-            self.logger.info(f"Registration blocked!: access code {access_code}")
-
-        return user_id

core/config.py

@@ -1,9 +1,5 @@
-import logging
-import os
-import ssl
-from typing import Any, Union, Dict
-
-from typing_extensions import Optional
+import logging, os
+from typing import Any
 
 class ServerConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -85,7 +81,7 @@ class ServerConfig:
         is_using_proxy is True and this value is non-zero
         """
         return CoreConfig.get_config_field(
-            self.__config, "core", "server", "proxy_port", default=0
+            self.__config, "core", "title", "proxy_port", default=0
         )
 
     @property
@@ -95,7 +91,7 @@ class ServerConfig:
         instead of 'port' if is_using_proxy is True and this value is non-zero
         """
         return CoreConfig.get_config_field(
-            self.__config, "core", "server", "proxy_port_ssl", default=0
+            self.__config, "core", "title", "proxy_port_ssl", default=0
         )
 
     @property
@@ -177,61 +173,7 @@ class DatabaseConfig:
     @property
     def protocol(self) -> str:
         return CoreConfig.get_config_field(
-            self.__config, "core", "database", "protocol", default="mysql"
-        )
-
-    @property
-    def ssl_enabled(self) -> bool:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_enabled", default=False
-        )
-        
-    @property
-    def ssl_cafile(self) -> Optional[str]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_cafile", default=None
-        )
-
-    @property
-    def ssl_capath(self) -> Optional[str]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_capath", default=None
-        )
-
-    @property
-    def ssl_cert(self) -> Optional[str]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_cert", default=None
-        )
-    
-    @property
-    def ssl_key(self) -> Optional[str]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_key", default=None
-        )
-    
-    @property
-    def ssl_key_password(self) -> Optional[str]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_key_password", default=None
-        )
-
-    @property
-    def ssl_verify_identity(self) -> bool:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_verify_identity", default=True
-        )
-    
-    @property
-    def ssl_verify_cert(self) -> Optional[Union[str, bool]]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_verify_cert", default=None
-        )
-
-    @property
-    def ssl_ciphers(self) -> Optional[str]:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "database", "ssl_ciphers", default=None
+            self.__config, "core", "database", "type", default="mysql"
         )
 
     @property
@@ -260,53 +202,6 @@ class DatabaseConfig:
             self.__config, "core", "database", "memcached_host", default="localhost"
         )
 
-    def create_ssl_context_if_enabled(self):
-        if not self.ssl_enabled:
-            return
-
-        no_ca = (
-            self.ssl_cafile is None
-            and self.ssl_capath is None
-        )
-
-        ctx = ssl.create_default_context(
-            cafile=self.ssl_cafile,
-            capath=self.ssl_capath,
-        )
-        ctx.check_hostname = not no_ca and self.ssl_verify_identity
-
-        if self.ssl_verify_cert is None:
-            ctx.verify_mode = ssl.CERT_NONE if no_ca else ssl.CERT_REQUIRED
-        elif isinstance(self.ssl_verify_cert, bool):
-            ctx.verify_mode = (
-                ssl.CERT_REQUIRED
-                if self.ssl_verify_cert
-                else ssl.CERT_NONE
-            )
-        elif isinstance(self.ssl_verify_cert, str):
-            value = self.ssl_verify_cert.lower()
-
-            if value in ("none", "0", "false", "no"):
-                ctx.verify_mode = ssl.CERT_NONE
-            elif value == "optional":
-                ctx.verify_mode = ssl.CERT_OPTIONAL
-            elif value in ("required", "1", "true", "yes"):
-                ctx.verify_mode = ssl.CERT_REQUIRED
-            else:
-                ctx.verify_mode = ssl.CERT_NONE if no_ca else ssl.CERT_REQUIRED
-        
-        if self.ssl_cert:
-            ctx.load_cert_chain(
-                self.ssl_cert,
-                self.ssl_key,
-                self.ssl_key_password,
-            )
-        
-        if self.ssl_ciphers:
-            ctx.set_ciphers(self.ssl_ciphers)
-        
-        return ctx
-
 class FrontendConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
         self.__config = parent_config
@@ -362,7 +257,7 @@ class AllnetConfig:
         )
 
     @property
-    def allow_online_updates(self) -> bool:
+    def allow_online_updates(self) -> int:
         return CoreConfig.get_config_field(
             self.__config, "core", "allnet", "allow_online_updates", default=False
         )
@@ -373,17 +268,6 @@ class AllnetConfig:
             self.__config, "core", "allnet", "update_cfg_folder", default=""
         )
 
-    @property
-    def save_billing(self) -> bool:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "allnet", "save_billing", default=False
-        )
-    @property
-    def allnet_lite_keys(self) -> Dict:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "allnet", "allnet_lite_keys", default={}
-        )
-
 class BillingConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
         self.__config = parent_config
@@ -436,12 +320,6 @@ class AimedbConfig:
             self.__config, "core", "aimedb", "enable", default=True
         )
 
-    @property
-    def listen_address(self) -> bool:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "aimedb", "listen_address", default=""
-        )
-
     @property
     def loglevel(self) -> int:
         return CoreConfig.str_to_loglevel(
@@ -474,28 +352,6 @@ class AimedbConfig:
             self.__config, "core", "aimedb", "id_lifetime_seconds", default=86400
         )
 
-class ChimedbConfig:
-    def __init__(self, parent_config: "CoreConfig") -> None:
-        self.__config = parent_config
-
-    @property
-    def enable(self) -> bool:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "chimedb", "enable", default=True
-        )
-    @property
-    def loglevel(self) -> int:
-        return CoreConfig.str_to_loglevel(
-            CoreConfig.get_config_field(
-                self.__config, "core", "chimedb", "loglevel", default="info"
-            )
-        )
-    @property
-    def key(self) -> str:
-        return CoreConfig.get_config_field(
-            self.__config, "core", "chimedb", "key", default=""
-        )
-
 class MuchaConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
         self.__config = parent_config
@@ -517,7 +373,6 @@ class CoreConfig(dict):
         self.allnet = AllnetConfig(self)
         self.billing = BillingConfig(self)
         self.aimedb = AimedbConfig(self)
-        self.chimedb = ChimedbConfig(self)
         self.mucha = MuchaConfig(self)
 
     @classmethod

core/const.py

@@ -1,18 +1,16 @@
 from enum import Enum
 
 
-class MainboardPlatformCodes(Enum):
-    RINGEDGE = "AAL"
-    RINGEDGE2 = "AAS"
-    RINGWIDE = "AAM"
-    NU = "AAV"
-    NUSX = "AAW"
-    ALLS = "ACA"
-    #ALLS_UX = "ACAE"
-    #ALLS_HX = "ACAX"
+class MainboardPlatformCodes:
+    RINGEDGE = "AALE"
+    RINGWIDE = "AAML"
+    NU = "AAVE"
+    NUSX = "AAWE"
+    ALLS_UX = "ACAE"
+    ALLS_HX = "ACAX"
 
 
-class MainboardRevisions(Enum):
+class MainboardRevisions:
     RINGEDGE = 1
     RINGEDGE2 = 2
 
@@ -31,10 +29,11 @@ class MainboardRevisions(Enum):
     ALLS_HX2 = 12
 
 
-class KeychipPlatformsCodes(Enum):
-    RING = "72"
-    NU = ("60", "61", "69")
-    ALLS = "63"
+class KeychipPlatformsCodes:
+    RING = "A72E"
+    NU = ("A60E", "A60E", "A60E")
+    NUSX = ("A61X", "A69X")
+    ALLS = "A63E"
 
 
 class AllnetCountryCode(Enum):
@@ -45,14 +44,6 @@ class AllnetCountryCode(Enum):
     SOUTH_KOREA = "KOR"
     TAIWAN = "TWN"
     CHINA = "CHN"
-    AUSTRALIA = "AUS"
-    INDONESIA = "IDN"
-    MYANMAR = "MMR"
-    MALAYSIA = "MYS"
-    NEW_ZEALAND = "NZL"
-    PHILIPPINES = "PHL"
-    THAILAND = "THA"
-    VIETNAM = "VNM"
 
 
 class AllnetJapanRegionId(Enum):

core/data/alembic/env.py

@@ -1,18 +1,8 @@
 from __future__ import with_statement
-
-import asyncio
-import os
-from pathlib import Path
-import threading
+from alembic import context
+from sqlalchemy import engine_from_config, pool
 from logging.config import fileConfig
 
-import yaml
-from alembic import context
-from sqlalchemy import pool
-from sqlalchemy.engine import Connection
-from sqlalchemy.ext.asyncio import async_engine_from_config
-
-from core.config import CoreConfig
 from core.data.schema.base import metadata
 
 # this is the Alembic Config object, which provides
@@ -47,29 +37,20 @@ def run_migrations_offline():
     script output.
 
     """
-    raise Exception("Not implemented or configured!")
+    raise Exception('Not implemented or configured!')
 
     url = config.get_main_option("sqlalchemy.url")
-    context.configure(url=url, target_metadata=target_metadata, literal_binds=True)
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def do_run_migrations(connection: Connection) -> None:
     context.configure(
-        connection=connection,
-        target_metadata=target_metadata,
-        compare_type=True,
-        compare_server_default=True,
-    )
+        url=url, target_metadata=target_metadata, literal_binds=True)
 
     with context.begin_transaction():
         context.run_migrations()
 
 
-async def run_async_migrations() -> None:
-    """In this scenario we need to create an Engine
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
     and associate a connection with the context.
 
     """
@@ -78,42 +59,21 @@ async def run_async_migrations() -> None:
     for override in overrides:
         ini_section[override] = overrides[override]
 
-    core_config = CoreConfig()
-    
-    with (Path("../../..") / os.environ["ARTEMIS_CFG_DIR"] / "core.yaml").open(encoding="utf-8") as f:
-        core_config.update(yaml.safe_load(f))
-
-    connectable = async_engine_from_config(
+    connectable = engine_from_config(
         ini_section,
-        poolclass=pool.NullPool,
-        connect_args={
-            "charset": "utf8mb4",
-            "ssl": core_config.database.create_ssl_context_if_enabled(),
-        }
-    )
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool)
 
-    async with connectable.connect() as connection:
-        await connection.run_sync(do_run_migrations)
-
-    await connectable.dispose()
-
-
-def run_migrations_online():
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        # there's no event loop
-        asyncio.run(run_async_migrations())
-    else:
-        # there's currently an event loop and trying to wait for a coroutine
-        # to finish without using `await` is pretty wormy. nested event loops
-        # are explicitly forbidden by asyncio.
-        #
-        # take the easy way out, spawn it in another thread.
-        thread = threading.Thread(target=asyncio.run, args=(run_async_migrations(),))
-        thread.start()
-        thread.join()
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            compare_type=True,
+            compare_server_default=True,
+        )
 
+        with context.begin_transaction():
+            context.run_migrations()
 
 if context.is_offline_mode():
     run_migrations_offline()

core/data/alembic/versions/1d0014d35220_ongeki_update_ongeki_static_tech_music_uk.py

@@ -1,30 +0,0 @@
-"""ONGEKI update ongeki_static_tech_music_uk
-
-Revision ID: 1d0014d35220
-Revises: 91c682918b67
-Create Date: 2025-03-26 20:44:55.590992
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '1d0014d35220'
-down_revision = '91c682918b67'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint('ongeki_static_tech_music_uk', 'ongeki_static_tech_music', type_='unique')
-    op.create_unique_constraint('ongeki_static_tech_music_uk', 'ongeki_static_tech_music', ['version', 'eventId', 'musicId', 'level'])
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint('ongeki_static_tech_music_uk', 'ongeki_static_tech_music', type_='unique')
-    op.create_unique_constraint('ongeki_static_tech_music_uk', 'ongeki_static_tech_music', ['version', 'musicId'])
-    # ### end Alembic commands ###

core/data/alembic/versions/1e150d16ab6b_chuni_add_net_battle_uk.py

@@ -1,27 +0,0 @@
-"""chuni_add_net_battle_uk
-
-Revision ID: 1e150d16ab6b
-Revises: b23f985100ba
-Create Date: 2024-06-21 22:57:18.418488
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '1e150d16ab6b'
-down_revision = 'b23f985100ba'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_unique_constraint(None, 'chuni_profile_net_battle', ['user'])
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    op.drop_constraint(None, 'chuni_profile_net_battle', type_='unique')
-    # ### end Alembic commands ###

core/data/alembic/versions/263884e774cc_acc_opt_tables.py

@@ -1,164 +0,0 @@
-"""acc_opt_tables
-
-Revision ID: 263884e774cc
-Revises: 1d0014d35220
-Create Date: 2025-04-07 18:05:53.349320
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '263884e774cc'
-down_revision = '1d0014d35220'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('chuni_static_opt',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('version', sa.INTEGER(), nullable=False),
-    sa.Column('name', sa.VARCHAR(length=4), nullable=False),
-    sa.Column('sequence', sa.INTEGER(), nullable=False),
-    sa.Column('whenRead', sa.TIMESTAMP(), server_default=sa.text('now()'), nullable=False),
-    sa.Column('isEnable', sa.BOOLEAN(), server_default='1', nullable=False),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('version', 'name', name='chuni_static_opt_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('cm_static_opts',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('version', sa.INTEGER(), nullable=False),
-    sa.Column('name', sa.VARCHAR(length=4), nullable=False),
-    sa.Column('sequence', sa.INTEGER(), nullable=True),
-    sa.Column('gekiVersion', sa.INTEGER(), nullable=True),
-    sa.Column('gekiReleaseVer', sa.INTEGER(), nullable=True),
-    sa.Column('maiVersion', sa.INTEGER(), nullable=True),
-    sa.Column('maiReleaseVer', sa.INTEGER(), nullable=True),
-    sa.Column('whenRead', sa.TIMESTAMP(), server_default=sa.text('now()'), nullable=False),
-    sa.Column('isEnable', sa.BOOLEAN(), server_default='1', nullable=False),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('version', 'name', name='cm_static_opts_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('mai2_static_opt',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('version', sa.INTEGER(), nullable=False),
-    sa.Column('name', sa.VARCHAR(length=4), nullable=False),
-    sa.Column('sequence', sa.INTEGER(), nullable=False),
-    sa.Column('cmReleaseVer', sa.INTEGER(), nullable=False),
-    sa.Column('whenRead', sa.TIMESTAMP(), server_default=sa.text('now()'), nullable=False),
-    sa.Column('isEnable', sa.BOOLEAN(), server_default='1', nullable=False),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('version', 'name', name='mai2_static_opt_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('ongeki_static_opt',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('version', sa.INTEGER(), nullable=False),
-    sa.Column('name', sa.VARCHAR(length=4), nullable=False),
-    sa.Column('sequence', sa.INTEGER(), nullable=False),
-    sa.Column('cmReleaseVer', sa.INTEGER(), nullable=False),
-    sa.Column('whenRead', sa.TIMESTAMP(), server_default=sa.text('now()'), nullable=False),
-    sa.Column('isEnable', sa.BOOLEAN(), server_default='1', nullable=False),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('version', 'name', name='ongeki_static_opt_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.add_column('chuni_static_avatar', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_avatar', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_cards', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_cards', 'cm_static_opts', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_character', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_character', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_charge', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_charge', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_events', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_events', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_gachas', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_gachas', 'cm_static_opts', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_login_bonus', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_login_bonus', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_login_bonus_preset', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_login_bonus_preset', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_map_icon', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_map_icon', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_music', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_music', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_system_voice', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_system_voice', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('chuni_static_trophy', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_trophy', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('mai2_static_cards', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'mai2_static_cards', 'cm_static_opts', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('mai2_static_event', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'mai2_static_event', 'mai2_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('mai2_static_music', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'mai2_static_music', 'mai2_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('mai2_static_ticket', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'mai2_static_ticket', 'mai2_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('ongeki_static_cards', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'ongeki_static_cards', 'ongeki_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('ongeki_static_events', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'ongeki_static_events', 'ongeki_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('ongeki_static_gachas', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'ongeki_static_gachas', 'cm_static_opts', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('ongeki_static_music', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'ongeki_static_music', 'ongeki_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    op.add_column('ongeki_static_rewards', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'ongeki_static_rewards', 'ongeki_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint("ongeki_static_rewards_ibfk_1", 'ongeki_static_rewards', type_='foreignkey')
-    op.drop_column('ongeki_static_rewards', 'opt')
-    op.drop_constraint("ongeki_static_music_ibfk_1", 'ongeki_static_music', type_='foreignkey')
-    op.drop_column('ongeki_static_music', 'opt')
-    op.drop_constraint("ongeki_static_gachas_ibfk_1", 'ongeki_static_gachas', type_='foreignkey')
-    op.drop_column('ongeki_static_gachas', 'opt')
-    op.drop_constraint("ongeki_static_events_ibfk_1", "ongeki_static_events", type_='foreignkey')
-    op.drop_column('ongeki_static_events', 'opt')
-    op.drop_constraint("ongeki_static_cards_ibfk_1", "ongeki_static_cards", type_='foreignkey')
-    op.drop_column('ongeki_static_cards', 'opt')
-    op.drop_constraint("mai2_static_ticket_ibfk_1", "mai2_static_ticket", type_='foreignkey')
-    op.drop_column('mai2_static_ticket', 'opt')
-    op.drop_constraint("mai2_static_music_ibfk_1", "mai2_static_music", type_='foreignkey')
-    op.drop_column('mai2_static_music', 'opt')
-    op.drop_constraint("mai2_static_event_ibfk_1", "mai2_static_event", type_='foreignkey')
-    op.drop_column('mai2_static_event', 'opt')
-    op.drop_constraint("mai2_static_cards_ibfk_1", "mai2_static_cards", type_='foreignkey')
-    op.drop_column('mai2_static_cards', 'opt')
-    op.drop_constraint("chuni_static_trophy_ibfk_1", "chuni_static_trophy", type_='foreignkey')
-    op.drop_column('chuni_static_trophy', 'opt')
-    op.drop_constraint("chuni_static_system_voice_ibfk_1", "chuni_static_system_voice", type_='foreignkey')
-    op.drop_column('chuni_static_system_voice', 'opt')
-    op.drop_constraint("chuni_static_music_ibfk_1", "chuni_static_music", type_='foreignkey')
-    op.drop_column('chuni_static_music', 'opt')
-    op.drop_constraint("chuni_static_map_icon_ibfk_1", "chuni_static_map_icon", type_='foreignkey')
-    op.drop_column('chuni_static_map_icon', 'opt')
-    op.drop_constraint("chuni_static_login_bonus_preset_ibfk_1", "chuni_static_login_bonus_preset", type_='foreignkey')
-    op.drop_column('chuni_static_login_bonus_preset', 'opt')
-    op.drop_constraint("chuni_static_login_bonus_ibfk_2", "chuni_static_login_bonus", type_='foreignkey')
-    op.drop_column('chuni_static_login_bonus', 'opt')
-    op.drop_constraint("chuni_static_gachas_ibfk_1", "chuni_static_gachas", type_='foreignkey')
-    op.drop_column('chuni_static_gachas', 'opt')
-    op.drop_constraint("chuni_static_events_ibfk_1", "chuni_static_events", type_='foreignkey')
-    op.drop_column('chuni_static_events', 'opt')
-    op.drop_constraint("chuni_static_charge_ibfk_1", "chuni_static_charge", type_='foreignkey')
-    op.drop_column('chuni_static_charge', 'opt')
-    op.drop_constraint("chuni_static_character_ibfk_1", "chuni_static_character", type_='foreignkey')
-    op.drop_column('chuni_static_character', 'opt')
-    op.drop_constraint("chuni_static_cards_ibfk_1", "chuni_static_cards", type_='foreignkey')
-    op.drop_column('chuni_static_cards', 'opt')
-    op.drop_constraint("chuni_static_avatar_ibfk_1", "chuni_static_avatar", type_='foreignkey')
-    op.drop_column('chuni_static_avatar', 'opt')
-    op.drop_table('ongeki_static_opt')
-    op.drop_table('mai2_static_opt')
-    op.drop_table('cm_static_opts')
-    op.drop_table('chuni_static_opt')
-    # ### end Alembic commands ###

core/data/alembic/versions/27e3434740df_add_billing_tables.py

@@ -1,66 +0,0 @@
-"""add_billing_tables
-
-Revision ID: 27e3434740df
-Revises: ae364c078429
-Create Date: 2025-04-17 18:32:06.008601
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '27e3434740df'
-down_revision = 'ae364c078429'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('machine_billing_charge',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('machine', sa.Integer(), nullable=False),
-    sa.Column('game_id', sa.CHAR(length=5), nullable=False),
-    sa.Column('game_ver', sa.FLOAT(), nullable=False),
-    sa.Column('play_count', sa.INTEGER(), nullable=False),
-    sa.Column('play_limit', sa.INTEGER(), nullable=False),
-    sa.Column('product_code', sa.INTEGER(), nullable=False),
-    sa.Column('product_count', sa.INTEGER(), nullable=False),
-    sa.Column('func_type', sa.INTEGER(), nullable=False),
-    sa.Column('player_number', sa.INTEGER(), nullable=False),
-    sa.ForeignKeyConstraint(['machine'], ['machine.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('machine_billing_credit',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('machine', sa.Integer(), nullable=False),
-    sa.Column('chute_type', sa.INTEGER(), nullable=False),
-    sa.Column('service_type', sa.INTEGER(), nullable=False),
-    sa.Column('operation_type', sa.INTEGER(), nullable=False),
-    sa.Column('coin_rate0', sa.INTEGER(), nullable=False),
-    sa.Column('coin_rate1', sa.INTEGER(), nullable=False),
-    sa.Column('coin_bonus', sa.INTEGER(), nullable=False),
-    sa.Column('credit_rate', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot0', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot1', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot2', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot3', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot4', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot5', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot6', sa.INTEGER(), nullable=False),
-    sa.Column('coin_count_slot7', sa.INTEGER(), nullable=False),
-    sa.ForeignKeyConstraint(['machine'], ['machine.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('machine'),
-    mysql_charset='utf8mb4'
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('machine_billing_credit')
-    op.drop_table('machine_billing_charge')
-    # ### end Alembic commands ###

core/data/alembic/versions/28443e2da5b8_mai2_buddies_plus.py

@@ -1,28 +0,0 @@
-"""mai2_buddies_plus
-
-Revision ID: 28443e2da5b8
-Revises: 5ea73f89d982
-Create Date: 2024-09-15 20:44:02.351819
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '28443e2da5b8'
-down_revision = '5ea73f89d982'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.add_column('mai2_profile_detail', sa.Column('point', sa.Integer()))
-    op.add_column('mai2_profile_detail', sa.Column('totalPoint', sa.Integer()))
-    op.add_column('mai2_profile_detail', sa.Column('friendRegistSkip', sa.SmallInteger()))
-
-
-def downgrade():
-    op.drop_column('mai2_profile_detail', 'point')
-    op.drop_column('mai2_profile_detail', 'totalPoint')
-    op.drop_column('mai2_profile_detail', 'friendRegistSkip')

core/data/alembic/versions/2bf9f38d9444_add_event_log_info.py

@@ -1,48 +0,0 @@
-"""add_event_log_info
-
-Revision ID: 2bf9f38d9444
-Revises: 81e44dd6047a
-Create Date: 2024-05-21 23:00:17.468407
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '2bf9f38d9444'
-down_revision = '81e44dd6047a'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('event_log', sa.Column('user', sa.INTEGER(), nullable=True))
-    op.add_column('event_log', sa.Column('arcade', sa.INTEGER(), nullable=True))
-    op.add_column('event_log', sa.Column('machine', sa.INTEGER(), nullable=True))
-    op.add_column('event_log', sa.Column('ip', sa.TEXT(length=39), nullable=True))
-    op.alter_column('event_log', 'when_logged',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    op.create_foreign_key(None, 'event_log', 'machine', ['machine'], ['id'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'event_log', 'arcade', ['arcade'], ['id'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'event_log', 'aime_user', ['user'], ['id'], onupdate='cascade', ondelete='cascade')
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint(None, 'event_log', type_='foreignkey')
-    op.drop_constraint(None, 'event_log', type_='foreignkey')
-    op.drop_constraint(None, 'event_log', type_='foreignkey')
-    op.alter_column('event_log', 'when_logged',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('current_timestamp()'),
-               existing_nullable=False)
-    op.drop_column('event_log', 'ip')
-    op.drop_column('event_log', 'machine')
-    op.drop_column('event_log', 'arcade')
-    op.drop_column('event_log', 'user')
-    # ### end Alembic commands ###

core/data/alembic/versions/2d024cf145a1_add_event_log_game_version.py

@@ -1,46 +0,0 @@
-"""add_event_log_game_version
-
-Revision ID: 2d024cf145a1
-Revises: 2bf9f38d9444
-Create Date: 2024-05-21 23:41:31.445331
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '2d024cf145a1'
-down_revision = '2bf9f38d9444'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('event_log', sa.Column('game', sa.TEXT(length=4), nullable=True))
-    op.add_column('event_log', sa.Column('version', sa.TEXT(length=24), nullable=True))
-    op.alter_column('event_log', 'ip',
-               existing_type=mysql.TINYTEXT(),
-               type_=sa.TEXT(length=39),
-               existing_nullable=True)
-    op.alter_column('event_log', 'when_logged',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('event_log', 'when_logged',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('current_timestamp()'),
-               existing_nullable=False)
-    op.alter_column('event_log', 'ip',
-               existing_type=sa.TEXT(length=39),
-               type_=mysql.TINYTEXT(),
-               existing_nullable=True)
-    op.drop_column('event_log', 'version')
-    op.drop_column('event_log', 'game')
-    # ### end Alembic commands ###

core/data/alembic/versions/3657efefc5a4_pokken_fix_pokemon_uk.py

@@ -1,54 +0,0 @@
-"""pokken_fix_pokemon_uk
-
-Revision ID: 3657efefc5a4
-Revises: 4a02e623e5e6
-Create Date: 2024-06-13 23:50:57.611998
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '3657efefc5a4'
-down_revision = '4a02e623e5e6'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('pokken_pokemon_data', 'char_id',
-               existing_type=mysql.INTEGER(display_width=11),
-               nullable=True)
-    op.alter_column('pokken_pokemon_data', 'illustration_book_no',
-               existing_type=mysql.INTEGER(display_width=11),
-               nullable=False)
-    op.drop_constraint('pokken_pokemon_data_ibfk_1', table_name='pokken_pokemon_data', type_='foreignkey')
-    op.drop_index('pokken_pokemon_data_uk', table_name='pokken_pokemon_data')
-    op.create_unique_constraint('pokken_pokemon_uk', 'pokken_pokemon_data', ['user', 'illustration_book_no'])
-    op.create_foreign_key("pokken_pokemon_data_ibfk_1", "pokken_pokemon_data", "aime_user", ['user'], ['id'])
-    op.alter_column('pokken_profile', 'trainer_name',
-               existing_type=mysql.VARCHAR(length=16),
-               type_=sa.String(length=14),
-               existing_nullable=True)
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('pokken_profile', 'trainer_name',
-               existing_type=sa.String(length=14),
-               type_=mysql.VARCHAR(length=16),
-               existing_nullable=True)
-    op.drop_constraint('pokken_pokemon_data_ibfk_1', table_name='pokken_pokemon_data', type_='foreignkey')
-    op.drop_constraint('pokken_pokemon_uk', 'pokken_pokemon_data', type_='unique')
-    op.create_index('pokken_pokemon_data_uk', 'pokken_pokemon_data', ['user', 'char_id'], unique=True)
-    op.create_foreign_key("pokken_pokemon_data_ibfk_1", "pokken_pokemon_data", "aime_user", ['user'], ['id'])
-    op.alter_column('pokken_pokemon_data', 'illustration_book_no',
-               existing_type=mysql.INTEGER(display_width=11),
-               nullable=True)
-    op.alter_column('pokken_pokemon_data', 'char_id',
-               existing_type=mysql.INTEGER(display_width=11),
-               nullable=False)
-    # ### end Alembic commands ###

core/data/alembic/versions/41f77ef50588_chuni_ui_overhaul.py

@@ -1,122 +0,0 @@
-"""chuni_ui_overhaul
-
-Revision ID: 41f77ef50588
-Revises: d8cd1fa04c2a
-Create Date: 2024-11-02 13:27:45.839787
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '41f77ef50588'
-down_revision = 'd8cd1fa04c2a'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('chuni_static_avatar', sa.Column('sortName', mysql.VARCHAR(length=255), nullable=True))
-    op.add_column('chuni_static_avatar', sa.Column('isEnabled', mysql.TINYINT(display_width=1), server_default=sa.text('1'), autoincrement=False, nullable=True))
-    op.add_column('chuni_static_avatar', sa.Column('defaultHave', mysql.TINYINT(display_width=1), server_default=sa.text('0'), autoincrement=False, nullable=True))
-    
-    op.create_table('chuni_static_character',
-    sa.Column('id', mysql.INTEGER(display_width=11), autoincrement=True, nullable=False),
-    sa.Column('version', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False),
-    sa.Column('characterId', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True),
-    sa.Column('name', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('sortName', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('worksName', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('rareType', mysql.INTEGER(display_width=11), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.Column('imagePath1', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('imagePath2', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('imagePath3', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('isEnabled', mysql.TINYINT(display_width=1), server_default=sa.text('1'), autoincrement=False, nullable=True),
-    sa.Column('defaultHave', mysql.TINYINT(display_width=1), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_collate='utf8mb4_general_ci',
-    mysql_default_charset='utf8mb4',
-    mysql_engine='InnoDB'
-    )
-    op.create_index('chuni_static_character_uk', 'chuni_static_character', ['version', 'characterId'], unique=True)
-    op.create_table('chuni_static_map_icon',
-    sa.Column('id', mysql.INTEGER(display_width=11), autoincrement=True, nullable=False),
-    sa.Column('version', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False),
-    sa.Column('mapIconId', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True),
-    sa.Column('name', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('sortName', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('iconPath', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('isEnabled', mysql.TINYINT(display_width=1), server_default=sa.text('1'), autoincrement=False, nullable=True),
-    sa.Column('defaultHave', mysql.TINYINT(display_width=1), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_collate='utf8mb4_general_ci',
-    mysql_default_charset='utf8mb4',
-    mysql_engine='InnoDB'
-    )
-    op.create_index('chuni_static_mapicon_uk', 'chuni_static_map_icon', ['version', 'mapIconId'], unique=True)
-    op.create_table('chuni_static_nameplate',
-    sa.Column('id', mysql.INTEGER(display_width=11), autoincrement=True, nullable=False),
-    sa.Column('version', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False),
-    sa.Column('nameplateId', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True),
-    sa.Column('name', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('texturePath', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('isEnabled', mysql.TINYINT(display_width=1), server_default=sa.text('1'), autoincrement=False, nullable=True),
-    sa.Column('defaultHave', mysql.TINYINT(display_width=1), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.Column('sortName', mysql.VARCHAR(length=255), nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_collate='utf8mb4_general_ci',
-    mysql_default_charset='utf8mb4',
-    mysql_engine='InnoDB'
-    )
-    op.create_index('chuni_static_nameplate_uk', 'chuni_static_nameplate', ['version', 'nameplateId'], unique=True)
-    op.create_table('chuni_static_trophy',
-    sa.Column('id', mysql.INTEGER(display_width=11), autoincrement=True, nullable=False),
-    sa.Column('version', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False),
-    sa.Column('trophyId', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True),
-    sa.Column('name', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('rareType', mysql.TINYINT(display_width=11), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.Column('isEnabled', mysql.TINYINT(display_width=1), server_default=sa.text('1'), autoincrement=False, nullable=True),
-    sa.Column('defaultHave', mysql.TINYINT(display_width=1), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_collate='utf8mb4_general_ci',
-    mysql_default_charset='utf8mb4',
-    mysql_engine='InnoDB'
-    )
-    op.create_index('chuni_static_trophy_uk', 'chuni_static_trophy', ['version', 'trophyId'], unique=True)
-    op.create_table('chuni_static_system_voice',
-    sa.Column('id', mysql.INTEGER(display_width=11), autoincrement=True, nullable=False),
-    sa.Column('version', mysql.INTEGER(display_width=11), autoincrement=False, nullable=False),
-    sa.Column('voiceId', mysql.INTEGER(display_width=11), autoincrement=False, nullable=True),
-    sa.Column('name', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('sortName', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('imagePath', mysql.VARCHAR(length=255), nullable=True),
-    sa.Column('isEnabled', mysql.TINYINT(display_width=1), server_default=sa.text('1'), autoincrement=False, nullable=True),
-    sa.Column('defaultHave', mysql.TINYINT(display_width=1), server_default=sa.text('0'), autoincrement=False, nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_collate='utf8mb4_general_ci',
-    mysql_default_charset='utf8mb4',
-    mysql_engine='InnoDB'
-    )
-    op.create_index('chuni_static_systemvoice_uk', 'chuni_static_system_voice', ['version', 'voiceId'], unique=True)
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index('chuni_static_systemvoice_uk', table_name='chuni_static_system_voice')
-    op.drop_table('chuni_static_system_voice')
-    op.drop_index('chuni_static_trophy_uk', table_name='chuni_static_trophy')
-    op.drop_table('chuni_static_trophy')
-    op.drop_index('chuni_static_nameplate_uk', table_name='chuni_static_nameplate')
-    op.drop_table('chuni_static_nameplate')
-    op.drop_index('chuni_static_mapicon_uk', table_name='chuni_static_map_icon')
-    op.drop_table('chuni_static_map_icon')
-    op.drop_index('chuni_static_character_uk', table_name='chuni_static_character')
-    op.drop_table('chuni_static_character')
-    
-    op.drop_column('chuni_static_avatar', 'defaultHave')
-    op.drop_column('chuni_static_avatar', 'isEnabled')
-    op.drop_column('chuni_static_avatar', 'sortName')
-    # ### end Alembic commands ###

core/data/alembic/versions/48f4acc43a7e_card_add_idm_chip_id.py

@@ -1,50 +0,0 @@
-"""card_add_idm_chip_id
-
-Revision ID: 48f4acc43a7e
-Revises: 1e150d16ab6b
-Create Date: 2024-06-21 23:53:34.369134
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '48f4acc43a7e'
-down_revision = '1e150d16ab6b'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('aime_card', sa.Column('idm', sa.String(length=16), nullable=True))
-    op.add_column('aime_card', sa.Column('chip_id', sa.BIGINT(), nullable=True))
-    op.alter_column('aime_card', 'access_code',
-               existing_type=mysql.VARCHAR(length=20),
-               nullable=False)
-    op.alter_column('aime_card', 'created_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=True)
-    op.create_unique_constraint(None, 'aime_card', ['chip_id'])
-    op.create_unique_constraint(None, 'aime_card', ['idm'])
-    op.create_unique_constraint(None, 'aime_card', ['access_code'])
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint("chip_id", 'aime_card', type_='unique')
-    op.drop_constraint("idm", 'aime_card', type_='unique')
-    op.drop_constraint("access_code", 'aime_card', type_='unique')
-    op.alter_column('aime_card', 'created_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=True)
-    op.alter_column('aime_card', 'access_code',
-               existing_type=mysql.VARCHAR(length=20),
-               nullable=True)
-    op.drop_column('aime_card', 'chip_id')
-    op.drop_column('aime_card', 'idm')
-    # ### end Alembic commands ###

core/data/alembic/versions/49c295e89cd4_chunithm_verse.py

@@ -1,85 +0,0 @@
-"""CHUNITHM VERSE support
-
-Revision ID: 49c295e89cd4
-Revises: f6007bbf057d
-Create Date: 2025-03-09 14:10:03.067328
-
-"""
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-from sqlalchemy.sql import func
-
-# revision identifiers, used by Alembic.
-revision = "49c295e89cd4"
-down_revision = "f6007bbf057d"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    ### commands auto generated by Alembic - please adjust! ###
-    op.add_column("chuni_profile_data", sa.Column("trophyIdSub1", sa.Integer()))
-    op.add_column("chuni_profile_data", sa.Column("trophyIdSub2", sa.Integer()))
-    op.add_column("chuni_score_playlog", sa.Column("monthPoint", sa.Integer()))
-    op.add_column("chuni_score_playlog", sa.Column("eventPoint", sa.Integer()))
-
-    op.create_table(
-        "chuni_static_unlock_challenge",
-        sa.Column("id", sa.Integer(), primary_key=True, nullable=False),
-        sa.Column("version", sa.Integer(), nullable=False),
-        sa.Column("unlockChallengeId", sa.Integer(), nullable=False),
-        sa.Column("name", sa.String(length=255)),
-        sa.Column("isEnabled", sa.Boolean(), server_default="1"),
-        sa.Column("startDate", sa.TIMESTAMP(), server_default=func.now()),
-        sa.Column("courseId1", sa.Integer()),
-        sa.Column("courseId2", sa.Integer()),
-        sa.Column("courseId3", sa.Integer()),
-        sa.Column("courseId4", sa.Integer()),
-        sa.Column("courseId5", sa.Integer()),
-        sa.UniqueConstraint(
-            "version", "unlockChallengeId", name="chuni_static_unlock_challenge_uk"
-        ),
-        mysql_charset="utf8mb4",
-    )
-
-    op.create_table(
-        "chuni_item_unlock_challenge",
-        sa.Column("id", sa.Integer(), primary_key=True, nullable=False),
-        sa.Column("version", sa.Integer(), nullable=False),
-        sa.Column(
-            "user",
-            sa.Integer(),
-            sa.ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
-            nullable=False,
-        ),
-        sa.Column("unlockChallengeId", sa.Integer(), nullable=False),
-        sa.Column("status", sa.Integer()),
-        sa.Column("clearCourseId", sa.Integer()),
-        sa.Column("conditionType", sa.Integer()),
-        sa.Column("score", sa.Integer()),
-        sa.Column("life", sa.Integer()),
-        sa.Column("clearDate", sa.TIMESTAMP(), server_defaul=func.now()),
-        sa.UniqueConstraint(
-            "version",
-            "user",
-            "unlockChallengeId",
-            name="chuni_item_unlock_challenge_uk",
-        ),
-        mysql_charset="utf8mb4",
-    )
-
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column("chuni_score_playlog", "eventPoint")
-    op.drop_column("chuni_score_playlog", "monthPoint")
-    op.drop_column("chuni_profile_data", "trophyIdSub2")
-    op.drop_column("chuni_profile_data", "trophyIdSub1")
-
-    op.drop_table("chuni_static_unlock_challenge")
-    op.drop_table("chuni_item_unlock_challenge")
-    # ### end Alembic commands ###

core/data/alembic/versions/4a02e623e5e6_mai2_add_favs_rivals.py

@@ -1,48 +0,0 @@
-"""mai2_add_favs_rivals
-
-Revision ID: 4a02e623e5e6
-Revises: 8ad40a6e7be2
-Create Date: 2024-06-08 19:02:43.856395
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '4a02e623e5e6'
-down_revision = '8ad40a6e7be2'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('mai2_item_favorite_music',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('user', sa.Integer(), nullable=False),
-    sa.Column('musicId', sa.Integer(), nullable=False),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user', 'musicId', name='mai2_item_favorite_music_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('mai2_user_rival',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('user', sa.Integer(), nullable=False),
-    sa.Column('rival', sa.Integer(), nullable=False),
-    sa.Column('show', sa.Boolean(), server_default='0', nullable=False),
-    sa.ForeignKeyConstraint(['rival'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user', 'rival', name='mai2_user_rival_uk'),
-    mysql_charset='utf8mb4'
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('mai2_user_rival')
-    op.drop_table('mai2_item_favorite_music')
-    # ### end Alembic commands ###

core/data/alembic/versions/54a84103b84e_mai2_intimacy.py

@@ -1,43 +0,0 @@
-"""mai2_intimacy
-
-Revision ID: 54a84103b84e
-Revises: bc91c1206dca
-Create Date: 2024-09-16 17:47:49.164546
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy import Column, Integer, UniqueConstraint
-
-# revision identifiers, used by Alembic.
-revision = '54a84103b84e'
-down_revision = 'bc91c1206dca'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.create_table(
-        "mai2_user_intimate",
-        Column("id", Integer, primary_key=True, nullable=False),
-        Column("user", Integer, nullable=False),
-        Column("partnerId", Integer, nullable=False),
-        Column("intimateLevel", Integer, nullable=False),
-        Column("intimateCountRewarded", Integer, nullable=False),
-        UniqueConstraint("user", "partnerId", name="mai2_user_intimate_uk"),
-        mysql_charset="utf8mb4",
-    )
-
-    op.create_foreign_key(
-        None,
-        "mai2_user_intimate",
-        "aime_user",
-        ["user"],
-        ["id"],
-        ondelete="cascade",
-        onupdate="cascade",
-    )
-
-
-def downgrade():
-    op.drop_table("mai2_user_intimate")

core/data/alembic/versions/5cf98cfe52ad_mai2_prism_support.py

@@ -1,52 +0,0 @@
-"""Mai2 PRiSM support
-
-Revision ID: 5cf98cfe52ad
-Revises: 263884e774cc
-Create Date: 2025-04-08 08:00:51.243089
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '5cf98cfe52ad'
-down_revision = '263884e774cc'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('mai2_score_kaleidxscope',
-    sa.Column('id', sa.Integer(), nullable=False),
-    sa.Column('user', sa.Integer(), nullable=False),
-    sa.Column('gateId', sa.Integer(), nullable=True),
-    sa.Column('isGateFound', sa.Boolean(), nullable=True),
-    sa.Column('isKeyFound', sa.Boolean(), nullable=True),
-    sa.Column('isClear', sa.Boolean(), nullable=True),
-    sa.Column('totalRestLife', sa.Integer(), nullable=True),
-    sa.Column('totalAchievement', sa.Integer(), nullable=True),
-    sa.Column('totalDeluxscore', sa.Integer(), nullable=True),
-    sa.Column('bestAchievement', sa.Integer(), nullable=True),
-    sa.Column('bestDeluxscore', sa.Integer(), nullable=True),
-    sa.Column('bestAchievementDate', sa.String(length=25), nullable=True),
-    sa.Column('bestDeluxscoreDate', sa.String(length=25), nullable=True),
-    sa.Column('playCount', sa.Integer(), nullable=True),
-    sa.Column('clearDate', sa.String(length=25), nullable=True),
-    sa.Column('lastPlayDate', sa.String(length=25), nullable=True),
-    sa.Column('isInfoWatched', sa.Boolean(), nullable=True),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user', 'gateId', name='mai2_score_best_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.add_column('mai2_playlog', sa.Column('extBool2', sa.Boolean(), nullable=True, server_default=sa.text("NULL")))
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('mai2_playlog', 'extBool2')
-    op.drop_table('mai2_score_kaleidxscope')
-    # ### end Alembic commands ###

core/data/alembic/versions/5ea363686347_mai2_presents.py

@@ -1,41 +0,0 @@
-"""mai2_presents
-
-Revision ID: 5ea363686347
-Revises: 680789dabab3
-Create Date: 2024-06-28 14:49:07.666879
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '5ea363686347'
-down_revision = '680789dabab3'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('mai2_item_present',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('version', sa.INTEGER(), nullable=True),
-    sa.Column('user', sa.Integer(), nullable=True),
-    sa.Column('itemKind', sa.INTEGER(), nullable=False),
-    sa.Column('itemId', sa.INTEGER(), nullable=False),
-    sa.Column('stock', sa.INTEGER(), server_default='1', nullable=False),
-    sa.Column('startDate', sa.TIMESTAMP(), nullable=True),
-    sa.Column('endDate', sa.TIMESTAMP(), nullable=True),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('version', 'user', 'itemKind', 'itemId', name='mai2_item_present_uk'),
-    mysql_charset='utf8mb4'
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('mai2_item_present')
-    # ### end Alembic commands ###

core/data/alembic/versions/5ea73f89d982_card_add_memo.py

@@ -1,28 +0,0 @@
-"""card_add_memo
-
-Revision ID: 5ea73f89d982
-Revises: 745448d83696
-Create Date: 2024-07-06 22:46:56.992152
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '5ea73f89d982'
-down_revision = '745448d83696'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('aime_card', sa.Column('memo', sa.VARCHAR(length=16), nullable=True))
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('aime_card', 'memo')
-    # ### end Alembic commands ###

core/data/alembic/versions/680789dabab3_sao_player_changes.py

@@ -1,295 +0,0 @@
-"""sao_player_changes
-
-Revision ID: 680789dabab3
-Revises: a616fd164e40
-Create Date: 2024-06-26 23:19:16.863778
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '680789dabab3'
-down_revision = 'a616fd164e40'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.add_column('sao_equipment_data', sa.Column('is_shop_purchase', sa.BOOLEAN(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('is_protect', sa.BOOLEAN(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property1_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property1_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property1_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property2_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property2_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property2_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property3_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property3_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property3_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property4_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property4_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('property4_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_equipment_data', sa.Column('converted_card_num', sa.INTEGER(), server_default='0', nullable=False))
-    op.alter_column('sao_equipment_data', 'equipment_id',
-               existing_type=mysql.INTEGER(),
-               type_=sa.BIGINT(),
-               existing_nullable=False)
-    op.alter_column('sao_equipment_data', 'get_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    op.create_foreign_key(None, 'sao_equipment_data', 'sao_static_property', ['property2_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_equipment_data', 'sao_static_property', ['property4_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_equipment_data', 'sao_static_property', ['property3_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_equipment_data', 'sao_static_property', ['property1_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_equipment_data', 'sao_static_equipment_list', ['equipment_id'], ['EquipmentId'], onupdate='cascade', ondelete='cascade')
-    op.add_column('sao_hero_log_data', sa.Column('max_level_extend_num', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('is_awakenable', sa.BOOLEAN(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('awakening_stage', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('awakening_exp', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('is_shop_purchase', sa.BOOLEAN(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('is_protect', sa.BOOLEAN(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property1_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property1_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property1_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property2_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property2_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property2_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property3_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property3_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property3_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property4_property_id', sa.BIGINT(), server_default='2', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property4_value1', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('property4_value2', sa.INTEGER(), server_default='0', nullable=False))
-    op.add_column('sao_hero_log_data', sa.Column('converted_card_num', sa.INTEGER(), server_default='0', nullable=False))
-    op.alter_column('sao_hero_log_data', 'main_weapon',
-               existing_type=mysql.INTEGER(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'sub_equipment',
-               existing_type=mysql.INTEGER(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'skill_slot1_skill_id',
-               existing_type=mysql.INTEGER(),
-               type_=sa.BIGINT(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'skill_slot2_skill_id',
-               existing_type=mysql.INTEGER(),
-               type_=sa.BIGINT(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'skill_slot3_skill_id',
-               existing_type=mysql.INTEGER(),
-               type_=sa.BIGINT(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'skill_slot4_skill_id',
-               existing_type=mysql.INTEGER(),
-               type_=sa.BIGINT(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'skill_slot5_skill_id',
-               existing_type=mysql.INTEGER(),
-               type_=sa.BIGINT(),
-               nullable=True)
-    op.alter_column('sao_hero_log_data', 'get_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    op.alter_column("sao_hero_log_data", "user_hero_log_id",
-                    existing_type=sa.Integer(),
-                    new_column_name="hero_log_id",
-                    type_=sa.BIGINT(),
-                    nullable=False)
-    op.execute(sa.text("UPDATE sao_hero_log_data SET skill_slot1_skill_id = NULL WHERE skill_slot1_skill_id = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data SET skill_slot2_skill_id = NULL WHERE skill_slot2_skill_id = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data SET skill_slot3_skill_id = NULL WHERE skill_slot3_skill_id = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data SET skill_slot4_skill_id = NULL WHERE skill_slot4_skill_id = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data SET skill_slot5_skill_id = NULL WHERE skill_slot5_skill_id = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data SET main_weapon = NULL WHERE main_weapon = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data SET sub_equipment = NULL WHERE sub_equipment = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_party SET user_hero_log_id_1 = NULL WHERE user_hero_log_id_1 = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_party SET user_hero_log_id_2 = NULL WHERE user_hero_log_id_2 = 0;"))
-    op.execute(sa.text("UPDATE sao_hero_party SET user_hero_log_id_3 = NULL WHERE user_hero_log_id_3 = 0;"))
-    
-    op.execute(sa.text("UPDATE sao_hero_log_data INNER JOIN sao_equipment_data ON sao_hero_log_data.main_weapon = sao_equipment_data.equipment_id SET sao_hero_log_data.main_weapon = sao_equipment_data.id;"))
-    op.execute(sa.text("UPDATE sao_hero_log_data INNER JOIN sao_equipment_data ON sao_hero_log_data.sub_equipment = sao_equipment_data.equipment_id SET sao_hero_log_data.sub_equipment = sao_equipment_data.id;"))
-    
-    op.execute(sa.text("UPDATE sao_hero_party INNER JOIN sao_hero_log_data ON sao_hero_party.user_hero_log_id_1 = sao_hero_log_data.hero_log_id SET sao_hero_party.user_hero_log_id_1 = sao_hero_log_data.id;"))
-    op.execute(sa.text("UPDATE sao_hero_party INNER JOIN sao_hero_log_data ON sao_hero_party.user_hero_log_id_2 = sao_hero_log_data.hero_log_id SET sao_hero_party.user_hero_log_id_2 = sao_hero_log_data.id;"))
-    op.execute(sa.text("UPDATE sao_hero_party INNER JOIN sao_hero_log_data ON sao_hero_party.user_hero_log_id_3 = sao_hero_log_data.hero_log_id SET sao_hero_party.user_hero_log_id_3 = sao_hero_log_data.id;"))
-    
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_property', ['property4_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_skill', ['skill_slot1_skill_id'], ['SkillId'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_skill', ['skill_slot5_skill_id'], ['SkillId'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_skill', ['skill_slot2_skill_id'], ['SkillId'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_skill', ['skill_slot3_skill_id'], ['SkillId'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_equipment_data', ['main_weapon'], ['id'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_property', ['property3_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_skill', ['skill_slot4_skill_id'], ['SkillId'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_equipment_data', ['sub_equipment'], ['id'], onupdate='set null', ondelete='set null')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_property', ['property1_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_hero_list', ['hero_log_id'], ['HeroLogId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_log_data', 'sao_static_property', ['property2_property_id'], ['PropertyId'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_party', 'sao_hero_log_data', ['user_hero_log_id_3'], ['id'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_party', 'sao_hero_log_data', ['user_hero_log_id_1'], ['id'], onupdate='cascade', ondelete='cascade')
-    op.create_foreign_key(None, 'sao_hero_party', 'sao_hero_log_data', ['user_hero_log_id_2'], ['id'], onupdate='cascade', ondelete='cascade')
-    op.alter_column('sao_item_data', 'get_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    op.alter_column('sao_play_sessions', 'play_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    op.add_column('sao_player_quest', sa.Column('quest_type', sa.INTEGER(), server_default='1', nullable=False))
-    op.alter_column('sao_player_quest', 'play_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    op.alter_column('sao_player_quest', 'episode_id',
-               existing_type=mysql.INTEGER(),
-               new_column_name="quest_scene_id",
-               type_=sa.BIGINT(),
-               nullable=False)
-    op.create_foreign_key(None, 'sao_player_quest', 'sao_static_quest', ['quest_scene_id'], ['QuestSceneId'], onupdate='cascade', ondelete='cascade')
-    op.add_column('sao_profile', sa.Column('my_shop', sa.INTEGER(), nullable=True))
-    op.add_column('sao_profile', sa.Column('fav_hero', sa.INTEGER(), nullable=True))
-    op.add_column('sao_profile', sa.Column('when_register', sa.TIMESTAMP(), server_default=sa.text('now()'), nullable=True))
-    op.add_column('sao_profile', sa.Column('last_login_date', sa.TIMESTAMP(), nullable=True))
-    op.add_column('sao_profile', sa.Column('last_yui_medal_date', sa.TIMESTAMP(), nullable=True))
-    op.add_column('sao_profile', sa.Column('last_bonus_yui_medal_date', sa.TIMESTAMP(), nullable=True))
-    op.add_column('sao_profile', sa.Column('last_comeback_date', sa.TIMESTAMP(), nullable=True))
-    op.add_column('sao_profile', sa.Column('last_login_bonus_date', sa.TIMESTAMP(), nullable=True))
-    op.add_column('sao_profile', sa.Column('ad_confirm_date', sa.TIMESTAMP(), nullable=True))
-    op.add_column('sao_profile', sa.Column('login_ct', sa.INTEGER(), server_default='0', nullable=True))
-    op.create_foreign_key(None, 'sao_profile', 'sao_hero_log_data', ['fav_hero'], ['id'], onupdate='cascade', ondelete='set null')
-
-
-def downgrade():
-    op.drop_constraint("sao_profile_ibfk_2", 'sao_profile', type_='foreignkey')
-    op.drop_column('sao_profile', 'login_ct')
-    op.drop_column('sao_profile', 'ad_confirm_date')
-    op.drop_column('sao_profile', 'last_login_bonus_date')
-    op.drop_column('sao_profile', 'last_comeback_date')
-    op.drop_column('sao_profile', 'last_bonus_yui_medal_date')
-    op.drop_column('sao_profile', 'last_yui_medal_date')
-    op.drop_column('sao_profile', 'last_login_date')
-    op.drop_column('sao_profile', 'when_register')
-    op.drop_column('sao_profile', 'fav_hero')
-    op.drop_column('sao_profile', 'my_shop')
-    op.alter_column('sao_player_quest', 'quest_scene_id',
-               existing_type=mysql.BIGINT(),
-               new_column_name="episode_id",
-               type_=sa.INTEGER(),
-               nullable=False)
-    op.drop_constraint("sao_player_quest_ibfk_2", 'sao_player_quest', type_='foreignkey')
-    op.alter_column('sao_player_quest', 'play_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=False)
-    op.drop_column('sao_player_quest', 'quest_scene_id')
-    op.drop_column('sao_player_quest', 'quest_type')
-    op.alter_column('sao_play_sessions', 'play_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=False)
-    op.alter_column('sao_item_data', 'get_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=False)
-    op.drop_constraint("sao_hero_party_ibfk_2", 'sao_hero_party', type_='foreignkey')
-    op.drop_constraint("sao_hero_party_ibfk_3", 'sao_hero_party', type_='foreignkey')
-    op.drop_constraint("sao_hero_party_ibfk_4", 'sao_hero_party', type_='foreignkey')
-    op.alter_column("sao_hero_log_data", "hero_log_id",
-                    existing_type=sa.BIGINT(),
-                    new_column_name="user_hero_log_id",
-                    type_=sa.Integer(),
-                    nullable=False)
-    op.drop_constraint("sao_hero_log_data_ibfk_2", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_3", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_4", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_5", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_6", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_7", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_8", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_9", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_10", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_11", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_12", 'sao_hero_log_data', type_='foreignkey')
-    op.drop_constraint("sao_hero_log_data_ibfk_13", 'sao_hero_log_data', type_='foreignkey')
-    op.alter_column('sao_hero_log_data', 'get_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=False)
-    op.alter_column('sao_hero_log_data', 'skill_slot5_skill_id',
-               existing_type=sa.BIGINT(),
-               type_=mysql.INTEGER(),
-               nullable=False)
-    op.alter_column('sao_hero_log_data', 'skill_slot4_skill_id',
-               existing_type=sa.BIGINT(),
-               type_=mysql.INTEGER(),
-               nullable=False)
-    op.alter_column('sao_hero_log_data', 'skill_slot3_skill_id',
-               existing_type=sa.BIGINT(),
-               type_=mysql.INTEGER(),
-               nullable=False)
-    op.alter_column('sao_hero_log_data', 'skill_slot2_skill_id',
-               existing_type=sa.BIGINT(),
-               type_=mysql.INTEGER(),
-               nullable=False)
-    op.alter_column('sao_hero_log_data', 'skill_slot1_skill_id',
-               existing_type=sa.BIGINT(),
-               type_=mysql.INTEGER(),
-               nullable=False)
-    op.alter_column('sao_hero_log_data', 'sub_equipment',
-               existing_type=mysql.INTEGER(),
-               nullable=False)
-    op.alter_column('sao_hero_log_data', 'main_weapon',
-               existing_type=mysql.INTEGER(),
-               nullable=False)
-    op.drop_column('sao_hero_log_data', 'converted_card_num')
-    op.drop_column('sao_hero_log_data', 'property4_value2')
-    op.drop_column('sao_hero_log_data', 'property4_value1')
-    op.drop_column('sao_hero_log_data', 'property4_property_id')
-    op.drop_column('sao_hero_log_data', 'property3_value2')
-    op.drop_column('sao_hero_log_data', 'property3_value1')
-    op.drop_column('sao_hero_log_data', 'property3_property_id')
-    op.drop_column('sao_hero_log_data', 'property2_value2')
-    op.drop_column('sao_hero_log_data', 'property2_value1')
-    op.drop_column('sao_hero_log_data', 'property2_property_id')
-    op.drop_column('sao_hero_log_data', 'property1_value2')
-    op.drop_column('sao_hero_log_data', 'property1_value1')
-    op.drop_column('sao_hero_log_data', 'property1_property_id')
-    op.drop_column('sao_hero_log_data', 'is_protect')
-    op.drop_column('sao_hero_log_data', 'is_shop_purchase')
-    op.drop_column('sao_hero_log_data', 'awakening_exp')
-    op.drop_column('sao_hero_log_data', 'awakening_stage')
-    op.drop_column('sao_hero_log_data', 'is_awakenable')
-    op.drop_column('sao_hero_log_data', 'max_level_extend_num')
-    op.drop_constraint("sao_equipment_data_ibfk_2", 'sao_equipment_data', type_='foreignkey')
-    op.drop_constraint("sao_equipment_data_ibfk_3", 'sao_equipment_data', type_='foreignkey')
-    op.drop_constraint("sao_equipment_data_ibfk_4", 'sao_equipment_data', type_='foreignkey')
-    op.drop_constraint("sao_equipment_data_ibfk_5", 'sao_equipment_data', type_='foreignkey')
-    op.drop_constraint("sao_equipment_data_ibfk_6", 'sao_equipment_data', type_='foreignkey')
-    op.alter_column('sao_equipment_data', 'get_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=False)
-    op.alter_column('sao_equipment_data', 'equipment_id',
-               existing_type=sa.BIGINT(),
-               type_=mysql.INTEGER(),
-               existing_nullable=False)
-    op.drop_column('sao_equipment_data', 'converted_card_num')
-    op.drop_column('sao_equipment_data', 'property4_value2')
-    op.drop_column('sao_equipment_data', 'property4_value1')
-    op.drop_column('sao_equipment_data', 'property4_property_id')
-    op.drop_column('sao_equipment_data', 'property3_value2')
-    op.drop_column('sao_equipment_data', 'property3_value1')
-    op.drop_column('sao_equipment_data', 'property3_property_id')
-    op.drop_column('sao_equipment_data', 'property2_value2')
-    op.drop_column('sao_equipment_data', 'property2_value1')
-    op.drop_column('sao_equipment_data', 'property2_property_id')
-    op.drop_column('sao_equipment_data', 'property1_value2')
-    op.drop_column('sao_equipment_data', 'property1_value1')
-    op.drop_column('sao_equipment_data', 'property1_property_id')
-    op.drop_column('sao_equipment_data', 'is_protect')
-    op.drop_column('sao_equipment_data', 'is_shop_purchase')

core/data/alembic/versions/6a7e8277763b_gekichu_rating_tables.py

@@ -1,56 +0,0 @@
-"""GekiChu rating tables
-
-Revision ID: 6a7e8277763b
-Revises: d8950c7ce2fc
-Create Date: 2024-03-13 12:18:53.210018
-
-"""
-from alembic import op
-from sqlalchemy import Column, Integer, String
-
-
-# revision identifiers, used by Alembic.
-revision = '6a7e8277763b'
-down_revision = 'd8950c7ce2fc'
-branch_labels = None
-depends_on = None
-
-GEKICHU_RATING_TABLE_NAMES = [
-    "chuni_profile_rating",
-    "ongeki_profile_rating",
-]
-
-def upgrade():
-    for table_name in GEKICHU_RATING_TABLE_NAMES:
-        op.create_table(
-            table_name,
-            Column("id", Integer, primary_key=True, nullable=False),
-            Column("user", Integer, nullable=False),
-            Column("version", Integer, nullable=False),
-            Column("type", String(255), nullable=False),
-            Column("index", Integer, nullable=False),
-            Column("musicId", Integer),
-            Column("difficultId", Integer),
-            Column("romVersionCode", Integer),
-            Column("score", Integer),
-            mysql_charset="utf8mb4",
-        )
-        op.create_foreign_key(
-            None,
-            table_name,
-            "aime_user",
-            ["user"],
-            ["id"],
-            ondelete="cascade",
-            onupdate="cascade",
-        )
-        op.create_unique_constraint(
-            f"{table_name}_uk",
-            table_name,
-            ["user", "version", "type", "index"],
-        )
-
-
-def downgrade():
-    for table_name in GEKICHU_RATING_TABLE_NAMES:
-        op.drop_table(table_name)

core/data/alembic/versions/745448d83696_chuni_team_points.py

@@ -1,28 +0,0 @@
-"""chuni_team_points
-
-Revision ID: 745448d83696
-Revises: 5ea363686347
-Create Date: 2024-06-29 00:05:22.479187
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '745448d83696'
-down_revision = '5ea363686347'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('chuni_profile_team', sa.Column('userTeamPoint', sa.JSON(), nullable=True))
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('chuni_profile_team', 'userTeamPoint')
-    # ### end Alembic commands ###

core/data/alembic/versions/7dc13e364e53_cxb_add_playlog_grade.py

@@ -1,28 +0,0 @@
-"""cxb_add_playlog_grade
-
-Revision ID: 7dc13e364e53
-Revises: 2d024cf145a1
-Create Date: 2024-05-28 22:31:22.264926
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '7dc13e364e53'
-down_revision = '2d024cf145a1'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('cxb_playlog', sa.Column('grade', sa.Integer(), nullable=True))
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('cxb_playlog', 'grade')
-    # ### end Alembic commands ###

core/data/alembic/versions/81e44dd6047a_mai2_buddies_support.py

@@ -1,68 +0,0 @@
-"""mai2_buddies_support
-
-Revision ID: 81e44dd6047a
-Revises: 6a7e8277763b
-Create Date: 2024-03-12 19:10:37.063907
-
-"""
-
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = "81e44dd6047a"
-down_revision = "6a7e8277763b"
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.create_table(
-        "mai2_playlog_2p",
-        sa.Column("id", sa.Integer(), nullable=False),
-        sa.Column("user", sa.Integer(), nullable=False),
-        sa.Column("userId1", sa.Integer(), nullable=True),
-        sa.Column("userId2", sa.Integer(), nullable=True),
-        sa.Column("userName1", sa.String(length=25), nullable=True),
-        sa.Column("userName2", sa.String(length=25), nullable=True),
-        sa.Column("regionId", sa.Integer(), nullable=True),
-        sa.Column("placeId", sa.Integer(), nullable=True),
-        sa.Column("user2pPlaylogDetailList", sa.JSON(), nullable=True),
-        sa.ForeignKeyConstraint(
-            ["user"], ["aime_user.id"], onupdate="cascade", ondelete="cascade"
-        ),
-        sa.PrimaryKeyConstraint("id"),
-        mysql_charset="utf8mb4",
-    )
-
-    op.add_column(
-        "mai2_playlog",
-        sa.Column(
-            "extBool1", sa.Boolean(), nullable=True, server_default=sa.text("NULL")
-        ),
-    )
-
-    op.add_column(
-        "mai2_profile_detail",
-        sa.Column(
-            "renameCredit", sa.Integer(), nullable=True, server_default=sa.text("NULL")
-        ),
-    )
-    op.add_column(
-        "mai2_profile_detail",
-        sa.Column(
-            "currentPlayCount",
-            sa.Integer(),
-            nullable=True,
-            server_default=sa.text("NULL"),
-        ),
-    )
-
-
-def downgrade():
-    op.drop_table("mai2_playlog_2p")
-
-    op.drop_column("mai2_playlog", "extBool1")
-    op.drop_column("mai2_profile_detail", "renameCredit")
-    op.drop_column("mai2_profile_detail", "currentPlayCount")

core/data/alembic/versions/8ad40a6e7be2_ongeki_fix_clearstatus.py

@@ -1,30 +0,0 @@
-"""ongeki: fix clearStatus
-
-Revision ID: 8ad40a6e7be2
-Revises: 7dc13e364e53
-Create Date: 2024-05-29 19:03:30.062157
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '8ad40a6e7be2'
-down_revision = '7dc13e364e53'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.alter_column('ongeki_score_best', 'clearStatus',
-               existing_type=mysql.TINYINT(display_width=1),
-               type_=sa.Integer(),
-               existing_nullable=False)
-
-
-def downgrade():
-    op.alter_column('ongeki_score_best', 'clearStatus',
-               existing_type=sa.Integer(),
-               type_=mysql.TINYINT(display_width=1),
-               existing_nullable=False)

core/data/alembic/versions/91c682918b67_chuni_fix_total_scores.py

@@ -1,92 +0,0 @@
-"""chuni_fix_total_scores
-
-Revision ID: 91c682918b67
-Revises: 9c42e54a27fe
-Create Date: 2025-03-29 11:19:46.063173
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '91c682918b67'
-down_revision = '9c42e54a27fe'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('chuni_profile_data', 'totalMapNum',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalHiScore',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalBasicHighScore',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalExpertHighScore',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalMasterHighScore',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalRepertoireCount',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalAdvancedHighScore',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalUltimaHighScore',
-               existing_type=mysql.INTEGER(display_width=11),
-               type_=sa.BigInteger(),
-               existing_nullable=True,
-               existing_server_default=sa.text("'0'"))
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.alter_column('chuni_profile_data', 'totalUltimaHighScore',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True,
-               existing_server_default=sa.text("'0'"))
-    op.alter_column('chuni_profile_data', 'totalAdvancedHighScore',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalRepertoireCount',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalMasterHighScore',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalExpertHighScore',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalBasicHighScore',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalHiScore',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    op.alter_column('chuni_profile_data', 'totalMapNum',
-               existing_type=sa.BigInteger(),
-               type_=mysql.INTEGER(display_width=11),
-               existing_nullable=True)
-    # ### end Alembic commands ###

core/data/alembic/versions/9c42e54a27fe_remove_ongeki_static_music_ranking_list.py

@@ -1,40 +0,0 @@
-"""remove ongeki_static_music_ranking_list
-
-Revision ID: 9c42e54a27fe
-Revises: 41f77ef50588
-Create Date: 2025-01-06 18:24:16.306748
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = '9c42e54a27fe'
-down_revision = '41f77ef50588'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_index('ongeki_static_music_ranking_uk', table_name='ongeki_static_music_ranking_list')
-    op.drop_table('ongeki_static_music_ranking_list')
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('ongeki_static_music_ranking_list',
-    sa.Column('id', mysql.INTEGER(), autoincrement=True, nullable=False),
-    sa.Column('version', mysql.INTEGER(), autoincrement=False, nullable=False),
-    sa.Column('musicId', mysql.INTEGER(), autoincrement=False, nullable=False),
-    sa.Column('point', mysql.INTEGER(), autoincrement=False, nullable=False),
-    sa.Column('userName', mysql.VARCHAR(length=255), nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    mysql_collate='utf8mb4_0900_ai_ci',
-    mysql_default_charset='utf8mb4',
-    mysql_engine='InnoDB'
-    )
-    op.create_index('ongeki_static_music_ranking_uk', 'ongeki_static_music_ranking_list', ['version', 'musicId'], unique=True)
-    # ### end Alembic commands ###

core/data/alembic/versions/a616fd164e40_sao_backport.py

@@ -1,437 +0,0 @@
-"""sao_backport
-
-Revision ID: a616fd164e40
-Revises: 48f4acc43a7e
-Create Date: 2024-06-24 20:28:34.471282
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = 'a616fd164e40'
-down_revision = '48f4acc43a7e'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('sao_static_quest')
-    op.create_table('sao_static_quest',
-    sa.Column('QuestSceneId', sa.BIGINT(), nullable=False),
-    sa.Column('SortNo', sa.INTEGER(), nullable=False),
-    sa.Column('Tutorial', sa.BOOLEAN(), nullable=False),
-    sa.Column('ColRate', sa.DECIMAL(), nullable=False),
-    sa.Column('LimitDefault', sa.INTEGER(), nullable=False),
-    sa.Column('LimitResurrection', sa.INTEGER(), nullable=False),
-    sa.Column('RewardTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('PlayerTraceTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('SuccessPlayerExp', sa.INTEGER(), nullable=False),
-    sa.Column('FailedPlayerExp', sa.INTEGER(), nullable=False),
-    sa.Column('PairExpRate', sa.INTEGER(), nullable=False),
-    sa.Column('TrioExpRate', sa.INTEGER(), nullable=False),
-    sa.Column('SingleRewardVp', sa.INTEGER(), nullable=False),
-    sa.Column('PairRewardVp', sa.INTEGER(), nullable=False),
-    sa.Column('TrioRewardVp', sa.INTEGER(), nullable=False),
-    sa.PrimaryKeyConstraint('QuestSceneId'),
-    mysql_charset='utf8mb4'
-    )
-    
-    op.create_table('sao_static_property',
-    sa.Column('PropertyId', sa.BIGINT(), nullable=False),
-    sa.Column('PropertyTargetType', sa.INTEGER(), nullable=False),
-    sa.Column('PropertyName', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('PropertyName_en', sa.VARCHAR(length=255), nullable=True),
-    sa.Column('PropertyNameFormat', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('PropertyNameFormat_en', sa.VARCHAR(length=255), nullable=True),
-    sa.Column('PropertyTypeId', sa.INTEGER(), nullable=False),
-    sa.Column('Value1Min', sa.INTEGER(), nullable=False),
-    sa.Column('Value1Max', sa.INTEGER(), nullable=False),
-    sa.Column('Value2Min', sa.INTEGER(), nullable=False),
-    sa.Column('Value2Max', sa.INTEGER(), nullable=False),
-    sa.PrimaryKeyConstraint('PropertyId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_reward',
-    sa.Column('RewardTableId', sa.BIGINT(), nullable=False),
-    sa.Column('RewardTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('UnanalyzedLogGradeId', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardType', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardId', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardNum', sa.INTEGER(), nullable=False),
-    sa.Column('StrengthMin', sa.INTEGER(), nullable=False),
-    sa.Column('StrengthMax', sa.INTEGER(), nullable=False),
-    sa.Column('PropertyTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('QuestInfoDisplayFlag', sa.BOOLEAN(), nullable=False),
-    sa.Column('Rate', sa.INTEGER(), nullable=False),
-    sa.PrimaryKeyConstraint('RewardTableId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_skill',
-    sa.Column('SkillId', sa.BIGINT(), nullable=False),
-    sa.Column('WeaponTypeId', sa.INTEGER(), nullable=False),
-    sa.Column('Name', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('Name_en', sa.VARCHAR(length=255), nullable=True),
-    sa.Column('Attack', sa.BOOLEAN(), nullable=False),
-    sa.Column('Passive', sa.BOOLEAN(), nullable=False),
-    sa.Column('Pet', sa.BOOLEAN(), nullable=False),
-    sa.Column('Level', sa.INTEGER(), nullable=False),
-    sa.Column('SkillCondition', sa.INTEGER(), nullable=False),
-    sa.Column('CoolTime', sa.INTEGER(), nullable=False),
-    sa.Column('SkillIcon', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('FriendSkillIcon', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('InfoText', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('InfoText_en', sa.VARCHAR(length=255), nullable=True),
-    sa.PrimaryKeyConstraint('SkillId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_trace_table',
-    sa.Column('PlayerTraceTableId', sa.BIGINT(), nullable=False),
-    sa.Column('PlayerTraceTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardType', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardId', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardNum', sa.INTEGER(), nullable=False),
-    sa.Column('Rate', sa.INTEGER(), nullable=False),
-    sa.PrimaryKeyConstraint('PlayerTraceTableId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_player_beginner_mission',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('user', sa.INTEGER(), nullable=False),
-    sa.Column('beginner_mission_id', sa.INTEGER(), nullable=False),
-    sa.Column('condition_id', sa.INTEGER(), nullable=False),
-    sa.Column('is_seat', sa.BOOLEAN(), server_default='0', nullable=False),
-    sa.Column('achievement_num', sa.INTEGER(), nullable=False),
-    sa.Column('complete_flag', sa.BOOLEAN(), server_default='0', nullable=False),
-    sa.Column('complete_date', sa.TIMESTAMP(), nullable=True),
-    sa.Column('reward_received_flag', sa.BOOLEAN(), server_default='0', nullable=False),
-    sa.Column('reward_received_date', sa.TIMESTAMP(), nullable=True),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user'),
-    sa.UniqueConstraint('user', 'condition_id', name='sao_player_beginner_mission_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_player_resource_card',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('user', sa.INTEGER(), nullable=False),
-    sa.Column('common_reward_type', sa.INTEGER(), nullable=False),
-    sa.Column('common_reward_id', sa.INTEGER(), nullable=False),
-    sa.Column('holographic_flag', sa.BOOLEAN(), server_default='0', nullable=False),
-    sa.Column('serial', sa.VARCHAR(length=20), nullable=True),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('serial'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_player_tutorial',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('user', sa.INTEGER(), nullable=False),
-    sa.Column('tutorial_byte', sa.INTEGER(), nullable=False),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user', 'tutorial_byte', name='sao_player_tutorial_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_episode',
-    sa.Column('EpisodeId', sa.BIGINT(), nullable=False),
-    sa.Column('EpisodeChapterId', sa.INTEGER(), nullable=False),
-    sa.Column('ReleaseEpisodeId', sa.INTEGER(), nullable=False),
-    sa.Column('Title', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('CommentSummary', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('ExBonusTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('QuestSceneId', sa.BIGINT(), nullable=True),
-    sa.ForeignKeyConstraint(['QuestSceneId'], ['sao_static_quest.QuestSceneId'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('EpisodeId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_ex_bonus',
-    sa.Column('ExBonusTableId', sa.BIGINT(), nullable=False),
-    sa.Column('ExBonusTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('ExBonusConditionId', sa.INTEGER(), nullable=False),
-    sa.Column('ConditionValue1', sa.INTEGER(), nullable=False),
-    sa.Column('ConditionValue2', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardType', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardId', sa.INTEGER(), nullable=False),
-    sa.Column('CommonRewardNum', sa.INTEGER(), nullable=False),
-    sa.Column('Strength', sa.INTEGER(), nullable=False),
-    sa.Column('Property1PropertyId', sa.BIGINT(), nullable=False),
-    sa.Column('Property1Value1', sa.INTEGER(), nullable=False),
-    sa.Column('Property1Value2', sa.INTEGER(), nullable=False),
-    sa.Column('Property2PropertyId', sa.BIGINT(), nullable=False),
-    sa.Column('Property2Value1', sa.INTEGER(), nullable=False),
-    sa.Column('Property2Value2', sa.INTEGER(), nullable=False),
-    sa.Column('Property3PropertyId', sa.BIGINT(), nullable=False),
-    sa.Column('Property3Value1', sa.INTEGER(), nullable=False),
-    sa.Column('Property3Value2', sa.INTEGER(), nullable=False),
-    sa.Column('Property4PropertyId', sa.BIGINT(), nullable=False),
-    sa.Column('Property4Value1', sa.INTEGER(), nullable=False),
-    sa.Column('Property4Value2', sa.INTEGER(), nullable=False),
-    sa.ForeignKeyConstraint(['Property1PropertyId'], ['sao_static_property.PropertyId'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['Property2PropertyId'], ['sao_static_property.PropertyId'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['Property3PropertyId'], ['sao_static_property.PropertyId'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['Property4PropertyId'], ['sao_static_property.PropertyId'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('ExBonusTableId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_ex_tower',
-    sa.Column('ExTowerQuestId', sa.BIGINT(), nullable=False),
-    sa.Column('ExTowerId', sa.INTEGER(), nullable=False),
-    sa.Column('ReleaseExTowerQuestId', sa.INTEGER(), nullable=False),
-    sa.Column('Title', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('Title_en', sa.VARCHAR(length=255), nullable=True),
-    sa.Column('ExBonusTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('QuestSceneId', sa.BIGINT(), nullable=False),
-    sa.ForeignKeyConstraint(['QuestSceneId'], ['sao_static_quest.QuestSceneId'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('ExTowerQuestId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_side_quest',
-    sa.Column('SideQuestId', sa.BIGINT(), nullable=False),
-    sa.Column('DisplayName', sa.VARCHAR(length=255), nullable=False),
-    sa.Column('DisplayName_en', sa.VARCHAR(length=255), nullable=True),
-    sa.Column('EpisodeNum', sa.INTEGER(), nullable=False),
-    sa.Column('ExBonusTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('QuestSceneId', sa.BIGINT(), nullable=False),
-    sa.ForeignKeyConstraint(['QuestSceneId'], ['sao_static_quest.QuestSceneId'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('SideQuestId'),
-    sa.UniqueConstraint('SideQuestId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_skill_table',
-    sa.Column('SkillTableId', sa.BIGINT(), nullable=False),
-    sa.Column('SkillId', sa.BIGINT(), nullable=False),
-    sa.Column('SkillTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('LevelObtained', sa.INTEGER(), nullable=False),
-    sa.Column('AwakeningId', sa.INTEGER(), nullable=False),
-    sa.ForeignKeyConstraint(['SkillId'], ['sao_static_skill.SkillId'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('SkillTableId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_static_tower',
-    sa.Column('TowerId', sa.BIGINT(), nullable=False),
-    sa.Column('ReleaseTowerId', sa.INTEGER(), nullable=False),
-    sa.Column('ExBonusTableSubId', sa.INTEGER(), nullable=False),
-    sa.Column('QuestSceneId', sa.BIGINT(), nullable=False),
-    sa.ForeignKeyConstraint(['QuestSceneId'], ['sao_static_quest.QuestSceneId'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('TowerId'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_player_ex_bonus',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('user', sa.INTEGER(), nullable=False),
-    sa.Column('quest_scene_id', sa.BIGINT(), nullable=False),
-    sa.Column('ex_bonus_table_id', sa.BIGINT(), nullable=False),
-    sa.Column('quest_clear_flag', sa.BOOLEAN(), server_default='0', nullable=False),
-    sa.ForeignKeyConstraint(['ex_bonus_table_id'], ['sao_static_ex_bonus.ExBonusTableId'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['quest_scene_id'], ['sao_static_quest.QuestSceneId'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user', 'quest_scene_id', 'ex_bonus_table_id', name='sao_player_ex_bonus_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.create_table('sao_player_hero_card',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('user', sa.INTEGER(), nullable=False),
-    sa.Column('user_hero_id', sa.INTEGER(), nullable=False),
-    sa.Column('holographic_flag', sa.BOOLEAN(), server_default='0', nullable=False),
-    sa.Column('serial', sa.VARCHAR(length=20), nullable=True),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.ForeignKeyConstraint(['user_hero_id'], ['sao_hero_log_data.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('serial'),
-    mysql_charset='utf8mb4'
-    )
-    op.alter_column('sao_end_sessions', 'play_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('now()'),
-               existing_nullable=False)
-    
-    op.drop_table('sao_static_equipment_list')
-    op.create_table("sao_static_equipment_list",
-    sa.Column("EquipmentId", sa.BIGINT, primary_key=True, nullable=False),
-    sa.Column("EquipmentType", sa.INTEGER, nullable=False),
-    sa.Column("WeaponTypeId", sa.INTEGER, nullable=False),
-    sa.Column("Name", sa.VARCHAR(255), nullable=False),
-    sa.Column("Name_en", sa.VARCHAR(255)),
-    sa.Column("Rarity", sa.INTEGER, nullable=False),
-    sa.Column("Power", sa.INTEGER, nullable=False),
-    sa.Column("StrengthIncrement", sa.INTEGER, nullable=False),
-    sa.Column("SkillCondition", sa.INTEGER, nullable=False),
-    sa.Column("Property1PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property1Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property1Value2", sa.INTEGER, nullable=False),
-    sa.Column("Property2PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property2Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property2Value2", sa.INTEGER, nullable=False),
-    sa.Column("Property3PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property3Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property3Value2", sa.INTEGER, nullable=False),
-    sa.Column("Property4PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property4Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property4Value2", sa.INTEGER, nullable=False),
-    sa.Column("SalePrice", sa.INTEGER, nullable=False),
-    sa.Column("CompositionExp", sa.INTEGER, nullable=False),
-    sa.Column("AwakeningExp", sa.INTEGER, nullable=False),
-    sa.Column("FlavorText", sa.VARCHAR(255), nullable=False),
-    sa.Column("FlavorText_en", sa.VARCHAR(255)),
-    mysql_charset="utf8mb4"
-   )
-    
-    op.drop_table('sao_static_hero_list')
-    op.create_table("sao_static_hero_list",
-    sa.Column("HeroLogId", sa.BIGINT, primary_key=True, nullable=False),
-    sa.Column("CharaId", sa.INTEGER, nullable=False),
-    sa.Column("Name", sa.VARCHAR(255), nullable=False),
-    sa.Column("Nickname", sa.VARCHAR(255), nullable=False),
-    sa.Column("Name_en", sa.VARCHAR(255)),
-    sa.Column("Nickname_en", sa.VARCHAR(255)),
-    sa.Column("Rarity", sa.INTEGER, nullable=False),
-    sa.Column("WeaponTypeId", sa.INTEGER, nullable=False),
-    sa.Column("HeroLogRoleId", sa.INTEGER, nullable=False),
-    sa.Column("CostumeTypeId", sa.INTEGER, nullable=False),
-    sa.Column("UnitId", sa.INTEGER, nullable=False),
-    sa.Column("DefaultEquipmentId1", sa.BIGINT, sa.ForeignKey("sao_static_equipment_list.EquipmentId", ondelete="cascade", onupdate="cascade")),
-    sa.Column("DefaultEquipmentId2", sa.BIGINT, sa.ForeignKey("sao_static_equipment_list.EquipmentId", ondelete="cascade", onupdate="cascade")),
-    sa.Column("SkillTableSubId", sa.INTEGER, nullable=False),
-    sa.Column("HpMin", sa.INTEGER, nullable=False),
-    sa.Column("HpMax", sa.INTEGER, nullable=False),
-    sa.Column("StrMin", sa.INTEGER, nullable=False),
-    sa.Column("StrMax", sa.INTEGER, nullable=False),
-    sa.Column("VitMin", sa.INTEGER, nullable=False),
-    sa.Column("VitMax", sa.INTEGER, nullable=False),
-    sa.Column("IntMin", sa.INTEGER, nullable=False),
-    sa.Column("IntMax", sa.INTEGER, nullable=False),
-    sa.Column("Property1PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property1Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property1Value2", sa.INTEGER, nullable=False),
-    sa.Column("Property2PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property2Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property2Value2", sa.INTEGER, nullable=False),
-    sa.Column("Property3PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property3Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property3Value2", sa.INTEGER, nullable=False),
-    sa.Column("Property4PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-    sa.Column("Property4Value1", sa.INTEGER, nullable=False),
-    sa.Column("Property4Value2", sa.INTEGER, nullable=False),
-    sa.Column("FlavorText", sa.VARCHAR(255), nullable=False),
-    sa.Column("FlavorText_en", sa.VARCHAR(255)),
-    sa.Column("SalePrice", sa.INTEGER, nullable=False),
-    sa.Column("CompositionExp", sa.INTEGER, nullable=False),
-    sa.Column("AwakeningExp", sa.INTEGER, nullable=False),
-    sa.Column("Slot4UnlockLevel", sa.INTEGER, nullable=False),
-    sa.Column("Slot5UnlockLevel", sa.INTEGER, nullable=False),
-    sa.Column("CollectionEmptyFrameDisplayFlag", sa.BOOLEAN, nullable=False),
-    mysql_charset="utf8mb4"
-    )
-
-    op.drop_table('sao_static_item_list')
-    op.create_table("sao_static_item_list",
-        sa.Column("ItemId", sa.INTEGER, nullable=False, primary_key=True),
-        sa.Column("ItemTypeId", sa.INTEGER, nullable=False),
-        sa.Column("Name", sa.VARCHAR(255), nullable=False),
-        sa.Column("Name_en", sa.VARCHAR(255)),
-        sa.Column("Rarity", sa.INTEGER, nullable=False),
-        sa.Column("Value", sa.INTEGER, nullable=False),
-        sa.Column("PropertyId", sa.BIGINT, sa.ForeignKey("sao_static_property.PropertyId", ondelete="cascade", onupdate="cascade"), nullable=False),
-        sa.Column("PropertyValue1Min", sa.INTEGER, nullable=False),
-        sa.Column("PropertyValue1Max", sa.INTEGER, nullable=False),
-        sa.Column("PropertyValue2Min", sa.INTEGER, nullable=False),
-        sa.Column("PropertyValue2Max", sa.INTEGER, nullable=False),
-        sa.Column("FlavorText", sa.VARCHAR(255), nullable=False),
-        sa.Column("FlavorText_en", sa.VARCHAR(255)),
-        sa.Column("SalePrice", sa.INTEGER, nullable=False),
-        sa.Column("ItemIcon", sa.VARCHAR(255), nullable=False),
-        mysql_charset="utf8mb4"
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('sao_static_item_list')
-    op.create_table("sao_static_item_list",
-    sa.Column("id", sa.Integer, primary_key=True, nullable=False),
-    sa.Column("version", sa.Integer),
-    sa.Column("itemId", sa.Integer),
-    sa.Column("itemTypeId", sa.Integer),
-    sa.Column("name", sa.String(255)),
-    sa.Column("rarity", sa.Integer),
-    sa.Column("flavorText", sa.String(255)),
-    sa.Column("enabled", sa.Boolean),
-    sa.UniqueConstraint(
-        "version", "itemId", name="sao_static_item_list_uk"
-    ),
-    mysql_charset="utf8mb4"
-    )
-
-    op.drop_table('sao_static_hero_list')
-    op.create_table("sao_static_hero_list",
-    sa.Column("id", sa.Integer, primary_key=True, nullable=False),
-    sa.Column("version", sa.Integer),
-    sa.Column("heroLogId", sa.Integer),
-    sa.Column("name", sa.String(255)),
-    sa.Column("nickname", sa.String(255)),
-    sa.Column("rarity", sa.Integer),
-    sa.Column("skillTableSubId", sa.Integer),
-    sa.Column("awakeningExp", sa.Integer),
-    sa.Column("flavorText", sa.String(255)),
-    sa.Column("enabled", sa.Boolean),
-    sa.UniqueConstraint(
-        "version", "heroLogId", name="sao_static_hero_list_uk"
-    ),
-    mysql_charset="utf8mb4",
-    )
-
-    op.drop_table('sao_static_equipment_list')
-    op.create_table("sao_static_equipment_list",
-    sa.Column("id", sa.Integer, primary_key=True, nullable=False),
-    sa.Column("version", sa.Integer),
-    sa.Column("equipmentId", sa.Integer),
-    sa.Column("equipmentType", sa.Integer),
-    sa.Column("weaponTypeId", sa.Integer),
-    sa.Column("name", sa.String(255)),
-    sa.Column("rarity", sa.Integer),
-    sa.Column("flavorText", sa.String(255)),
-    sa.Column("enabled", sa.Boolean),
-    sa.UniqueConstraint(
-        "version", "equipmentId", name="sao_static_equipment_list_uk"
-    ),
-    mysql_charset="utf8mb4"
-
-   )
-
-    op.alter_column('sao_end_sessions', 'play_date',
-               existing_type=mysql.TIMESTAMP(),
-               server_default=sa.text('CURRENT_TIMESTAMP'),
-               existing_nullable=False)
-    op.drop_table('sao_player_hero_card')
-    op.drop_table('sao_player_ex_bonus')
-    op.drop_table('sao_static_tower')
-    op.drop_table('sao_static_skill_table')
-    op.drop_table('sao_static_side_quest')
-    op.drop_table('sao_static_ex_tower')
-    op.drop_table('sao_static_ex_bonus')
-    op.drop_table('sao_static_episode')
-    op.drop_table('sao_player_tutorial')
-    op.drop_table('sao_player_resource_card')
-    op.drop_table('sao_player_beginner_mission')
-    op.drop_table('sao_static_trace_table')
-    op.drop_table('sao_static_skill')
-    op.drop_table('sao_static_reward')
-    op.drop_table('sao_static_property')
-    op.drop_table('sao_static_quest')
-    op.create_table('sao_static_quest',
-    sa.Column('id', mysql.INTEGER(), autoincrement=True, nullable=False),
-    sa.Column('enabled', mysql.TINYINT(display_width=1), autoincrement=False, nullable=True),
-    sa.Column('version', mysql.INTEGER(), autoincrement=False, nullable=True),
-    sa.Column('questSceneId', mysql.INTEGER(), autoincrement=False, nullable=True),
-    sa.Column('sortNo', mysql.INTEGER(), autoincrement=False, nullable=True),
-    sa.Column('name', mysql.VARCHAR(charset='utf8mb4', collation='utf8mb4_general_ci', length=255), nullable=True),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint("version", "questSceneId", name="sao_static_quest_uk"),
-    mysql_charset='utf8mb4'
-    )
-    # ### end Alembic commands ###

core/data/alembic/versions/ae364c078429_chuni_nameplate_add_opt.py

@@ -1,30 +0,0 @@
-"""chuni_nameplate_add_opt
-
-Revision ID: ae364c078429
-Revises: 5cf98cfe52ad
-Create Date: 2025-04-08 00:22:22.370660
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = 'ae364c078429'
-down_revision = '5cf98cfe52ad'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.add_column('chuni_static_nameplate', sa.Column('opt', sa.BIGINT(), nullable=True))
-    op.create_foreign_key(None, 'chuni_static_nameplate', 'chuni_static_opt', ['opt'], ['id'], onupdate='cascade', ondelete='SET NULL')
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint("chuni_static_nameplate_ibfk_1", 'chuni_static_nameplate', type_='foreignkey')
-    op.drop_column('chuni_static_nameplate', 'opt')
-    # ### end Alembic commands ###

core/data/alembic/versions/b23f985100ba_chunithm_luminous.py

@@ -1,87 +0,0 @@
-"""CHUNITHM LUMINOUS
-
-Revision ID: b23f985100ba
-Revises: 3657efefc5a4
-Create Date: 2024-06-20 08:08:08.759261
-
-"""
-from alembic import op
-from sqlalchemy import Column, Integer, Boolean, UniqueConstraint
-
-
-# revision identifiers, used by Alembic.
-revision = 'b23f985100ba'
-down_revision = '3657efefc5a4'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.create_table(
-        "chuni_profile_net_battle",
-        Column("id", Integer, primary_key=True, nullable=False),
-        Column("user", Integer, nullable=False),
-        Column("isRankUpChallengeFailed", Boolean),
-        Column("highestBattleRankId", Integer),
-        Column("battleIconId", Integer),
-        Column("battleIconNum", Integer),
-        Column("avatarEffectPoint", Integer),
-        mysql_charset="utf8mb4",
-    )
-    op.create_foreign_key(
-        None,
-        "chuni_profile_net_battle",
-        "aime_user",
-        ["user"],
-        ["id"],
-        ondelete="cascade",
-        onupdate="cascade",
-    )
-
-    op.create_table(
-        "chuni_item_cmission",
-        Column("id", Integer, primary_key=True, nullable=False),
-        Column("user", Integer, nullable=False),
-        Column("missionId", Integer, nullable=False),
-        Column("point", Integer),
-        UniqueConstraint("user", "missionId", name="chuni_item_cmission_uk"),
-        mysql_charset="utf8mb4",
-    )
-    op.create_foreign_key(
-        None,
-        "chuni_item_cmission",
-        "aime_user",
-        ["user"],
-        ["id"],
-        ondelete="cascade",
-        onupdate="cascade",
-    )
-
-    op.create_table(
-        "chuni_item_cmission_progress",
-        Column("id", Integer, primary_key=True, nullable=False),
-        Column("user", Integer, nullable=False),
-        Column("missionId", Integer, nullable=False),
-        Column("order", Integer),
-        Column("stage", Integer),
-        Column("progress", Integer),
-        UniqueConstraint(
-            "user", "missionId", "order", name="chuni_item_cmission_progress_uk"
-        ),
-        mysql_charset="utf8mb4",
-    )
-    op.create_foreign_key(
-        None,
-        "chuni_item_cmission_progress",
-        "aime_user",
-        ["user"],
-        ["id"],
-        ondelete="cascade",
-        onupdate="cascade",
-    )
-
-
-def downgrade():
-    op.drop_table("chuni_profile_net_battle")
-    op.drop_table("chuni_item_cmission")
-    op.drop_table("chuni_item_cmission_progress")

core/data/alembic/versions/bc91c1206dca_mai2_favorite_song_ordering.py

@@ -1,24 +0,0 @@
-"""mai2_favorite_song_ordering
-
-Revision ID: bc91c1206dca
-Revises: 28443e2da5b8
-Create Date: 2024-09-16 14:24:56.714066
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'bc91c1206dca'
-down_revision = '28443e2da5b8'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    op.add_column('mai2_item_favorite_music', sa.Column('orderId', sa.Integer(), nullable=True))
-
-
-def downgrade():
-    op.drop_column('mai2_item_favorite_music', 'orderId')

core/data/alembic/versions/d8cd1fa04c2a_mai2_add_photos.py

@@ -1,38 +0,0 @@
-"""mai2_add_photos
-
-Revision ID: d8cd1fa04c2a
-Revises: 54a84103b84e
-Create Date: 2024-10-06 03:09:15.959817
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = 'd8cd1fa04c2a'
-down_revision = '54a84103b84e'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('mai2_user_photo',
-    sa.Column('id', sa.VARCHAR(length=36), nullable=False),
-    sa.Column('user', sa.Integer(), nullable=False),
-    sa.Column('playlog_num', sa.INTEGER(), nullable=False),
-    sa.Column('track_num', sa.INTEGER(), nullable=False),
-    sa.Column('when_upload', sa.TIMESTAMP(), server_default=sa.text('now()'), nullable=False),
-    sa.ForeignKeyConstraint(['user'], ['aime_user.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('user', 'playlog_num', 'track_num', name='mai2_user_photo_uk'),
-    mysql_charset='utf8mb4'
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('mai2_user_photo')
-    # ### end Alembic commands ###

core/data/alembic/versions/f6007bbf057d_add_billing_playcount.py

@@ -1,50 +0,0 @@
-"""add_billing_playcount
-
-Revision ID: f6007bbf057d
-Revises: 27e3434740df
-Create Date: 2025-04-19 18:20:35.554137
-
-"""
-from alembic import op
-import sqlalchemy as sa
-from sqlalchemy.dialects import mysql
-
-# revision identifiers, used by Alembic.
-revision = 'f6007bbf057d'
-down_revision = '27e3434740df'
-branch_labels = None
-depends_on = None
-
-
-def upgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table('machine_billing_playcount',
-    sa.Column('id', sa.BIGINT(), nullable=False),
-    sa.Column('machine', sa.Integer(), nullable=False),
-    sa.Column('game_id', sa.CHAR(length=5), nullable=False),
-    sa.Column('year', sa.INTEGER(), nullable=False),
-    sa.Column('month', sa.INTEGER(), nullable=False),
-    sa.Column('playct', sa.BIGINT(), server_default='1', nullable=False),
-    sa.ForeignKeyConstraint(['machine'], ['machine.id'], onupdate='cascade', ondelete='cascade'),
-    sa.PrimaryKeyConstraint('id'),
-    sa.UniqueConstraint('machine'),
-    sa.UniqueConstraint('machine', 'game_id', 'year', 'month', name='machine_billing_playcount_uk'),
-    mysql_charset='utf8mb4'
-    )
-    op.add_column('machine_billing_credit', sa.Column('game_id', sa.CHAR(length=5), nullable=False))
-    op.drop_constraint("machine_billing_credit_ibfk_1", "machine_billing_credit", "foreignkey")
-    op.drop_index('machine', table_name='machine_billing_credit')
-    op.create_unique_constraint('machine_billing_credit_uk', 'machine_billing_credit', ['machine', 'game_id'])
-    op.create_foreign_key("machine_billing_credit_ibfk_1", "machine_billing_credit", "machine", ["machine"], ["id"], onupdate='cascade', ondelete='cascade')
-    # ### end Alembic commands ###
-
-
-def downgrade():
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_constraint("machine_billing_credit_ibfk_1", "machine_billing_credit", "foreignkey")
-    op.drop_constraint('machine_billing_credit_uk', 'machine_billing_credit', type_='unique')
-    op.create_index('machine', 'machine_billing_credit', ['machine'], unique=True)
-    op.create_foreign_key("machine_billing_credit_ibfk_1", "machine_billing_credit", "machine", ["machine"], ["id"], onupdate='cascade', ondelete='cascade')
-    op.drop_column('machine_billing_credit', 'game_id')
-    op.drop_table('machine_billing_playcount')
-    # ### end Alembic commands ###

core/data/database.py

@@ -1,70 +1,54 @@
-import logging
-import os
-import secrets
-import string
-import warnings
-from hashlib import sha256
+import logging, coloredlogs
+from typing import Optional
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy import create_engine
 from logging.handlers import TimedRotatingFileHandler
-from typing import ClassVar, Optional
-
-import alembic.config
+import os
+import secrets, string
 import bcrypt
-import coloredlogs
-import pymysql.err
-from sqlalchemy.ext.asyncio import (
-    AsyncEngine,
-    AsyncSession,
-    create_async_engine,
-)
-from sqlalchemy.orm import sessionmaker
+from hashlib import sha256
+import alembic.config
+import glob
 
 from core.config import CoreConfig
-from core.data.schema import ArcadeData, BaseData, CardData, UserData, metadata
-from core.utils import MISSING, Utils
+from core.data.schema import *
+from core.utils import Utils
 
 
 class Data:
-    engine: ClassVar[AsyncEngine] = MISSING
-    session: ClassVar["sessionmaker[AsyncSession]"] = MISSING
-    user: ClassVar[UserData] = MISSING
-    arcade: ClassVar[ArcadeData] = MISSING
-    card: ClassVar[CardData] = MISSING
-    base: ClassVar[BaseData] = MISSING
-
+    engine = None
+    session = None
+    user = None
+    arcade = None
+    card = None
+    base = None
     def __init__(self, cfg: CoreConfig) -> None:
         self.config = cfg
 
         if self.config.database.sha2_password:
             passwd = sha256(self.config.database.password.encode()).digest()
-            self.__url = f"{self.config.database.protocol}+aiomysql://{self.config.database.username}:{passwd.hex()}@{self.config.database.host}:{self.config.database.port}/{self.config.database.name}"
+            self.__url = f"{self.config.database.protocol}://{self.config.database.username}:{passwd.hex()}@{self.config.database.host}:{self.config.database.port}/{self.config.database.name}?charset=utf8mb4"
         else:
-            self.__url = f"{self.config.database.protocol}+aiomysql://{self.config.database.username}:{self.config.database.password}@{self.config.database.host}:{self.config.database.port}/{self.config.database.name}"
+            self.__url = f"{self.config.database.protocol}://{self.config.database.username}:{self.config.database.password}@{self.config.database.host}:{self.config.database.port}/{self.config.database.name}?charset=utf8mb4"
 
-        if Data.engine is MISSING:
-            Data.engine = create_async_engine(
-                self.__url,
-                pool_recycle=3600,
-                isolation_level="AUTOCOMMIT",
-                connect_args={
-                    "charset": "utf8mb4",
-                    "ssl": self.config.database.create_ssl_context_if_enabled(),
-                },
-            )
+        if Data.engine is None:
+            Data.engine = create_engine(self.__url, pool_recycle=3600)
             self.__engine = Data.engine
 
-        if Data.session is MISSING:
-            Data.session = sessionmaker(Data.engine, expire_on_commit=False, class_=AsyncSession)
+        if Data.session is None:
+            s = sessionmaker(bind=Data.engine, autoflush=True, autocommit=True)
+            Data.session = scoped_session(s)
 
-        if Data.user is MISSING:
+        if Data.user is None:
             Data.user = UserData(self.config, self.session)
         
-        if Data.arcade is MISSING:
+        if Data.arcade is None:
             Data.arcade = ArcadeData(self.config, self.session)
         
-        if Data.card is MISSING:
+        if Data.card is None:
             Data.card = CardData(self.config, self.session)
         
-        if Data.base is MISSING:
+        if Data.base is None:
             Data.base = BaseData(self.config, self.session)
 
         self.logger = logging.getLogger("database")
@@ -110,79 +94,40 @@ class Data:
         alembic.config.main(argv=alembicArgs)
         os.chdir(old_dir)
 
-    async def create_database(self):
+    def create_database(self):
         self.logger.info("Creating databases...")
+        metadata.create_all(
+            self.engine,
+            checkfirst=True,
+        )
 
-        with warnings.catch_warnings():
-            # SQLAlchemy will generate a nice primary key constraint name, but in
-            # MySQL/MariaDB the constraint name is always PRIMARY. Every time a
-            # custom primary key name is generated, a warning is emitted from pymysql,
-            # which we don't care about. Other warnings may be helpful though, don't
-            # suppress everything.            
-            warnings.filterwarnings(
-                action="ignore",
-                message=r"Name '(.+)' ignored for PRIMARY key\.",
-                category=pymysql.err.Warning,
-            )
+        for _, mod in Utils.get_all_titles().items():
+            if hasattr(mod, "database"):
+                mod.database(self.config)
+                metadata.create_all(
+                    self.engine,
+                    checkfirst=True,
+                )
 
-            async with self.engine.begin() as conn:
-                await conn.run_sync(metadata.create_all, checkfirst=True)
+        # Stamp the end revision as if alembic had created it, so it can take off after this.
+        self.__alembic_cmd(
+            "stamp",
+            "head",
+        )
 
-                for _, mod in Utils.get_all_titles().items():
-                    if hasattr(mod, "database"):
-                        mod.database(self.config)
+    def schema_upgrade(self, ver: str = None):
+        self.__alembic_cmd(
+            "upgrade",
+            "head",
+        )
 
-                        await conn.run_sync(metadata.create_all, checkfirst=True)
-
-            # Stamp the end revision as if alembic had created it, so it can take off after this.
-            self.__alembic_cmd(
-                "stamp",
-                "head",
-            )
-
-    def schema_upgrade(self, ver: Optional[str] = None):
-        with warnings.catch_warnings():
-            # SQLAlchemy will generate a nice primary key constraint name, but in
-            # MySQL/MariaDB the constraint name is always PRIMARY. Every time a
-            # custom primary key name is generated, a warning is emitted from pymysql,
-            # which we don't care about. Other warnings may be helpful though, don't
-            # suppress everything.            
-            warnings.filterwarnings(
-                action="ignore",
-                message=r"Name '(.+)' ignored for PRIMARY key\.",
-                category=pymysql.err.Warning,
-            )
-
-            self.__alembic_cmd(
-                "upgrade",
-                "head" if not ver else ver,
-            )
-
-    def schema_downgrade(self, ver: str):
-        with warnings.catch_warnings():
-            # SQLAlchemy will generate a nice primary key constraint name, but in
-            # MySQL/MariaDB the constraint name is always PRIMARY. Every time a
-            # custom primary key name is generated, a warning is emitted from pymysql,
-            # which we don't care about. Other warnings may be helpful though, don't
-            # suppress everything.            
-            warnings.filterwarnings(
-                action="ignore",
-                message=r"Name '(.+)' ignored for PRIMARY key\.",
-                category=pymysql.err.Warning,
-            )
-
-            self.__alembic_cmd(
-                "downgrade",
-                ver,
-            )
-
-    async def create_owner(self, email: Optional[str] = None, code: str = "00000000000000000000") -> None:
+    async def create_owner(self, email: Optional[str] = None, code: Optional[str] = "00000000000000000000") -> None:
         pw = "".join(
             secrets.choice(string.ascii_letters + string.digits) for i in range(20)
         )
         hash = bcrypt.hashpw(pw.encode(), bcrypt.gensalt())
 
-        user_id = await self.user.create_user(username="sysowner", email=email, password=hash.decode(), permission=255)
+        user_id = await self.user.create_user("sysowner", email, hash.decode(), 255)
         if user_id is None:
             self.logger.error(f"Failed to create owner with email {email}")
             return
@@ -199,12 +144,12 @@ class Data:
     async def migrate(self) -> None:
         exist = await self.base.execute("SELECT * FROM alembic_version")
         if exist is not None:
-            self.logger.warning("No need to migrate as you have already migrated to alembic. If you are trying to upgrade the schema, use `upgrade` instead!")
+            self.logger.warn("No need to migrate as you have already migrated to alembic. If you are trying to upgrade the schema, use `upgrade` instead!")
             return
         
         self.logger.info("Upgrading to latest with legacy system")
         if not await self.legacy_upgrade():
-            self.logger.warning("No need to migrate as you have already deleted the old schema_versions system. If you are trying to upgrade the schema, use `upgrade` instead!")
+            self.logger.warn("No need to migrate as you have already deleted the old schema_versions system. If you are trying to upgrade the schema, use `upgrade` instead!")
             return
         self.logger.info("Done")
         
@@ -223,7 +168,7 @@ class Data:
     async def legacy_upgrade(self) -> bool:
         vers = await self.base.execute("SELECT * FROM schema_versions")
         if vers is None:
-            self.logger.warning("Cannot legacy upgrade, schema_versions table unavailable!")
+            self.logger.warn("Cannot legacy upgrade, schema_versions table unavailable!")
             return False
         
         db_vers = {}
@@ -252,7 +197,7 @@ class Data:
             game_codes = getattr(mod, "game_codes", [])
             for game in game_codes:
                 if game not in db_vers:
-                    self.logger.warning(f"{game} does not have an antry in schema_versions, skipping")
+                    self.logger.warn(f"{game} does not have an antry in schema_versions, skipping")
                     continue
 
                 now_ver = int(db_vers[game]) + 1
@@ -284,19 +229,3 @@ class Data:
             "-m",
             message,
         )
-
-    async def create_revision_auto(self, message: str) -> None:
-        if not message:
-            self.logger.info("Message is required for create-revision")
-            return
-        
-        for _, mod in Utils.get_all_titles().items():
-            if hasattr(mod, "database"):
-                mod.database(self.config)
-        
-        self.__alembic_cmd(
-            "revision",
-            "--autogenerate",
-            "-m",
-            message,
-        )

core/data/schema/arcade.py

@@ -1,17 +1,16 @@
-import re
-from typing import List, Optional
-from datetime import datetime
-
-from sqlalchemy import Column, Table, and_, or_, UniqueConstraint
+from typing import Optional, Dict, List
+from sqlalchemy import Table, Column, and_, or_
+from sqlalchemy.sql.schema import ForeignKey, PrimaryKeyConstraint
+from sqlalchemy.types import Integer, String, Boolean, JSON
+from sqlalchemy.sql import func, select
 from sqlalchemy.dialects.mysql import insert
 from sqlalchemy.engine import Row
-from sqlalchemy.sql import func, select
-from sqlalchemy.sql.schema import ForeignKey, PrimaryKeyConstraint
-from sqlalchemy.types import JSON, Boolean, Integer, String, BIGINT, INTEGER, CHAR, FLOAT
+import re
 
 from core.data.schema.base import BaseData, metadata
+from core.const import *
 
-arcade: Table = Table(
+arcade = Table(
     "arcade",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
@@ -27,7 +26,7 @@ arcade: Table = Table(
     mysql_charset="utf8mb4",
 )
 
-machine: Table = Table(
+machine = Table(
     "machine",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
@@ -48,7 +47,7 @@ machine: Table = Table(
     mysql_charset="utf8mb4",
 )
 
-arcade_owner: Table = Table(
+arcade_owner = Table(
     "arcade_owner",
     metadata,
     Column(
@@ -68,79 +67,9 @@ arcade_owner: Table = Table(
     mysql_charset="utf8mb4",
 )
 
-billing_charge: Table = Table(
-    "machine_billing_charge",
-    metadata,
-    Column("id", BIGINT, primary_key=True, nullable=False),
-    Column(
-        "machine",
-        Integer,
-        ForeignKey("machine.id", ondelete="cascade", onupdate="cascade"),
-        nullable=False,
-    ),
-    Column("game_id", CHAR(5), nullable=False),
-    Column("game_ver", FLOAT, nullable=False),
-    Column("play_count", INTEGER, nullable=False),
-    Column("play_limit", INTEGER, nullable=False),
-    Column("product_code", INTEGER, nullable=False),
-    Column("product_count", INTEGER, nullable=False),
-    Column("func_type", INTEGER, nullable=False),
-    Column("player_number", INTEGER, nullable=False),
-    mysql_charset="utf8mb4",
-)
-
-# These settings are only really of interest
-# for real cabinets operating as pay-to-play
-billing_credit: Table = Table(
-    "machine_billing_credit",
-    metadata,
-    Column("id", BIGINT, primary_key=True, nullable=False),
-    Column(
-        "machine",
-        Integer,
-        ForeignKey("machine.id", ondelete="cascade", onupdate="cascade"),
-        nullable=False
-    ),
-    Column("game_id", CHAR(5), nullable=False),
-    Column("chute_type", INTEGER, nullable=False),
-    Column("service_type", INTEGER, nullable=False),
-    Column("operation_type", INTEGER, nullable=False),
-    Column("coin_rate0", INTEGER, nullable=False),
-    Column("coin_rate1", INTEGER, nullable=False),
-    Column("coin_bonus", INTEGER, nullable=False),
-    Column("credit_rate", INTEGER, nullable=False),
-    Column("coin_count_slot0", INTEGER, nullable=False),
-    Column("coin_count_slot1", INTEGER, nullable=False),
-    Column("coin_count_slot2", INTEGER, nullable=False),
-    Column("coin_count_slot3", INTEGER, nullable=False),
-    Column("coin_count_slot4", INTEGER, nullable=False),
-    Column("coin_count_slot5", INTEGER, nullable=False),
-    Column("coin_count_slot6", INTEGER, nullable=False),
-    Column("coin_count_slot7", INTEGER, nullable=False),
-    UniqueConstraint("machine", "game_id", name="machine_billing_credit_uk"),
-    mysql_charset="utf8mb4",
-)
-
-billing_playct: Table = Table(
-    "machine_billing_playcount",
-    metadata,
-    Column("id", BIGINT, primary_key=True, nullable=False),
-    Column(
-        "machine",
-        Integer,
-        ForeignKey("machine.id", ondelete="cascade", onupdate="cascade"),
-        nullable=False, unique=True
-    ),
-    Column("game_id", CHAR(5), nullable=False),
-    Column("year", INTEGER, nullable=False),
-    Column("month", INTEGER, nullable=False),
-    Column("playct", BIGINT, nullable=False, server_default="1"),
-    UniqueConstraint("machine", "game_id", "year", "month", name="machine_billing_playcount_uk"),
-    mysql_charset="utf8mb4",
-)
 
 class ArcadeData(BaseData):
-    async def get_machine(self, serial: Optional[str] = None, id: Optional[int] = None) -> Optional[Row]:
+    async def get_machine(self, serial: str = None, id: int = None) -> Optional[Row]:
         if serial is not None:
             serial = serial.replace("-", "")
             if len(serial) == 11:
@@ -165,20 +94,20 @@ class ArcadeData(BaseData):
             return None
         return result.fetchone()
 
-    async def create_machine(
+    async def put_machine(
         self,
         arcade_id: int,
         serial: str = "",
-        board: Optional[str] = None,
-        game: Optional[str] = None,
+        board: str = None,
+        game: str = None,
         is_cab: bool = False,
     ) -> Optional[int]:
-        if not arcade_id:
+        if arcade_id:
             self.logger.error(f"{__name__ }: Need arcade id!")
             return None
 
         sql = machine.insert().values(
-            arcade=arcade_id, serial=serial, board=board, game=game, is_cab=is_cab
+            arcade=arcade_id, keychip=serial, board=board, game=game, is_cab=is_cab
         )
 
         result = await self.execute(sql)
@@ -186,15 +115,6 @@ class ArcadeData(BaseData):
             return None
         return result.lastrowid
 
-    async def set_machine_arcade(self, machine_id: int, new_arcade: int) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(arcade = new_arcade)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} arcade to {new_arcade}")
-            return False
-        return True
-
     async def set_machine_serial(self, machine_id: int, serial: str) -> None:
         result = await self.execute(
             machine.update(machine.c.id == machine_id).values(keychip=serial)
@@ -214,60 +134,6 @@ class ArcadeData(BaseData):
                 f"Failed to update board id for machine {machine_id} -> {boardid}"
             )
 
-    async def set_machine_game(self, machine_id: int, new_game: Optional[str]) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(game = new_game)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} game to {new_game}")
-            return False
-        return True
-
-    async def set_machine_country(self, machine_id: int, new_country: Optional[str]) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(country = new_country)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} country to {new_country}")
-            return False
-        return True
-
-    async def set_machine_timezone(self, machine_id: int, new_timezone: Optional[str]) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(timezone = new_timezone)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} timezone to {new_timezone}")
-            return False
-        return True
-
-    async def set_machine_real_cabinet(self, machine_id: int, is_real: bool = False) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(is_cab = is_real)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} is_cab to {is_real}")
-            return False
-        return True
-
-    async def set_machine_can_ota(self, machine_id: int, can_ota: bool = False) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(ota_enable = can_ota)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} ota_enable to {can_ota}")
-            return False
-        return True
-
-    async def set_machine_memo(self, machine_id: int, new_memo: Optional[str]) -> bool:
-        sql = machine.update(machine.c.id == machine_id).values(memo = new_memo)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update machine {machine_id} memo")
-            return False
-        return True
-
     async def get_arcade(self, id: int) -> Optional[Row]:
         sql = arcade.select(arcade.c.id == id)
         result = await self.execute(sql)
@@ -282,15 +148,15 @@ class ArcadeData(BaseData):
             return None
         return result.fetchall()
 
-    async def create_arcade(
+    async def put_arcade(
         self,
-        name: Optional[str] = None,
-        nickname: Optional[str] = None,
+        name: str,
+        nickname: str = None,
         country: str = "JPN",
         country_id: int = 1,
         state: str = "",
         city: str = "",
-        region_id: int = 1,
+        regional_id: int = 1,
     ) -> Optional[int]:
         if nickname is None:
             nickname = name
@@ -302,7 +168,7 @@ class ArcadeData(BaseData):
             country_id=country_id,
             state=state,
             city=city,
-            region_id=region_id,
+            regional_id=regional_id,
         )
 
         result = await self.execute(sql)
@@ -321,11 +187,8 @@ class ArcadeData(BaseData):
         sql = select(arcade_owner.c.permissions).where(and_(arcade_owner.c.user == user_id, arcade_owner.c.arcade == arcade_id))
         result = await self.execute(sql)
         if result is None:
-            return None
-        row =  result.fetchone()
-        if row:
-            return row['permissions']
-        return None
+            return False
+        return result.fetchone()
 
     async def get_arcade_owners(self, arcade_id: int) -> Optional[Row]:
         sql = select(arcade_owner).where(arcade_owner.c.arcade == arcade_id)
@@ -335,23 +198,23 @@ class ArcadeData(BaseData):
             return None
         return result.fetchall()
 
-    async def add_arcade_owner(self, arcade_id: int, user_id: int, permissions: int = 1) -> Optional[int]:
-        sql = insert(arcade_owner).values(arcade=arcade_id, user=user_id, permissions=permissions)
+    async def add_arcade_owner(self, arcade_id: int, user_id: int) -> None:
+        sql = insert(arcade_owner).values(arcade=arcade_id, user=user_id)
 
         result = await self.execute(sql)
         if result is None:
             return None
         return result.lastrowid
 
-    async def set_arcade_owner_permissions(self, arcade_id: int, user_id: int, new_permissions: int = 1) -> bool:
-        sql = arcade_owner.update(
-            and_(arcade_owner.c.arcade == arcade_id, arcade_owner.c.user == user_id)
-        ).values(permissions = new_permissions)
+    async def format_serial(
+        self, platform_code: str, platform_rev: int, serial_num: int, append: int = 4152
+    ) -> str:
+        return f"{platform_code}{platform_rev:02d}A{serial_num:04d}{append:04d}"  # 0x41 = A, 0x52 = R
 
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update arcade owner permissions to {new_permissions} for user {user_id} arcade {arcade_id}")
+    def validate_keychip_format(self, serial: str) -> bool:
+        if re.fullmatch(r"^A[0-9]{2}[E|X][-]?[0-9]{2}[A-HJ-NP-Z][0-9]{4}([0-9]{4})?$", serial) is None:
             return False
+        
         return True
 
     async def get_arcade_by_name(self, name: str) -> Optional[List[Row]]:
@@ -367,208 +230,3 @@ class ArcadeData(BaseData):
         if result is None:
             return None
         return result.fetchall()
-
-    async def set_arcade_name_nickname(self, arcade_id: int, new_name: Optional[str], new_nickname: Optional[str]) -> bool:
-        sql = arcade.update(arcade.c.id == arcade_id).values(name = new_name, nickname = new_nickname)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update arcade {arcade_id} name to {new_name}/{new_nickname}")
-            return False
-        return True
-
-    async def set_arcade_region_info(self, arcade_id: int, new_country: Optional[str], new_state: Optional[str], new_city: Optional[str], new_region_id: Optional[int], new_country_id: Optional[int]) -> bool:
-        sql = arcade.update(arcade.c.id == arcade_id).values(
-            country = new_country,
-            state = new_state,
-            city = new_city,
-            region_id = new_region_id,
-            country_id = new_country_id
-        )
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update arcade {arcade_id} regional info to {new_country}/{new_state}/{new_city}/{new_region_id}/{new_country_id}")
-            return False
-        return True
-
-    async def set_arcade_timezone(self, arcade_id: int, new_timezone: Optional[str]) -> bool:
-        sql = arcade.update(arcade.c.id == arcade_id).values(timezone = new_timezone)
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update arcade {arcade_id} timezone to {new_timezone}")
-            return False
-        return True
-
-    async def set_arcade_vpn_ip(self, arcade_id: int, new_ip: Optional[str]) -> bool:
-        sql = arcade.update(arcade.c.id == arcade_id).values(ip = new_ip)
-
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.error(f"Failed to update arcade {arcade_id} VPN address to {new_ip}")
-            return False
-        return True
-
-    async def get_num_generated_keychips(self) -> Optional[int]:
-        result = await self.execute(select(func.count("serial LIKE 'A69A%'")).select_from(machine))
-        if result:
-            return result.fetchone()['count_1']
-        self.logger.error("Failed to count machine serials that start with A69A!")
-
-    async def billing_add_charge(self, machine_id: int, game_id: str, game_ver: float, playcount: int, playlimit, product_code: int, product_count: int, func_type: int, player_num: int) -> Optional[int]:
-        result = await self.execute(billing_charge.insert().values(
-            machine=machine_id,
-            game_id=game_id,
-            game_ver=game_ver,
-            play_count=playcount,
-            play_limit=playlimit,
-            product_code=product_code,
-            product_count=product_count,
-            func_type=func_type,
-            player_number=player_num
-        ))
-
-        if result is None:
-            self.logger.error(f"Failed to add billing charge for machine {machine_id}!")
-            return None
-        return result.lastrowid
-    
-    async def billing_get_last_charge(self, machine_id: int, game_id: str) -> Optional[Row]:
-        result = await self.execute(billing_charge.select(
-            and_(billing_charge.c.machine == machine_id, billing_charge.c.game_id == game_id)
-        ).order_by(billing_charge.c.id.desc()).limit(3))
-        if result:
-            return result.fetchone()
-
-    async def billing_set_credit(self, machine_id: int, game_id: str, chute_type: int, service_type: int, op_mode: int, coin_rate0: int, coin_rate1: int,
-        bonus_adder: int, coin_to_credit_rate: int, coin_count_slot0: int, coin_count_slot1: int, coin_count_slot2: int, coin_count_slot3: int,
-        coin_count_slot4: int, coin_count_slot5: int, coin_count_slot6: int, coin_count_slot7: int) -> Optional[int]:
-        
-        sql = insert(billing_credit).values(
-            machine=machine_id,
-            game_id=game_id,
-            chute_type=chute_type,
-            service_type=service_type,
-            operation_type=op_mode,
-            coin_rate0=coin_rate0,
-            coin_rate1=coin_rate1,
-            coin_bonus=bonus_adder,
-            credit_rate=coin_to_credit_rate,
-            coin_count_slot0=coin_count_slot0,
-            coin_count_slot1=coin_count_slot1,
-            coin_count_slot2=coin_count_slot2,
-            coin_count_slot3=coin_count_slot3,
-            coin_count_slot4=coin_count_slot4,
-            coin_count_slot5=coin_count_slot5,
-            coin_count_slot6=coin_count_slot6,
-            coin_count_slot7=coin_count_slot7,
-        )
-
-        conflict = sql.on_duplicate_key_update(
-            chute_type=chute_type,
-            service_type=service_type,
-            operation_type=op_mode,
-            coin_rate0=coin_rate0,
-            coin_rate1=coin_rate1,
-            coin_bonus=bonus_adder,
-            credit_rate=coin_to_credit_rate,
-            coin_count_slot0=coin_count_slot0,
-            coin_count_slot1=coin_count_slot1,
-            coin_count_slot2=coin_count_slot2,
-            coin_count_slot3=coin_count_slot3,
-            coin_count_slot4=coin_count_slot4,
-            coin_count_slot5=coin_count_slot5,
-            coin_count_slot6=coin_count_slot6,
-            coin_count_slot7=coin_count_slot7,
-        )
-        
-        result = await self.execute(conflict)
-        if result is None:
-            self.logger.error(f"Failed to set billing credit settings for machine {machine_id}!")
-            return None
-        return result.lastrowid
-
-    async def billing_get_credit(self, machine_id: int, game_id: str) -> Optional[Row]:
-        result = await self.execute(billing_credit.select(
-            and_(billing_credit.c.machine == machine_id, billing_credit.c.game_id == game_id)
-        ))
-        if result:
-            return result.fetchone()
-
-    async def billing_add_playcount(self, machine_id: int, game_id: str, playct: int = 1) -> None:
-        now = datetime.now()
-        sql = insert(billing_playct).values(
-            machine=machine_id,
-            game_id=game_id,
-            year=now.year,
-            month=now.month,
-            playct=playct
-        )
-
-        conflict = sql.on_duplicate_key_update(playct=billing_playct.c.playct + playct)
-        result = await self.execute(conflict)
-
-        if result is None:
-            self.logger.error(f"Failed to add playcount for machine {machine_id} running {game_id}")
-    
-    async def billing_get_playcount_3mo(self, machine_id: int, game_id: str) -> Optional[List[Row]]:
-        result = await self.execute(billing_playct.select(and_(
-            billing_playct.c.machine == machine_id,
-            billing_playct.c.game_id == game_id
-        )).order_by(billing_playct.c.year.desc(), billing_playct.c.month.desc()).limit(3))
-
-        if result is not None:
-            return result.fetchall()
-
-    async def billing_get_last_playcount(self, machine_id: int, game_id: str) -> Optional[Row]:
-        result = await self.execute(billing_playct.select(and_(
-            billing_playct.c.machine == machine_id,
-            billing_playct.c.game_id == game_id
-        )).order_by(billing_playct.c.year.desc(), billing_playct.c.month.desc()).limit(1))
-
-        if result is not None:
-            return result.fetchone()
-
-    def format_serial(
-        self, platform_code: str, platform_rev: int, serial_letter: str, serial_num: int, append: int, dash: bool = False
-    ) -> str:
-        return f"{platform_code}{'-' if dash else ''}{platform_rev:02d}{serial_letter}{serial_num:04d}{append:04d}"
-
-    def validate_keychip_format(self, serial: str) -> bool:
-        # For the 2nd letter, E and X are the only "real" values that have been observed (A is used for generated keychips)
-        if re.fullmatch(r"^A[0-9]{2}[A-Z][-]?[0-9]{2}[A-HJ-NP-Z][0-9]{4}([0-9]{4})?$", serial) is None:
-            return False
-        
-        return True
-    
-    # Thanks bottersnike!
-    def get_keychip_suffix(self, year: int, month: int) -> str:
-        assert year > 1957
-        assert 1 <= month <= 12
-
-        year -= 1957
-        # Jan/Feb/Mar are from the previous tax year
-        if month < 4:
-            year -= 1
-        assert year >= 1 and year <= 99
-
-        month = ((month - 1) + 9) % 12  # Offset so April=0
-        return f"{year:02}{month // 6:01}{month % 6 + 1:01}"
-
-    def parse_keychip_suffix(self, suffix: str) -> tuple[int, int]:
-        year = int(suffix[0:2])
-        half = int(suffix[2])
-        assert half in (0, 1)
-        period = int(suffix[3])
-        assert period in (1, 2, 3, 4, 5, 6)
-
-        month = half * 6 + (period - 1)
-        month = ((month + 3) % 12) + 1  # Offset so Jan=1
-
-        # Jan/Feb/Mar are from the previous tax year
-        if month < 4:
-            year += 1
-        year += 1957
-
-        return (year, month)

core/data/schema/base.py

@@ -1,36 +1,27 @@
-import asyncio
 import json
 import logging
 from random import randrange
-from typing import Any, Dict, List, Optional
-
-from sqlalchemy import Column, MetaData, Table
+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
 from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.schema import ForeignKey
-from sqlalchemy.sql import func, text
-from sqlalchemy.types import INTEGER, JSON, TEXT, TIMESTAMP, Integer, String
+from sqlalchemy import MetaData, Table, Column
+from sqlalchemy.types import Integer, String, TIMESTAMP, JSON
+from sqlalchemy.dialects.mysql import insert
 
 from core.config import CoreConfig
 
 metadata = MetaData()
 
-event_log: Table = Table(
+event_log = Table(
     "event_log",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
     Column("system", String(255), nullable=False),
     Column("type", String(255), nullable=False),
     Column("severity", Integer, nullable=False),
-    Column("user", INTEGER, ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade")),
-    Column("arcade", INTEGER, ForeignKey("arcade.id", ondelete="cascade", onupdate="cascade")),
-    Column("machine", INTEGER, ForeignKey("machine.id", ondelete="cascade", onupdate="cascade")),
-    Column("ip", TEXT(39)),
-    Column("game", TEXT(4)),
-    Column("version", TEXT(24)),
     Column("message", String(1000), nullable=False),
     Column("details", JSON, nullable=False),
     Column("when_logged", TIMESTAMP, nullable=False, server_default=func.now()),
@@ -39,7 +30,7 @@ event_log: Table = Table(
 
 
 class BaseData:
-    def __init__(self, cfg: CoreConfig, conn: "sessionmaker[AsyncSession]") -> None:
+    def __init__(self, cfg: CoreConfig, conn: Connection) -> None:
         self.config = cfg
         self.conn = conn
         self.logger = logging.getLogger("database")
@@ -47,10 +38,21 @@ class BaseData:
     async def execute(self, sql: str, opts: Dict[str, Any] = {}) -> Optional[CursorResult]:
         res = None
 
-        async with self.conn() as session:
+        try:
+            self.logger.debug(f"SQL Execute: {''.join(str(sql).splitlines())}")
+            res = self.conn.execute(text(sql), opts)
+
+        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
+
+        except Exception:
             try:
-                self.logger.debug(f"SQL Execute: {''.join(str(sql).splitlines())}")
-                res = await session.execute(text(sql), opts)
+                res = self.conn.execute(sql, opts)
 
             except SQLAlchemyError as e:
                 self.logger.error(f"SQLAlchemy error {e}")
@@ -61,20 +63,8 @@ class BaseData:
                 return None
 
             except Exception:
-                try:
-                    res = await session.execute(sql, opts)
-
-                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
-
-                except Exception:
-                    self.logger.error(f"Unknown error")
-                    raise
+                self.logger.error(f"Unknown error")
+                raise
 
         return res
 
@@ -85,19 +75,12 @@ class BaseData:
         return randrange(10000, 9999999)
 
     async def log_event(
-        self, system: str, type: str, severity: int, message: str, details: Dict = {}, user: int = None, 
-        arcade: int = None, machine: int = None, ip: Optional[str] = None, game: Optional[str] = None, version: Optional[str] = None
+        self, system: str, type: str, severity: int, message: str, details: Dict = {}
     ) -> Optional[int]:
         sql = event_log.insert().values(
             system=system,
             type=type,
             severity=severity,
-            user=user,
-            arcade=arcade,
-            machine=machine,
-            ip=ip,
-            game=game,
-            version=version,
             message=message,
             details=json.dumps(details),
         )
@@ -111,8 +94,8 @@ class BaseData:
 
         return result.lastrowid
 
-    async def get_event_log(self, entries: int = 100) -> Optional[List[Row]]:
-        sql = event_log.select().order_by(event_log.c.id.desc()).limit(entries)
+    async def get_event_log(self, entries: int = 100) -> Optional[List[Dict]]:
+        sql = event_log.select().limit(entries).all()
         result = await self.execute(sql)
 
         if result is None:

core/data/schema/card.py

@@ -1,35 +1,32 @@
 from typing import Dict, List, Optional
-
-from sqlalchemy import Column, Table, UniqueConstraint
-from sqlalchemy.engine import Row
-from sqlalchemy.sql import func
+from sqlalchemy import Table, Column, UniqueConstraint
+from sqlalchemy.types import Integer, String, Boolean, TIMESTAMP
 from sqlalchemy.sql.schema import ForeignKey
-from sqlalchemy.types import BIGINT, TIMESTAMP, VARCHAR, Boolean, Integer, String
+from sqlalchemy.sql import func
+from sqlalchemy.engine import Row
 
 from core.data.schema.base import BaseData, metadata
 
-aime_card: Table = Table(
+aime_card = Table(
     "aime_card",
     metadata,
     Column("id", Integer, primary_key=True, nullable=False),
-    Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
-    Column("access_code", String(20), nullable=False, unique=True),
-    Column("idm", String(16), unique=True),
-    Column("chip_id", BIGINT, unique=True),
+    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"),
-    Column("memo", VARCHAR(16)),
     UniqueConstraint("user", "access_code", name="aime_card_uk"),
     mysql_charset="utf8mb4",
 )
 
 
 class CardData(BaseData):
-    moble_os_codes = set([0x06, 0x07, 0x10, 0x12, 0x13, 0x14, 0x15, 0x17, 0x18])
-    card_os_codes  = set([0x20, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7])
-
     async def get_card_by_access_code(self, access_code: str) -> Optional[Row]:
         sql = aime_card.select(aime_card.c.access_code == access_code)
 
@@ -77,7 +74,6 @@ class CardData(BaseData):
         if card["is_banned"]:
             return True
         return False
-    
     async def get_card_locked(self, access_code: str) -> Optional[bool]:
         """
         Given a 20 digit access code as a string, check if the card is locked
@@ -116,45 +112,6 @@ class CardData(BaseData):
             return None
         return result.lastrowid
 
-    async def update_card_last_login(self, access_code: str) -> None:
-        sql = aime_card.update(aime_card.c.access_code == access_code).values(
-            last_login_date=func.now()
-        )
-        
-        result = await self.execute(sql)
-        if result is None:
-            self.logger.warning(f"Failed to update last login time for {access_code}")
-
-    async def get_card_by_idm(self, idm: str) -> Optional[Row]:
-        result = await self.execute(aime_card.select(aime_card.c.idm == idm))
-        if result:
-            return result.fetchone()
-
-    async def get_card_by_chip_id(self, chip_id: int) -> Optional[Row]:
-        result = await self.execute(aime_card.select(aime_card.c.chip_id == chip_id))
-        if result:
-            return result.fetchone()
-
-    async def set_chip_id_by_access_code(self, access_code: str, chip_id: int) -> Optional[Row]:
-        result = await self.execute(aime_card.update(aime_card.c.access_code == access_code).values(chip_id=chip_id))
-        if not result:
-            self.logger.error(f"Failed to update chip ID to {chip_id} for {access_code}")
-
-    async def set_idm_by_access_code(self, access_code: str, idm: str) -> Optional[Row]:
-        result = await self.execute(aime_card.update(aime_card.c.access_code == access_code).values(idm=idm))
-        if not result:
-            self.logger.error(f"Failed to update IDm to {idm} for {access_code}")
-
-    async def set_access_code_by_access_code(self, old_ac: str, new_ac: str) -> None:
-        result = await self.execute(aime_card.update(aime_card.c.access_code == old_ac).values(access_code=new_ac))
-        if not result:
-            self.logger.error(f"Failed to change card access code from {old_ac} to {new_ac}")
-
-    async def set_memo_by_access_code(self, access_code: str, memo: str) -> None:
-        result = await self.execute(aime_card.update(aime_card.c.access_code == access_code).values(memo=memo))
-        if not result:
-            self.logger.error(f"Failed to add memo to card {access_code}")
-
     def to_access_code(self, luid: str) -> str:
         """
         Given a felica cards internal 16 hex character luid, convert it to a 0-padded 20 digit access code as a string
@@ -165,4 +122,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,15 +1,15 @@
-from typing import List, Optional
-
-import bcrypt
-from sqlalchemy import Column, Table
+from typing import Optional, List
+from sqlalchemy import Table, Column
+from sqlalchemy.types import Integer, String, TIMESTAMP
+from sqlalchemy.sql import func
 from sqlalchemy.dialects.mysql import insert
-from sqlalchemy.engine import Row
 from sqlalchemy.sql import func, select
-from sqlalchemy.types import TIMESTAMP, Integer, String
+from sqlalchemy.engine import Row
+import bcrypt
 
 from core.data.schema.base import BaseData, metadata
 
-aime_user: Table = Table(
+aime_user = Table(
     "aime_user",
     metadata,
     Column("id", Integer, nullable=False, primary_key=True, autoincrement=True),
@@ -26,10 +26,10 @@ aime_user: Table = Table(
 class UserData(BaseData):
     async def create_user(
         self,
-        id: Optional[int] = None,
-        username: Optional[str] = None,
-        email: Optional[str] = None,
-        password: Optional[str] = None,
+        id: int = None,
+        username: str = None,
+        email: str = None,
+        password: str = None,
         permission: int = 1,
     ) -> Optional[int]:
         if id is None:
@@ -108,19 +108,3 @@ class UserData(BaseData):
         if result is None:
             return False
         return result.fetchall()
-
-    async def change_password(self, user_id: int, new_passwd: str) -> bool:
-        sql = aime_user.update(aime_user.c.id == user_id).values(password = new_passwd)
-
-        result = await self.execute(sql)
-        return result is not None
-
-    async def change_username(self, user_id: int, new_name: str) -> bool:
-        sql = aime_user.update(aime_user.c.id == user_id).values(username = new_name)
-
-        result = await self.execute(sql)
-        return result is not None
-
-    async def get_user_by_username(self, username: str) -> Optional[Row]:
-        result = await self.execute(aime_user.select(aime_user.c.username == username))
-        if result: return result.fetchone()

core/frontend.py

@@ -10,8 +10,6 @@ import bcrypt
 import re
 import jwt
 import yaml
-import secrets
-import string
 from base64 import b64decode
 from enum import Enum
 from datetime import datetime, timezone
@@ -19,11 +17,6 @@ from os import path, environ, mkdir, W_OK, access
 
 from core import CoreConfig, Utils
 from core.data import Data
-from core.const import AllnetCountryCode
-
-# A-HJ-NP-Z
-SERIAL_LETTERS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
-ARTEMIS_SERIAL_PREFIX = "A69A"
 
 class PermissionOffset(Enum):
     USER = 0 # Regular user
@@ -37,7 +30,8 @@ class ShopPermissionOffset(Enum):
     VIEW = 0 # View info and cabs
     BOOKKEEP = 1 # View bookeeping info
     EDITOR = 2 # Can edit name, settings
-    # 3 - 6 reserved for future use
+    REGISTRAR = 3 # Can add cabs
+    # 4 - 6 reserved for future use
     OWNER = 7 # Can do anything
 
 class ShopOwner():
@@ -47,13 +41,11 @@ class ShopOwner():
         self.permissions = perms
 
 class UserSession():
-    def __init__(self, usr_id: int = 0, ip: str = "", perms: int = 0, ongeki_ver: int = 7, chunithm_ver: int = -1, maimai_version: int = -1):
+    def __init__(self, usr_id: int = 0, ip: str = "", perms: int = 0, ongeki_ver: int = 7):
         self.user_id = usr_id
         self.current_ip = ip
         self.permissions = perms
         self.ongeki_version = ongeki_ver
-        self.chunithm_version = chunithm_ver
-        self.maimai_version = maimai_version
 
 class FrontendServlet():
     def __init__(self, cfg: CoreConfig, config_dir: str) -> None:
@@ -137,24 +129,16 @@ class FrontendServlet():
             ]),
             Mount("/sys", routes=[
                 Route("/", self.system.render_GET, methods=['GET']),
-                Route("/logs", self.system.render_logs, methods=['GET']),
                 Route("/lookup.user", self.system.lookup_user, methods=['GET']),
                 Route("/lookup.shop", self.system.lookup_shop, methods=['GET']),
-                Route("/add.user", self.system.add_user, methods=['POST']),
-                Route("/add.card", self.system.add_card, methods=['POST']),
-                Route("/add.shop", self.system.add_shop, methods=['POST']),
-                Route("/add.cab", self.system.add_cab, methods=['POST']),
             ]),
             Mount("/shop", routes=[
                 Route("/", self.arcade.render_GET, methods=['GET']),
                 Route("/{shop_id:int}", self.arcade.render_GET, methods=['GET']),
-                Route("/{shop_id:int}/info.update", self.arcade.update_shop, methods=['POST']),
             ]),
             Mount("/cab", routes=[
                 Route("/", self.machine.render_GET, methods=['GET']),
                 Route("/{machine_id:int}", self.machine.render_GET, methods=['GET']),
-                Route("/{machine_id:int}/info.update", self.machine.update_cab, methods=['POST']),
-                Route("/{machine_id:int}/reassign", self.machine.reassign_cab, methods=['POST']),
             ]),
             Mount("/game", routes=g_routes),            
             Route("/robots.txt", self.robots)
@@ -196,10 +180,10 @@ class FE_Base():
             title=self.core_config.server.name,
             game_list=self.environment.globals["game_list"],
             sesh=vars(sesh) if sesh is not None else vars(UserSession()),
-        ), media_type="text/html; charset=utf-8")
+        ))
         
         if sesh is None:
-            resp.delete_cookie("ARTEMIS_SESH")
+            resp.delete_cookie("DIANA_SESH")
         return resp
     
     def get_routes(self) -> List[Route]:
@@ -222,10 +206,7 @@ class FE_Base():
             sesh.user_id = tk['user_id']
             sesh.current_ip = tk['current_ip']
             sesh.permissions = tk['permissions']
-            sesh.chunithm_version = tk['chunithm_version']
-            sesh.maimai_version = tk['maimai_version']
-            sesh.ongeki_version = tk['ongeki_version']
-
+            
             if sesh.user_id <= 0:
                 self.logger.error("User session failed to validate due to an invalid ID!")
                 return UserSession()
@@ -250,7 +231,7 @@ class FE_Base():
             return UserSession()
     
     def validate_session(self, request: Request) -> Optional[UserSession]:
-        sesh = request.cookies.get('ARTEMIS_SESH', "")
+        sesh = request.cookies.get('DIANA_SESH', "")
         if not sesh:
             return None
         
@@ -264,22 +245,12 @@ class FE_Base():
         if usr_sesh.permissions <= 0 or usr_sesh.permissions > 255:
             self.logger.error(f"User session failed to validate due to an invalid permission value! {usr_sesh.permissions}")
             return None
-
+        
         return usr_sesh
     
     def encode_session(self, sesh: UserSession, exp_seconds: int = 86400) -> str:
         try:
-            return jwt.encode({
-                "user_id": sesh.user_id,
-                "current_ip": sesh.current_ip,
-                "permissions": sesh.permissions,
-                "ongeki_version": sesh.ongeki_version,
-                "chunithm_version": sesh.chunithm_version,
-                "maimai_version": sesh.maimai_version,
-                "exp": int(datetime.now(tz=timezone.utc).timestamp()) + exp_seconds }, 
-                b64decode(self.core_config.frontend.secret), 
-                algorithm="HS256"
-            )
+            return jwt.encode({ "user_id": sesh.user_id, "current_ip": sesh.current_ip, "permissions": sesh.permissions, "ongeki_version": sesh.ongeki_version, "exp": int(datetime.now(tz=timezone.utc).timestamp()) + exp_seconds }, b64decode(self.core_config.frontend.secret), algorithm="HS256")
         except jwt.InvalidKeyError:
             self.logger.error("Failed to encode User session because the secret is invalid!")
             return ""
@@ -310,8 +281,8 @@ class FE_Gate(FE_Base):
             title=f"{self.core_config.server.name} | Login Gate",
             error=err,
             sesh=vars(UserSession()),
-        ), media_type="text/html; charset=utf-8")
-        resp.delete_cookie("ARTEMIS_SESH")
+        ))
+        resp.delete_cookie("DIANA_SESH")
         return resp
     
     async def render_login(self, request: Request):
@@ -327,12 +298,8 @@ class FE_Gate(FE_Base):
 
         uid = await self.data.card.get_user_id_from_card(access_code)
         if uid is None:
-            user = await self.data.user.get_user_by_username(access_code) # Lookup as username
-            if not user:
-                self.logger.debug(f"Failed to find user for card/username {access_code}")
-                return RedirectResponse("/gate/?e=1", 303)
-            
-            uid = user['id']
+            self.logger.debug(f"Failed to find user for card {access_code}")
+            return RedirectResponse("/gate/?e=1", 303)
 
         user = await self.data.user.get_user(uid)
         if user is None:
@@ -343,7 +310,7 @@ class FE_Gate(FE_Base):
             sesh = await self.data.user.check_password(uid)
 
             if sesh is not None:
-                return RedirectResponse(f"/gate/create?ac={access_code}", 303)
+                return RedirectResponse(f"/gate/create?ac={access_code}")
             
             return RedirectResponse("/gate/?e=1", 303)
 
@@ -361,17 +328,16 @@ class FE_Gate(FE_Base):
         usr_sesh = self.encode_session(sesh)
         self.logger.debug(f"Created session with JWT {usr_sesh}")
         resp = RedirectResponse("/user/", 303)
-        resp.set_cookie("ARTEMIS_SESH", usr_sesh)
+        resp.set_cookie("DIANA_SESH", usr_sesh)
 
         return resp
 
     async def render_create(self, request: Request):
         ip = Utils.get_ip_addr(request)
-        frm = await request.form()
-        access_code: str = frm.get("access_code", "")
-        username: str = frm.get("username", "")
-        email: str = frm.get("email", "")
-        passwd: bytes = frm.get("passwd", "").encode()
+        access_code: str = request.query_params.get("access_code", "")
+        username: str = request.query_params.get("username", "")
+        email: str = request.query_params.get("email", "")
+        passwd: bytes = request.query_params.get("passwd", "").encode()
 
         if not access_code or not username or not email or not passwd:
             return RedirectResponse("/gate/?e=1", 303)
@@ -399,13 +365,13 @@ class FE_Gate(FE_Base):
         
         usr_sesh = self.encode_session(sesh)
         self.logger.debug(f"Created session with JWT {usr_sesh}")
-        resp = RedirectResponse("/user/", 303)
-        resp.set_cookie("ARTEMIS_SESH", usr_sesh)
+        resp = RedirectResponse("/user", 303)
+        resp.set_cookie("DIANA_SESH", usr_sesh)
 
         return resp
 
     async def render_create_get(self, request: Request):
-        ac = request.query_params.get("ac", "")
+        ac = request.query_params.get(b"ac", [b""])[0].decode()
         if len(ac) != 20:
             return RedirectResponse("/gate/?e=2", 303)
 
@@ -426,7 +392,7 @@ class FE_Gate(FE_Base):
             title=f"{self.core_config.server.name} | Create User",
             code=ac,
             sesh={"user_id": 0, "permissions": 0},
-        ), media_type="text/html; charset=utf-8")
+        ))
 
 class FE_User(FE_Base):
     async def render_GET(self, request: Request):
@@ -441,7 +407,7 @@ class FE_User(FE_Base):
         
         if user_id:
             if not self.test_perm(usr_sesh.permissions, PermissionOffset.USERMOD) and user_id != usr_sesh.user_id:
-                self.logger.warning(f"User {usr_sesh.user_id} does not have permission to view user {user_id}")
+                self.logger.warn(f"User {usr_sesh.user_id} does not have permission to view user {user_id}")
                 return RedirectResponse("/user/", 303)
         
         else:
@@ -457,16 +423,6 @@ class FE_User(FE_Base):
         card_data = []
         arcade_data = []
 
-        managed_arcades = await self.data.arcade.get_arcades_managed_by_user(user_id)
-        if managed_arcades:
-            for arcade in managed_arcades:
-                ac = await self.data.arcade.get_arcade(arcade['id'])
-                if ac:
-                    arcade_data.append({
-                        "id": ac['id'],
-                        "name": ac['name'],
-                    })
-
         for c in cards:
             if c['is_locked']:
                 status = 'Locked'
@@ -483,7 +439,10 @@ class FE_User(FE_Base):
             elif ac.startswith("3"):
                 c_type = "Banapass"
             elif ac.startswith("010"):                
-                c_type = "Aime" # TODO: Aime verification
+                c_type = "Unknown Aime"
+                desc, _ = self.data.card.get_aime_ac_key_desc(ac)
+                if desc is not None:
+                    c_type = desc
             elif ac.startswith("0008"):
                 c_type = "Generated AIC"
             else:
@@ -492,11 +451,10 @@ class FE_User(FE_Base):
             card_data.append({
                 'access_code': ac, 
                 'status': status, 
-                'chip_id': c['chip_id'],
-                'idm': c['idm'], 
+                'chip_id': "", #None if c['chip_id'] is None else f"{c['chip_id']:X}", 
+                'idm': "", 
                 'type': c_type, 
-                "memo": c['memo'],
-                "id": c['id'],
+                "memo": ""
             })
 
         if "e" in request.query_params:
@@ -525,114 +483,18 @@ class FE_User(FE_Base):
             success=succ,
             username=user['username'],
             arcades=arcade_data
-        ), media_type="text/html; charset=utf-8")
+        ))
     
     async def render_logout(self, request: Request):
         resp = RedirectResponse("/gate/", 303)
-        resp.delete_cookie("ARTEMIS_SESH")
+        resp.delete_cookie("DIANA_SESH")
         return resp
     
     async def edit_card(self, request: Request) -> RedirectResponse:
-        frm = await request.form()
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.USERMOD):
-            return RedirectResponse("/gate/", 303)
-
-        frm = await request.form()
-        cid = frm.get("card_edit_frm_card_id", None)
-        if not cid:
-            return RedirectResponse("/user/?e=999", 303)
-        
-        ac = frm.get("card_edit_frm_access_code", None)
-        if not ac:
-            return RedirectResponse("/user/?e=999", 303)
-        
-        card = await self.data.card.get_card_by_id(cid)
-        if not card:
-            return RedirectResponse("/user/?e=2", 303)
-        
-        if card['user'] != usr_sesh.user_id and not self.test_perm_minimum(usr_sesh.permissions, PermissionOffset.USERMOD):
-            return RedirectResponse("/user/?e=11", 303)
-
-        if frm.get("add_memo", None) or frm.get("add_memo", None) == "":
-            memo = frm.get("add_memo")
-            if len(memo) > 16:
-                return RedirectResponse("/user/?e=4", 303)
-            await self.data.card.set_memo_by_access_code(ac, memo)
-
-        if False: # Saving this in case I want to allow editing idm/chip ID down the line
-            if frm.get("add_felica_idm", None):
-                idm = frm.get('add_felica_idm')
-                if not all(c in string.hexdigits for c in idm):
-                    return RedirectResponse("/user/?e=4", 303)
-                await self.data.card.set_idm_by_access_code(ac, idm)
-
-            if frm.get("add_mifare_chip_id", None):
-                chip_id: str = frm.get('add_mifare_chip_id')
-                if not all(c in string.hexdigits for c in idm):
-                    return RedirectResponse("/user/?e=4", 303)
-                await self.data.card.set_chip_id_by_access_code(ac, int(chip_id, 16))
-
-        return RedirectResponse("/user/?s=4", 303)
+        return RedirectResponse("/user/", 303)
     
     async def add_card(self, request: Request) -> RedirectResponse:
-        frm = await request.form()
-        card_type = frm.get("card_add_frm_type", None)
-        access_code = frm.get("add_access_code", None)
-        idm = frm.get("add_idm", None)
-        idm_caps = None
-        
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.USERMOD):
-            return RedirectResponse("/gate/", 303)
-
-        if not len(access_code) == 20 or (not access_code.startswith("5") and not access_code.startswith("3") \
-            and not access_code.startswith("010") and not access_code.startswith("0008")):
-            return RedirectResponse("/user/?e=4", 303)
-
-        if card_type == "0" and access_code.startswith("5") and len(idm) == 16:
-            idm_caps = idm.upper()
-
-            if not all([x in string.hexdigits for x in idm_caps]):
-                return RedirectResponse("/user/?e=4", 303)
-        
-        if access_code.startswith("5") and not idm_caps:
-            return RedirectResponse("/user/?e=13", 303)
-
-        test = await self.data.card.get_card_by_access_code(access_code)
-        if test:
-            return RedirectResponse("/user/?e=12", 303)
-        
-        if idm_caps:
-            test = await self.data.card.get_card_by_idm(idm_caps)
-            if test and test['user'] != usr_sesh.user_id:
-                return RedirectResponse("/user/?e=12", 303)
-            
-            test = await self.data.card.get_card_by_access_code(self.data.card.to_access_code(idm_caps))
-            if test:
-                if test['user'] != usr_sesh.user_id:
-                    return RedirectResponse("/user/?e=12", 303)
-
-                await self.data.card.set_access_code_by_access_code(test['access_code'], access_code)
-                self.logger.info(f"Update card {test['id']} from {test['access_code']} to {access_code} for user {usr_sesh.user_id}")
-
-                await self.data.card.set_idm_by_access_code(access_code, idm_caps)
-                self.logger.info(f"Set IDm for card {access_code} to {idm_caps}")
-                return RedirectResponse("/user/?s=1", 303)
-        
-        if card_type == "0" and access_code.startswith("0008"):
-            test = await self.data.card.get_card_by_idm(self.data.card.to_idm(access_code))
-            if test:
-                return RedirectResponse("/user/?e=12", 303)
-
-        new_card = await self.data.card.create_card(usr_sesh.user_id, access_code)
-        self.logger.info(f"Created new card {new_card} with access code {access_code} for user {usr_sesh.user_id}")
-        
-        if idm_caps:
-            await self.data.card.set_idm_by_access_code(access_code, idm_caps)
-            self.logger.info(f"Set IDm for card {access_code} to {idm_caps}")
-        
-        return RedirectResponse("/user/?s=1", 303)
+        return RedirectResponse("/user/", 303)
 
     async def render_POST(self, request: Request):
         frm = await request.form()
@@ -691,17 +553,11 @@ class FE_System(FE_Base):
         if not usr_sesh or not self.test_perm_minimum(usr_sesh.permissions, PermissionOffset.USERMOD):
             return RedirectResponse("/gate/", 303)
         
-        if request.query_params.get("e", None):
-            err = int(request.query_params.get("e"))
-        else:
-            err = 0
-        
         return Response(template.render(
             title=f"{self.core_config.server.name} | System", 
             sesh=vars(usr_sesh), 
             usrlist=[],
-            error = err
-        ), media_type="text/html; charset=utf-8")
+        ))
         
     async def lookup_user(self, request: Request):
         template = self.environment.get_template("core/templates/sys/index.jinja")
@@ -734,7 +590,7 @@ class FE_System(FE_Base):
             sesh=vars(usr_sesh), 
             usrlist=usrlist,
             shoplist=[],
-        ), media_type="text/html; charset=utf-8")
+        ))
 
     async def lookup_shop(self, request: Request):
         shoplist = []
@@ -768,7 +624,7 @@ class FE_System(FE_Base):
                     usrlist=[],
                     shoplist=shoplist,
                     error=4
-                ), media_type="text/html; charset=utf-8")
+                ))
         
         if sn_search:
             sn_search = sn_search.upper().replace("-", "").strip()
@@ -797,7 +653,7 @@ class FE_System(FE_Base):
                     usrlist=[],
                     shoplist=shoplist,
                     error=10
-                ), media_type="text/html; charset=utf-8")
+                ))
             
         
         return Response(template.render(
@@ -805,185 +661,30 @@ class FE_System(FE_Base):
             sesh=vars(usr_sesh), 
             usrlist=[],
             shoplist=shoplist,
-        ), media_type="text/html; charset=utf-8")
+        ))
 
-    async def add_user(self, request: Request):
-        template = self.environment.get_template("core/templates/sys/index.jinja")
-        
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            return RedirectResponse("/gate/", 303)
-        
-        frm = await request.form()
-        username = frm.get("userName", None)
-        email = frm.get("userEmail", None)
-        perm = frm.get("usrPerm", "1")
-        passwd = "".join(
-            secrets.choice(string.ascii_letters + string.digits) for i in range(20)
-        )
-        hash = bcrypt.hashpw(passwd.encode(), bcrypt.gensalt())
-
-        if not email:
-            return RedirectResponse("/sys/?e=4", 303)
-
-        uid = await self.data.user.create_user(username=username if username else None, email=email, password=hash.decode(), permission=int(perm))
-        return Response(template.render(
-            title=f"{self.core_config.server.name} | System", 
-            sesh=vars(usr_sesh), 
-            usradd={"id": uid, "username": username, "password": passwd},
-        ), media_type="text/html; charset=utf-8")
-
-    async def add_card(self, request: Request):
-        template = self.environment.get_template("core/templates/sys/index.jinja")
-        
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            return RedirectResponse("/gate/", 303)
-        
-        frm = await request.form()
-        userid = frm.get("cardUsr", None)
-        access_code = frm.get("cardAc", None)
-        idm = frm.get("cardIdm", None)
-
-        if userid is None or access_code is None or not userid.isdigit() or not len(access_code) == 20 or not access_code.isdigit:
-            return RedirectResponse("/sys/?e=4", 303)
-        
-        cardid = await self.data.card.create_card(int(userid), access_code)
-        if not cardid:
-            return RedirectResponse("/sys/?e=99", 303)
-
-        if idm is not None:
-            # TODO: save IDM
-            pass
-        
-        return Response(template.render(
-            title=f"{self.core_config.server.name} | System", 
-            sesh=vars(usr_sesh), 
-            cardadd={"id": cardid, "user": userid, "access_code": access_code},
-        ), media_type="text/html; charset=utf-8")
-
-    async def add_shop(self, request: Request):
-        template = self.environment.get_template("core/templates/sys/index.jinja")
-        
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            return RedirectResponse("/gate/", 303)
-        
-        frm = await request.form()
-        name = frm.get("shopName", None)
-        country = frm.get("shopCountry", "JPN")
-        ip = frm.get("shopIp", None)
-        owner = frm.get("shopOwner", None)
-
-        acid = await self.data.arcade.create_arcade(name if name else None, name if name else None, country)
-        if not acid:
-            return RedirectResponse("/sys/?e=99", 303)
-        
-        await self.data.arcade.set_arcade_vpn_ip(acid, ip if ip else None)
-
-        if owner:
-            await self.data.arcade.add_arcade_owner(acid, int(owner), 255)
-        
-        return Response(template.render(
-            title=f"{self.core_config.server.name} | System", 
-            sesh=vars(usr_sesh), 
-            shopadd={"id": acid},
-        ), media_type="text/html; charset=utf-8")
-
-    async def add_cab(self, request: Request):
-        template = self.environment.get_template("core/templates/sys/index.jinja")
-        
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            return RedirectResponse("/gate/", 303)
-
-        frm = await request.form()
-        shopid = frm.get("cabShop", None)
-        serial = frm.get("cabSerial", None)
-        game_code = frm.get("cabGame", None)
-
-        if not shopid or not shopid.isdigit():
-            return RedirectResponse("/sys/?e=4", 303)
-        
-        if not serial:
-            append = self.data.arcade.get_keychip_suffix(datetime.now().year, datetime.now().month)
-            generated = await self.data.arcade.get_num_generated_keychips()
-            if not generated:
-                generated = 0
-            
-            rollover = generated // 9999
-            serial_num = (generated % 9999) + 1
-            serial_letter = SERIAL_LETTERS[rollover]
-
-            serial_dash = self.data.arcade.format_serial(ARTEMIS_SERIAL_PREFIX, 1, serial_letter, serial_num, int(append), True)
-            serial = serial_dash.replace("-", "")
-        
-        cab_id = await self.data.arcade.create_machine(int(shopid), serial, None, game_code if game_code else None)
-        if cab_id is None:
-            return RedirectResponse("/sys/?e=4", 303)
-        
-        return Response(template.render(
-            title=f"{self.core_config.server.name} | System", 
-            sesh=vars(usr_sesh), 
-            cabadd={"id": cab_id, "serial": serial_dash},
-        ), media_type="text/html; charset=utf-8")
-
-    async def render_logs(self, request: Request):
-        template = self.environment.get_template("core/templates/sys/logs.jinja")
-        events = []
-        
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.SYSADMIN):
-            return RedirectResponse("/sys/?e=11", 303)
-        
-        logs = await self.data.base.get_event_log()
-        if not logs:
-            logs = []
-        
-        for log in logs:
-            evt = log._asdict()
-            if not evt['user']: evt["user"] = "NONE"
-            if not evt['arcade']: evt["arcade"] = "NONE"
-            if not evt['machine']: evt["machine"] = "NONE"
-            if not evt['ip']: evt["ip"] = "NONE"
-            if not evt['game']: evt["game"] = "NONE"
-            if not evt['version']: evt["version"] = "NONE"
-            evt['when_logged'] = evt['when_logged'].strftime("%x %X")
-            events.append(evt)
-        
-        return Response(template.render(
-            title=f"{self.core_config.server.name} | Event Logs", 
-            sesh=vars(usr_sesh), 
-            events=events
-        ), media_type="text/html; charset=utf-8")
-        
 class FE_Arcade(FE_Base):
     async def render_GET(self, request: Request):
         template = self.environment.get_template("core/templates/arcade/index.jinja")
         shop_id = request.path_params.get('shop_id', None)
         
         usr_sesh = self.validate_session(request)
-        if not usr_sesh:
+        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
+            self.logger.warn(f"User {usr_sesh.user_id} does not have permission to view shops!")
             return RedirectResponse("/gate/", 303)
- 
+        
         if not shop_id:
-            return Response('Not Found', status_code=404)
-
-        is_acmod = self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD)
-        if not is_acmod:
-            usr_shop_perm = await self.data.arcade.get_manager_permissions(usr_sesh.user_id, shop_id)
-            if usr_shop_perm is None or usr_shop_perm == 0:
-                self.logger.warning(f"User {usr_sesh.user_id} does not have permission to view shop {shop_id}!")
-                return RedirectResponse("/", 303)
-        else:
-            usr_shop_perm = 15 # view, bookeep, edit
+            return Response(template.render(
+                title=f"{self.core_config.server.name} | Arcade", 
+                sesh=vars(usr_sesh),
+            ))
         
         sinfo = await self.data.arcade.get_arcade(shop_id)
         if not sinfo:
             return Response(template.render(
                 title=f"{self.core_config.server.name} | Arcade", 
                 sesh=vars(usr_sesh),
-            ), media_type="text/html; charset=utf-8")
+            ))
         
         cabs = await self.data.arcade.get_arcade_machines(shop_id)
         cablst = []
@@ -995,206 +696,40 @@ class FE_Arcade(FE_Base):
                     "game": x['game'],
                 })
         
-        managers = []
-        if (usr_shop_perm & 1 << ShopPermissionOffset.OWNER.value) or is_acmod:
-            mgrs = await self.data.arcade.get_arcade_owners(sinfo['id'])
-            if mgrs:
-                for mgr in mgrs:
-                    usr = await self.data.user.get_user(mgr['user'])
-                    managers.append({
-                        'user': mgr['user'],
-                        'name': usr['username'] if usr['username'] else 'No Name Set',
-                        'is_view': bool(mgr['permissions'] & 1 << ShopPermissionOffset.VIEW.value),
-                        'is_bookkeep': bool(mgr['permissions'] & 1 << ShopPermissionOffset.BOOKKEEP.value),
-                        'is_edit': bool(mgr['permissions'] & 1 << ShopPermissionOffset.EDITOR.value),
-                        'is_owner': bool(mgr['permissions'] & 1 << ShopPermissionOffset.OWNER.value),
-                    })
-
-        if request.query_params.get("e", None):
-            err = int(request.query_params.get("e"))
-        else:
-            err = 0
-
-        if request.query_params.get("s", None):
-            suc = int(request.query_params.get("s"))
-        else:
-            suc = 0
-
         return Response(template.render(
             title=f"{self.core_config.server.name} | Arcade", 
             sesh=vars(usr_sesh),
-            cablst=cablst,
-            arcade=sinfo._asdict(),
-            can_bookkeep=bool(usr_shop_perm & 1 << ShopPermissionOffset.BOOKKEEP.value) or is_acmod,
-            can_edit=bool(usr_shop_perm & 1 << ShopPermissionOffset.EDITOR.value) or is_acmod,
-            is_owner=usr_shop_perm & 1 << ShopPermissionOffset.OWNER.value,
-            is_acmod=is_acmod,
-            managers=managers,
-            error=err,
-            success=suc
-        ), media_type="text/html; charset=utf-8")
-
-    async def update_shop(self, request: Request):
-        shop_id = request.path_params.get('shop_id', None)
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        sinfo = await self.data.arcade.get_arcade(shop_id)
-        
-        if not shop_id or not sinfo:
-            return RedirectResponse("/", 303)
-
-        if not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            usr_shop_perm = await self.data.arcade.get_manager_permissions(usr_sesh.user_id, sinfo['id'])
-            if usr_shop_perm is None or usr_shop_perm == 0:
-                self.logger.warning(f"User {usr_sesh.user_id} does not have permission to view shop {sinfo['id']}!")
-                return RedirectResponse("/", 303)
-        
-        frm = await request.form()
-        new_name = frm.get('name', None)
-        new_nickname = frm.get('nickname', None)
-        new_country = frm.get('country', None)
-        new_region1 = frm.get('region1', None)
-        new_region2 = frm.get('region2', None)
-        new_tz = frm.get('tz', None)
-        new_ip = frm.get('ip', None)
-
-        try:
-            AllnetCountryCode(new_country)
-        except ValueError:
-            new_country = 'JPN'
-
-        did_name = await self.data.arcade.set_arcade_name_nickname(sinfo['id'], new_name if new_name else f'Arcade{sinfo["id"]}', new_nickname if new_nickname else None)
-        did_region = await self.data.arcade.set_arcade_region_info(sinfo['id'], new_country, new_region1 if new_region1 else None, new_region2 if new_region2 else None, None, None)
-        did_timezone = await self.data.arcade.set_arcade_timezone(sinfo['id'], new_tz if new_tz else None)
-        did_vpn = await self.data.arcade.set_arcade_vpn_ip(sinfo['id'], new_ip if new_ip else None)
-
-        if not did_name or not did_region or not did_timezone or not did_vpn:
-            self.logger.error(f"Failed to update some shop into: Name: {did_name} Region: {did_region} TZ: {did_timezone} VPN: {did_vpn}")
-            return RedirectResponse(f"/shop/{shop_id}?e=15", 303)
-        
-        return RedirectResponse(f"/shop/{shop_id}?s=1", 303)
+            arcade={
+                "name": sinfo['name'],
+                "id": sinfo['id'],
+                "cabs": cablst
+            }
+            
+        ))
 
 class FE_Machine(FE_Base):
     async def render_GET(self, request: Request):
         template = self.environment.get_template("core/templates/machine/index.jinja")
-        cab_id = request.path_params.get('machine_id', None)
+        cab_id = request.path_params.get('cab_id', None)
         
         usr_sesh = self.validate_session(request)
-        if not usr_sesh:
+        if not usr_sesh or not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
+            self.logger.warn(f"User {usr_sesh.user_id} does not have permission to view shops!")
             return RedirectResponse("/gate/", 303)
-
-        cab = await self.data.arcade.get_machine(id=cab_id)
         
-        if not cab_id or not cab:
-            return Response('Not Found', status_code=404)
+        if not cab_id:
+            return Response(template.render(
+                title=f"{self.core_config.server.name} | Machine", 
+                sesh=vars(usr_sesh),
+            ))
         
-        shop = await self.data.arcade.get_arcade(cab['arcade'])
-        
-        is_acmod = self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD)
-        if not is_acmod:
-            usr_shop_perm = await self.data.arcade.get_manager_permissions(usr_sesh.user_id, shop['id'])
-            if usr_shop_perm is None or usr_shop_perm == 0:
-                self.logger.warning(f"User {usr_sesh.user_id} does not have permission to view shop {shop['id']}!")
-                return RedirectResponse("/", 303)
-        else:
-            usr_shop_perm = 15 # view, bookeep, edit
-        
-        if request.query_params.get("e", None):
-            err = int(request.query_params.get("e"))
-        else:
-            err = 0
-
-        if request.query_params.get("s", None):
-            suc = int(request.query_params.get("s"))
-        else:
-            suc = 0
-
         return Response(template.render(
             title=f"{self.core_config.server.name} | Machine", 
             sesh=vars(usr_sesh),
-            arcade=shop._asdict(),
-            machine=cab._asdict(),
-            can_bookkeep=bool(usr_shop_perm & 1 << ShopPermissionOffset.BOOKKEEP.value) or is_acmod,
-            can_edit=bool(usr_shop_perm & 1 << ShopPermissionOffset.EDITOR.value) or is_acmod,
-            is_owner=usr_shop_perm & 1 << ShopPermissionOffset.OWNER.value,
-            is_acmod=is_acmod,
-            error=err,
-            success=suc
-        ), media_type="text/html; charset=utf-8")
-    
-    async def update_cab(self, request: Request):
-        cab_id = request.path_params.get('machine_id', None)
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
+            arcade={}
+        ))
 
-        cab = await self.data.arcade.get_machine(id=cab_id)
-        
-        if not cab_id or not cab:
-            return RedirectResponse("/", 303)
-
-        if not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            usr_shop_perm = await self.data.arcade.get_manager_permissions(usr_sesh.user_id, cab['arcade'])
-            if usr_shop_perm is None or usr_shop_perm == 0:
-                self.logger.warning(f"User {usr_sesh.user_id} does not have permission to view shop {cab['arcade']}!")
-                return RedirectResponse("/", 303)
-
-        frm = await request.form()
-        new_game = frm.get('game', None)
-        new_country = frm.get('country', None)
-        new_tz = frm.get('tz', None)
-        new_is_cab = frm.get('is_cab', False) == 'on'
-        new_is_ota = frm.get('is_ota', False) == 'on'
-        new_memo = frm.get('memo', None)
-
-        try:
-            AllnetCountryCode(new_country)
-        except ValueError:
-            new_country = None
-        
-        did_game = await self.data.arcade.set_machine_game(cab['id'], new_game if new_game else None)
-        did_country = await self.data.arcade.set_machine_country(cab['id'], new_country if new_country else None)
-        did_timezone = await self.data.arcade.set_machine_timezone(cab['id'], new_tz if new_tz else None)
-        did_real_cab = await self.data.arcade.set_machine_real_cabinet(cab['id'], new_is_cab)
-        did_ota = await self.data.arcade.set_machine_can_ota(cab['id'], new_is_ota)
-        did_memo = await self.data.arcade.set_machine_memo(cab['id'], new_memo if new_memo else None)
-
-        if not did_game or not did_country or not did_timezone or not did_real_cab or not did_ota or not did_memo:
-            self.logger.error(f"Failed to update some shop into: Game: {did_game} Country: {did_country} TZ: {did_timezone} Real: {did_real_cab} OTA: {did_ota} Memo: {did_memo}")
-            return RedirectResponse(f"/cab/{cab['id']}?e=15", 303)
-
-        return RedirectResponse(f"/cab/{cab_id}?s=1", 303)
-
-    async def reassign_cab(self, request: Request):
-        cab_id = request.path_params.get('machine_id', None)
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        cab = await self.data.arcade.get_machine(id=cab_id)
-        
-        if not cab_id or not cab:
-            return RedirectResponse("/", 303)
-        
-        frm = await request.form()
-        new_shop = frm.get('new_arcade', None)
-
-        if not self.test_perm(usr_sesh.permissions, PermissionOffset.ACMOD):
-            self.logger.warning(f"User {usr_sesh.user_id} does not have permission to reassign cab {cab['id']} to arcade !")
-            return RedirectResponse(f"/cab/{cab_id}?e=11", 303)
-        
-        new_sinfo = await self.data.arcade.get_arcade(new_shop)
-        if not new_sinfo:
-            return RedirectResponse(f"/cab/{cab_id}?e=14", 303)
-        
-        if not await self.data.arcade.set_machine_arcade(cab['id'], new_sinfo['id']):
-            return RedirectResponse(f"/cab/{cab_id}?e=99", 303)
-        
-        return RedirectResponse(f"/cab/{cab_id}?s=2", 303)
-
-cfg_dir = environ.get("ARTEMIS_CFG_DIR", "config")
+cfg_dir = environ.get("DIANA_CFG_DIR", "config")
 cfg: CoreConfig = CoreConfig()
 if path.exists(f"{cfg_dir}/core.yaml"):
     cfg.update(yaml.safe_load(open(f"{cfg_dir}/core.yaml")))

core/mucha.py

@@ -2,7 +2,6 @@ from typing import Dict, Any, Optional
 import logging, coloredlogs
 from logging.handlers import TimedRotatingFileHandler
 from starlette.requests import Request
-from starlette.responses import PlainTextResponse
 from datetime import datetime
 from Crypto.Cipher import Blowfish
 import pytz
@@ -10,11 +9,9 @@ import pytz
 from .config import CoreConfig
 from .utils import Utils
 from .title import TitleServlet
-from .data import Data
-from .const import *
 
 class MuchaServlet:
-    mucha_registry: Dict[str, Dict[str, str]] = {}
+    mucha_registry: Dict[str, str] = {}
     def __init__(self, cfg: CoreConfig, cfg_dir: str) -> None:
         self.config = cfg
         self.config_dir = cfg_dir
@@ -38,148 +35,91 @@ class MuchaServlet:
 
         self.logger.setLevel(cfg.mucha.loglevel)
         coloredlogs.install(level=cfg.mucha.loglevel, logger=self.logger, fmt=log_fmt_str)
-        
-        self.data = Data(cfg)
 
         for _, mod in TitleServlet.title_registry.items():
-            enabled, game_cds, netids = mod.get_mucha_info(self.config, self.config_dir)
-            if enabled:
-                for x in range(len(game_cds)):
-                    self.mucha_registry[game_cds[x]] = { "netid_prefix": netids[x] }
+            if hasattr(mod, "get_mucha_info"):
+                enabled, game_cds, netid_prefixes = mod.get_mucha_info(
+                    self.config, self.config_dir
+                )
+                if enabled:
+                    for x in range(len(game_cds)):
+                        self.mucha_registry[game_cds[x]] = netid_prefixes[x]
 
         self.logger.info(f"Serving {len(self.mucha_registry)} games")
 
-    async def handle_boardauth(self, request: Request) -> bytes:
-        bod = await request.body()
-        req_dict = self.mucha_preprocess(bod)
+    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 {bod}"
+                f"Error processing mucha request {request.content.getvalue()}"
             )
-            return PlainTextResponse("RESULTS=000")
+            return b"RESULTS=000"
 
         req = MuchaAuthRequest(req_dict)
-        self.logger.debug(f"Mucha request {vars(req)}")
-        
-        if not req.gameCd or not req.gameVer or not req.sendDate or not req.countryCd or not req.serialNum:
-            self.logger.warning(f"Missing required fields - {vars(req)}")
-            return PlainTextResponse("RESULTS=000")
-
-        minfo = self.mucha_registry.get(req.gameCd, {})
-
-        if not minfo:
-            self.logger.warning(f"Unknown gameCd {req.gameCd} from {client_ip}")
-            return PlainTextResponse("RESULTS=000")
-
-        b_key = b""
-        for x in range(8):
-            b_key += req.sendDate[(x - 1) & 7].encode()
-        
-        b_iv = b_key # what the fuck namco
-
-        cipher = Blowfish.new(b_key, Blowfish.MODE_CBC, b_iv)
-        try:
-            sn_decrypt = cipher.decrypt(bytes.fromhex(req.serialNum))[:12].decode()
-        except Exception as e:
-            self.logger.error(f"Decrypt SN {req.serialNum} failed! - {e}")
-            return PlainTextResponse("RESULTS=000")
-
-        self.logger.info(f"Boardauth request from {sn_decrypt} ({client_ip}) for {req.gameVer}")
-
-        resp = MuchaAuthResponse(
-            f"{self.config.server.hostname}{':' + str(self.config.server.port) if not self.config.server.is_using_proxy else ''}"
-        )
-
-        netid = minfo.get('netid_prefix', "ABxN") + sn_decrypt[5:]
-
-        cab = await self.data.arcade.get_machine(netid)
-        if cab:
-            arcade = await self.data.arcade.get_arcade(cab['id'])
-            if not arcade:
-                self.logger.error(f"Failed to get arcade with id {cab['id']}")
-                return PlainTextResponse("RESULTS=000")
-
-            resp.AREA_0 = arcade["region_id"] or AllnetJapanRegionId.AICHI.name
-            resp.AREA_0_EN = arcade["region_id"] or AllnetJapanRegionId.AICHI.name
-            resp.AREA_FULL_0 = arcade["region_id"] or AllnetJapanRegionId.AICHI.name
-            resp.AREA_FULL_0_EN = arcade["region_id"] or AllnetJapanRegionId.AICHI.name
-            
-            resp.AREA_1 = arcade["country"] or cab['country'] or AllnetCountryCode.JAPAN.value
-            resp.AREA_1_EN = arcade["country"] or cab['country'] or AllnetCountryCode.JAPAN.value
-            resp.AREA_FULL_1 = arcade["country"] or cab['country'] or AllnetCountryCode.JAPAN.value
-            resp.AREA_FULL_1_EN = arcade["country"] or cab['country'] or AllnetCountryCode.JAPAN.value
-
-            resp.AREA_2 = arcade["city"] if arcade["city"] else ""
-            resp.AREA_2_EN = arcade["city"] if arcade["city"] else ""
-            resp.AREA_FULL_2 = arcade["city"] if arcade["city"] else ""
-            resp.AREA_FULL_2_EN = arcade["city"] if arcade["city"] else ""
-
-            resp.AREA_3 = ""
-            resp.AREA_3_EN = ""
-            resp.AREA_FULL_3 = ""
-            resp.AREA_FULL_3_EN = ""
-
-            resp.PREFECTURE_ID = arcade['region_id']
-            resp.COUNTRY_CD = arcade['country'] or cab['country'] or AllnetCountryCode.JAPAN.value
-            resp.PLACE_ID = req.placeId if req.placeId else f"{arcade['country'] or cab['country'] or AllnetCountryCode.JAPAN.value}{arcade['id']:04X}"
-            resp.SHOP_NAME = arcade['name']
-            resp.SHOP_NAME_EN = arcade['name']
-            resp.SHOP_NICKNAME = arcade['nickname']
-            resp.SHOP_NICKNAME_EN = arcade['nickname']
-
-        elif self.config.server.allow_unregistered_serials:
-            self.logger.info(f"Allow unknown serial {netid} ({sn_decrypt}) to auth")
-        
-        else:
-            self.logger.warning(f'Auth failed for NetID {netid}')
-            return PlainTextResponse("RESULTS=000")
-
-        self.logger.debug(f"Mucha response {vars(resp)}")
-
-        return PlainTextResponse(self.mucha_postprocess(vars(resp)))
-
-    async def handle_updatecheck(self, request: Request) -> bytes:
-        bod = await request.body()
-        req_dict = self.mucha_preprocess(bod)
-        client_ip = Utils.get_ip_addr(request)
-
-        if req_dict is None:
-            self.logger.error(
-                f"Error processing mucha request {bod}"
-            )
-            return PlainTextResponse("RESULTS=000")
-
-        req = MuchaUpdateRequest(req_dict)
-        self.logger.info(f"Updatecheck request from {req.serialNum} ({client_ip}) for {req.gameVer}")        
+        self.logger.info(f"Boardauth request from {client_ip} for {req.gameVer}")        
         self.logger.debug(f"Mucha request {vars(req)}")
 
         if req.gameCd not in self.mucha_registry:
             self.logger.warning(f"Unknown gameCd {req.gameCd}")
-            return PlainTextResponse("RESULTS=000")
+            return b"RESULTS=000"
 
-        resp = MuchaUpdateResponse(req.gameVer, f"{self.config.server.hostname}{':' + str(self.config.server.port) if not self.config.server.is_using_proxy else ''}")
+        # TODO: Decrypt S/N
+        b_key = b""
+        for x in range(8):
+            b_key += req.sendDate[(x - 1) & 7].encode()
+
+        cipher = Blowfish.new(b_key, Blowfish.MODE_ECB)
+        sn_decrypt = cipher.decrypt(bytes.fromhex(req.serialNum))
+        self.logger.debug(f"Decrypt SN to {sn_decrypt.hex()}")
+
+        resp = MuchaAuthResponse(
+            f"{self.config.server.hostname}{':' + str(self.config.server.port) if self.config.server.is_develop else ''}"
+        )
 
         self.logger.debug(f"Mucha response {vars(resp)}")
 
-        return PlainTextResponse(self.mucha_postprocess(vars(resp)))
+        return self.mucha_postprocess(vars(resp))
 
-    async def handle_dlstate(self, request: Request) -> bytes:
-        bod = await request.body()
-        req_dict = self.mucha_preprocess(bod)
+    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 {bod}"
+                f"Error processing mucha request {request.content.getvalue()}"
             )
-            return PlainTextResponse("RESULTS=000")
+            return b"RESULTS=000"
+
+        req = MuchaUpdateRequest(req_dict)
+        self.logger.info(f"Updatecheck request from {client_ip} for {req.gameVer}")        
+        self.logger.debug(f"Mucha request {vars(req)}")
+
+        if req.gameCd not in self.mucha_registry:
+            self.logger.warning(f"Unknown gameCd {req.gameCd}")
+            return b"RESULTS=000"
+
+        resp = MuchaUpdateResponse(req.gameVer, f"{self.config.server.hostname}{':' + str(self.config.server.port) if self.config.server.is_develop else ''}")
+
+        self.logger.debug(f"Mucha response {vars(resp)}")
+
+        return self.mucha_postprocess(vars(resp))
+
+    def handle_dlstate(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()}"
+            )
+            return b""
         
         req = MuchaDownloadStateRequest(req_dict)
-        self.logger.info(f"DownloadState request from {req.serialNum} ({client_ip}) for {req.gameCd} -> {req.updateVer}")        
+        self.logger.info(f"DownloadState request from {client_ip} for {req.gameCd} -> {req.updateVer}")        
         self.logger.debug(f"request {vars(req)}")
-        return PlainTextResponse("RESULTS=001")
+        return b"RESULTS=001"
 
     def mucha_preprocess(self, data: bytes) -> Optional[Dict]:
         try:
@@ -229,7 +169,7 @@ class MuchaAuthResponse:
         self.RESULTS = "001"
         self.AUTH_INTERVAL = "86400"
         self.SERVER_TIME = datetime.strftime(datetime.now(), "%Y%m%d%H%M")
-        self.SERVER_TIME_UTC = datetime.strftime(datetime.now(pytz.UTC), "%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.FILE_URL = f"https://{mucha_url}/file/"

core/templates/arcade/index.jinja

@@ -2,104 +2,18 @@
 {% block content %}
 {% if arcade is defined %}
 <h1>{{ arcade.name }}</h1>
-<h2>Assigned Machines</h2>
+<h2>PCBs assigned to this arcade <button class="btn btn-success" id="btn_add_cab" onclick="toggle_add_cab_form()">Add</button></h2>
 {% if success is defined and success == 3 %}
 <div style="background-color: #00AA00; padding: 20px; margin-bottom: 10px; width: 15%;">
 Cab added successfully
 </div>
 {% endif %}
-{% if success is defined and success == 1 %}
-<div style="background-color: #00AA00; padding: 20px; margin-bottom: 10px; width: 15%;">
-Info Updated
-</div>
-{% endif %}
-{% include "core/templates/widgets/err_banner.jinja" %}
 <ul style="font-size: 20px;">
-{% for c in cablst %}
-<li><a href="/cab/{{ c.id }}">{{ c.serial }}</a> ({{ c.game if c.game else "Any" }})</li>
+{% for c in arcade.cabs %}
+<li><a href="/cab/{{ c.id }}">{{ c.serial }} ({{ c.game }})</a>&nbsp;<button class="btn btn-secondary" onclick="prep_edit_form()">Edit</button>&nbsp;<button class="btn-danger btn">Delete</button></li>
 {% endfor %}
 </ul>
-Info
-<form style="max-width: 50%;" action="/shop/{{ arcade.id }}/info.update" method="post" id="shop_info">
-    <div class="row">
-        <div class="col mb-3">
-            <label for="name" class="form-label">Name</label>
-            <input type="text" class="form-control" id="name" name="name" maxlength="255" value="{{ arcade.name if arcade.name is not none else "" }}">
-        </div>
-        <div class="col mb-3">
-            <label for="nickname" class="form-label">Nickname</label>
-            <input type="text" class="form-control" id="nickname" name="nickname" maxlength="255" value="{{ arcade.nickname if arcade.nickname is not none else "" }}">
-        </div>
-    </div>
-    <div class="row">
-        <div class="col mb-3">
-            <label for="country" class="form-label">Country</label>
-            <select id="country" name="country" class="form-select bg-dark text-white">
-                <option value="JPN" {{ 'selected' if arcade.country == 'JPN' else ''}}>Japan</option>
-                <option value="USA" {{ 'selected' if arcade.country == 'USA' else ''}}>USA</option>
-                <option value="HKG" {{ 'selected' if arcade.country == 'HKG' else ''}}>Hong Kong</option>
-                <option value="SGP" {{ 'selected' if arcade.country == 'SGP' else ''}}>Singapore</option>
-                <option value="KOR" {{ 'selected' if arcade.country == 'KOR' else ''}}>South Korea</option>
-                <option value="TWN" {{ 'selected' if arcade.country == 'TWN' else ''}}>Taiwan</option>
-                <option value="CHN" {{ 'selected' if arcade.country == 'CHN' else ''}}>China</option>
-                <option value="AUS" {{ 'selected' if arcade.country == 'AUS' else ''}}>Australia</option>
-                <option value="IDN" {{ 'selected' if arcade.country == 'IDN' else ''}}>Indonesia</option>
-                <option value="MMR" {{ 'selected' if arcade.country == 'MMR' else ''}}>Myanmar</option>
-                <option value="MYS" {{ 'selected' if arcade.country == 'MYS' else ''}}>Malaysia</option>
-                <option value="NZL" {{ 'selected' if arcade.country == 'NZL' else ''}}>New Zealand</option>
-                <option value="PHL" {{ 'selected' if arcade.country == 'PHL' else ''}}>Philippines</option>
-                <option value="THA" {{ 'selected' if arcade.country == 'THA' else ''}}>Thailand</option>
-                <option value="VNM" {{ 'selected' if arcade.country == 'VNM' else ''}}>Vietnam</option>
-            </select>
-        </div>
-        <div class="col mb-3">
-            <label for="region1" class="form-label">Region 1</label>
-            <input type="text" class="form-control" id="region1" name="region1" maxlength="255" value="{{ arcade.state if arcade.state is not none else "" }}">
-        </div>
-        <div class="col mb-3">
-            <label for="region2" class="form-label">Region 2</label>
-            <input type="text" class="form-control" id="region2" name="region2" maxlength="255" value="{{ arcade.city if arcade.city is not none else "" }}">
-        </div>
-        <div class="col mb-3">
-            <label for="tz" class="form-label">Timezone</label>
-            <input type="text" class="form-control" id="tz" name="tz" placeholder="+09:00" maxlength="255" value="{{ arcade.timezone if arcade.timezone is not none else "" }}">
-        </div>
-    </div>
-    <div class="row">
-        <div class="col mb-3">
-            <label for="ip" class="form-label">VPN IP</label>
-            <input type="text" class="form-control" id="ip" name="ip" maxlength="39" value="{{ arcade.ip if arcade.ip is not none else "" }}">
-        </div>
-    </div>
-    {% if can_edit %}
-    <div class="row">
-        <div class="col mb-3">
-            <input type="submit" value="Update" class="btn btn-primary">
-        </div>
-    </div>
-    {% endif %}
-</form>
-{% if is_owner or is_acmod %}
-<br>
-<h2>Arcade Managers&nbsp;<button type="button" class="btn btn-success">Add</button></h2>
-<ul style="font-size: 20px;">
-{% for u in managers %}
-<li>{{ u.name }}:
-<label for="is_view_{{ u.user }}" class="form-label">View Arcade</label>
-<input type="checkbox" class="form-control-check" id="is_view_{{ u.user }}" name="is_view" {{ 'checked' if u.is_view else ''}}>&nbsp;|
-<label for="is_bookkeep_{{ u.user }}" class="form-label">View Bookkeeping</label>
-<input type="checkbox" class="form-control-check" id="is_bookkeep_{{ u.user }}" name="is_bookkeep" {{ 'checked' if u.is_bookkeep else ''}}>&nbsp;|
-<label for="is_edit_{{ u.user }}" class="form-label">Edit Arcade</label>
-<input type="checkbox" class="form-control-check" id="is_edit_{{ u.user }}" name="is_edit" {{ 'checked' if u.is_edit else ''}}>&nbsp;|
-<label for="is_owner_{{ u.user }}" class="form-label">Owner</label>
-<input type="checkbox" class="form-control-check" id="is_owner_{{ u.user }}" name="is_owner" {{ 'checked' if u.is_owner else ''}}>&nbsp;|
-<button type="submit" class="btn btn-primary">Update</button>
-<button type="button" class="btn btn-danger">Delete</button>
-</li>
-{% endfor %}
-</ul>
-{% endif %}
 {% else %}
 <h3>Arcade Not Found</h3>
 {% endif %}
-{% endblock content %}
+{% endblock content %}

core/templates/gate/gate.jinja

@@ -15,18 +15,18 @@
         -moz-appearance: textfield;
     }
 </style>
-<form id="login" style="max-width: 240px; min-width: 15%;" action="/gate/gate.login" method="post">
+<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">Access Code or Username</label><br>
-        <input form="login" class="form-control" name="access_code" id="access_code" placeholder="00000000000000000000" maxlength="20" required aria-describedby="access_code_help">
-        <div id="access_code_help" class="form-text">20 Digit access code from a card registered to your account, or your account username. (NOT your username from a game!)</div>
+        <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" aria-describedby="passwd_help">
-        <div id="passwd_help" class="form-text">Leave blank if registering for the webui. Your card must have been used on a game connected to this server to register.</div>
+        <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/templates/machine/index.jinja

@@ -1,113 +1,4 @@
 {% extends "core/templates/index.jinja" %}
 {% block content %}
-<script type="text/javascript">
-function swap_ota() {
-    let is_cab = document.getElementById("is_cab").checked;
-    let cbx_ota = document.getElementById("is_ota");
-
-    cbx_ota.disabled = !is_cab;
-
-    if (cbx_ota.disabled) {
-        cbx_ota.checked = false;
-    }
-}
-</script>
-<h1>Machine: {{machine.serial}}</h1>
-<h3>Arcade: <a href=/shop/{{ arcade.id }}>{{ arcade.name }}</a>{% if is_acmod %}&nbsp;<button class="btn btn-danger" data-bs-toggle="modal" data-bs-target="#reassign_modal">Reassign</button>{% endif %}</h3>
-{% include "core/templates/widgets/err_banner.jinja" %}
-{% if success is defined and success == 1 %}
-<div style="background-color: #00AA00; padding: 20px; margin-bottom: 10px; width: 15%;">
-Info Updated
-</div>
-{% endif %}
-{% if success is defined and success == 2 %}
-<div style="background-color: #00AA00; padding: 20px; margin-bottom: 10px; width: 15%;">
-Machine successfully reassigned
-</div>
-{% endif %}
-Info
-<form style="max-width: 50%;" action="/cab/{{ machine.id }}/info.update" method="post" id="mech_info">
-    <div class="row">
-        <div class="col mb-3">
-            <label for="game" class="form-label">Game</label>
-            <input type="text" class="form-control" id="game" name="game" placeholder="SXXX" maxlength="4" value="{{ machine.game if machine.game is not none else "" }}">
-        </div>
-        <div class="col mb-3">
-            <label for="country" class="form-label">Country Override</label>
-            <select id="country" name="country" class="form-select bg-dark text-white">
-                <option value="" {{ 'selected' if machine.country is none else ''}}>Same As Arcade</option>
-                <option value="JPN" {{ 'selected' if machine.country == 'JPN' else ''}}>Japan</option>
-                <option value="USA" {{ 'selected' if machine.country == 'USA' else ''}}>USA</option>
-                <option value="HKG" {{ 'selected' if machine.country == 'HKG' else ''}}>Hong Kong</option>
-                <option value="SGP" {{ 'selected' if machine.country == 'SGP' else ''}}>Singapore</option>
-                <option value="KOR" {{ 'selected' if machine.country == 'KOR' else ''}}>South Korea</option>
-                <option value="TWN" {{ 'selected' if machine.country == 'TWN' else ''}}>Taiwan</option>
-                <option value="CHN" {{ 'selected' if machine.country == 'CHN' else ''}}>China</option>
-                <option value="AUS" {{ 'selected' if machine.country == 'AUS' else ''}}>Australia</option>
-                <option value="IDN" {{ 'selected' if machine.country == 'IDN' else ''}}>Indonesia</option>
-                <option value="MMR" {{ 'selected' if machine.country == 'MMR' else ''}}>Myanmar</option>
-                <option value="MYS" {{ 'selected' if machine.country == 'MYS' else ''}}>Malaysia</option>
-                <option value="NZL" {{ 'selected' if machine.country == 'NZL' else ''}}>New Zealand</option>
-                <option value="PHL" {{ 'selected' if machine.country == 'PHL' else ''}}>Philippines</option>
-                <option value="THA" {{ 'selected' if machine.country == 'THA' else ''}}>Thailand</option>
-                <option value="VNM" {{ 'selected' if machine.country == 'VNM' else ''}}>Vietnam</option>
-            </select>
-        </div>
-        <div class="col mb-3">
-            <label for="tz" class="form-label">Timezone Override</label>
-            <input type="text" class="form-control" id="tz" name="tz" placeholder="+09:00" maxlength="6" value="{{ machine.timezone if machine.timezone is not none else "" }}">
-        </div>
-    </div>
-    <div class="row">
-        <div class="col mb-3">
-            <input type="checkbox" class="form-control-check" id="is_cab" name="is_cab" {{ 'checked' if machine.is_cab else ''}} onchange="swap_ota()">
-            <label for="is_cab" class="form-label">Real Cabinet</label>
-        </div>
-        <div class="col mb-3">
-            <input type="checkbox" class="form-control-check" id="is_ota" name="is_ota" {{ 'checked' if machine.ota_enable else ''}}>
-            <label for="is_ota" class="form-label">Allow OTA updates</label>
-        </div>
-        <div class="col mb-3">
-        </div>
-    </div>
-    <div class="row">
-        <div class="col mb-3">
-            <label for="memo" class="form-label">Memo</label>
-            <input type="text" class="form-control" id="memo" name="memo" maxlength="255" value="{{ machine.memo if machine.memo is not none else "" }}">
-        </div>
-    </div>
-    {% if can_edit %}
-    <div class="row">
-        <div class="col mb-3">
-            <input type="submit" value="Update" class="btn btn-primary">
-        </div>
-    </div>
-    {% endif %}
-</form>
-{% if is_acmod %}
-<form id="frm_reassign" method="post" action="/cab/{{ machine.id }}/reassign" style="outline: 0px;">
-<div class="modal" tabindex="-1" id="reassign_modal">
-  <div class="modal-dialog">
-    <div class="modal-content">
-      <div class="modal-header">
-        <h5 class="modal-title">Reassign {{ machine.serial }}</h5>
-        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-      </div>
-      <div class="modal-body">
-        <p>This will reassign this cabinet from the current arcade "{{ arcade.name }}" to the arcade who's ID you enter below.</p>
-        <label for="new_arcade" class="form-label">New Arcade</label>
-        <input type="text" class="form-control" id="new_arcade" name="new_arcade" value="{{ arcade.id }}">
-      </div>
-      <div class="modal-footer">
-        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
-        <button type="submit" class="btn btn-primary">Save changes</button>
-      </div>
-    </div>
-  </div>
-</div>
-</form>
-{% endif %}
-<script type="text/javascript">
-swap_ota();
-</script>
-{% endblock content %}
+<h1>Machine Management</h1>
+{% endblock content %}

core/templates/sys/index.jinja

@@ -4,7 +4,6 @@
 {% if error is defined %}
 {% include "core/templates/widgets/err_banner.jinja" %}
 {% endif %}
-<h2>Search</h2>
 <div class="row" id="rowForm">
     {% if "{:08b}".format(sesh.permissions)[6] == "1" %}
     <div class="col-sm-6" style="max-width: 25%;">
@@ -22,12 +21,7 @@
             OR
             <div class="form-group">
                 <label for="usrEmail">Email address</label>
-                <input type="email" class="form-control" id="usrEmail" name="usrEmail">
-            </div>
-            OR
-            <div class="form-group">
-                <label for="usrAc">Access Code</label>
-                <input type="text" class="form-control" id="usrAc" name="usrAc" maxlength="20" placeholder="00000000000000000000">
+                <input type="email" class="form-control" id="usrEmail" name="usrEmail" aria-describedby="emailHelp">
             </div>
             <br />
             <button type="submit" class="btn btn-primary">Search</button>
@@ -51,9 +45,6 @@
             <button type="submit" class="btn btn-primary">Search</button>
         </form>
     </div>
-    <div class="col-sm-6" style="max-width: 25%;">
-        <a href="/sys/logs"><button class="btn btn-primary">Event Logs</button></a>
-    </div>
     {% endif %}
 </div>
 <div class="row" id="rowResult" style="margin: 10px;">
@@ -72,126 +63,7 @@
     </div>
     {% endif %}
 </div>
-<h2>Add</h2>
 <div class="row" id="rowAdd">
-    {% if "{:08b}".format(sesh.permissions)[6] == "1" %}
-    <div class="col-sm-6" style="max-width: 25%;">
-        <form id="usrAdd" name="usrAdd" action="/sys/add.user" class="form-inline" method="POST">
-            <h3>Add User</h3>
-            <div class="form-group">
-                <label for="usrName">Username</label>
-                <input type="text" class="form-control" id="usrName" name="usrName">
-            </div>
-            <br>
-            <div class="form-group">
-                <label for="usrEmail">Email address</label>
-                <input type="email" class="form-control" id="usrEmail" name="usrEmail" required>
-            </div>
-            <br>
-            <div class="form-group">
-                <label for="usrPerm">Permission Level</label>
-                <input type="number" class="form-control" id="usrPerm" name="usrPerm" value="1">
-            </div>
-            <br />
-            <button type="submit" class="btn btn-primary">Add</button>
-        </form>
-    </div>
-    <div class="col-sm-6" style="max-width: 25%;">
-        <form id="cardAdd" name="cardAdd" action="/sys/add.card" class="form-inline" method="POST">
-            <h3>Add Card</h3>
-            <div class="form-group">
-                <label for="cardUsr">User ID</label>
-                <input type="number" class="form-control" id="cardUsr" name="cardUsr" required>
-            </div>
-            <br>
-            <div class="form-group">
-                <label for="cardAc">Access Code</label>
-                <input type="text" class="form-control" id="cardAc" name="cardAc" maxlength="20" placeholder="00000000000000000000" required>
-            </div>
-            <br>
-            <div class="form-group">
-                <label for="cardIdm">IDm/Chip ID</label>
-                <input type="text" class="form-control" id="cardIdm" name="cardIdm" disabled>
-            </div>
-            <br />
-            <button type="submit" class="btn btn-primary">Add</button>
-        </form>
-    </div>
-    {% endif %}
-    {% if "{:08b}".format(sesh.permissions)[5] == "1" %}
-    <div class="col-sm-6" style="max-width: 25%;">
-        <form id="shopAdd" name="shopAdd" action="/sys/add.shop" class="form-inline" method="POST">
-            <h3>Add Shop</h3>
-            <div class="form-group">
-                <label for="shopName">Name</label>
-                <input type="text" class="form-control" id="shopName" name="shopName">
-            </div>
-            <br>
-            <div class="form-group">
-                <label for="shopCountry">Country Code</label>
-                <input type="text" class="form-control" id="shopCountry" name="shopCountry" maxlength="3" placeholder="JPN">
-            </div>
-            <br />
-            <div class="form-group">
-                <label for="shopIp">VPN IP</label>
-                <input type="text" class="form-control" id="shopIp" name="shopIp">
-            </div>
-            <br />
-            <div class="form-group">
-                <label for="shopOwner">Owner User ID</label>
-                <input type="text" class="form-control" id="shopOwner" name="shopOwner">
-            </div>
-            <br />
-            <button type="submit" class="btn btn-primary">Add</button>
-        </form>
-    </div>
-    <div class="col-sm-6" style="max-width: 25%;">
-        <form id="cabAdd" name="cabAdd" action="/sys/add.cab" class="form-inline" method="POST">
-            <h3>Add Machine</h3>
-            <div class="form-group">
-                <label for="cabShop">Shop ID</label>
-                <input type="number" class="form-control" id="cabShop" name="cabShop" required>
-            </div>
-            <br>
-            <div class="form-group">
-                <label for="cabSerial">Serial</label>
-                <input type="text" class="form-control" id="cabSerial" name="cabSerial">
-            </div>
-            <br />
-            <div class="form-group">
-                <label for="cabGame">Game Code</label>
-                <input type="text" class="form-control" id="cabGame" name="cabGame" maxlength="4" placeholder="SXXX">
-            </div>
-            <br />
-            <button type="submit" class="btn btn-primary">Add</button>
-        </form>
-    </div>
-    {% endif %}
-</div>
-<div class="row" id="rowAddResult" style="margin: 10px;">
-    {% if "{:08b}".format(sesh.permissions)[6] == "1" %}
-    <div id="userAddResult" class="col-sm-6" style="max-width: 25%;">
-        {% if usradd is defined %}
-            <pre>Added user {{ usradd.username if usradd.username is not none else "with no name"}} with id {{usradd.id}} and password {{ usradd.password }}</pre>
-        {% endif %}
-    </div>
-    <div id="cardAddResult" class="col-sm-6" style="max-width: 25%;">
-        {% if cardadd is defined %}
-            <pre>Added {{ cardadd.access_code }} with id {{cardadd.id}} to user {{ cardadd.user }}</pre>
-        {% endif %}
-    </div>
-    {% endif %}
-    {% if "{:08b}".format(sesh.permissions)[5] == "1" %}
-    <div id="shopAddResult" class="col-sm-6" style="max-width: 25%;">
-        {% if shopadd is defined %}
-            <pre>Added Shop {{ shopadd.id }}</pre></a>
-        {% endif %}
-    </div>
-    <div id="cabAddResult" class="col-sm-6" style="max-width: 25%;">
-        {% if cabadd is defined %}
-            <pre>Added Machine {{ cabadd.id }} with serial {{ cabadd.serial }}</pre></a>
-        {% endif %}
-    </div>
-    {% endif %}
+
 </div>
 {% endblock content %}

core/templates/sys/logs.jinja

@@ -1,202 +0,0 @@
-{% extends "core/templates/index.jinja" %}
-{% block content %}
-<h1>Event Logs</h1>
-<table class="table table-dark table-striped-columns" id="tbl_events">
-    <caption>Viewing last 100 logs</caption>
-    <thead>
-        <tr>
-            <th>Severity</th>
-            <th>Timestamp</th>
-            <th>System</th>
-            <th>Name</th>
-            <th>User</th>
-            <th>Arcade</th>
-            <th>Machine</th>
-            <th>Game</th>
-            <th>Version</th>
-            <th>Message</th>
-            <th>Params</th>
-        </tr>
-    </thead>
-    {% if events is not defined or events|length == 0 %}
-    <tr>
-        <td colspan="11" style="text-align:center"><i>No Events</i></td>
-    </tr>
-    {% endif %}
-</table>
-<div id="div_tbl_ctrl">
-<select id="sel_per_page" onchange="update_tbl()">
-<option value="10" selected>10</option>
-<option value="25">25</option>
-<option value="50">50</option>
-<option value="100">100</option>
-</select>
-&nbsp;
-<button class="btn btn-primary" id="btn_prev" disabled onclick="chg_page(-1)"><<</button>
-<button class="btn btn-primary" id="btn_next" onclick="chg_page(1)">>></button>
-</div>
-<script type="text/javascript">
-{% if events is defined %}
-const TBL_DATA = {{events}};
-{% else %}
-const TBL_DATA = [];
-{% endif %}
-
-var per_page = 0;
-var page = 0;
-
-function update_tbl() {
-    if (TBL_DATA.length == 0) { 
-        document.getElementById("btn_next").disabled = true;
-        document.getElementById("btn_prev").disabled = true;
-        return;
-    }
-    var tbl = document.getElementById("tbl_events");
-    
-    for (var i = 0; i < per_page; i++) {
-        try{
-            tbl.deleteRow(1);
-        } catch {
-            break;
-        }
-    }
-
-    per_page = document.getElementById("sel_per_page").value;
-
-    if (per_page >= TBL_DATA.length) {
-        page = 0;
-        document.getElementById("btn_next").disabled = true;
-        document.getElementById("btn_prev").disabled = true;
-    }
-    
-    for (var i = 0; i < per_page; i++) {
-        let off = (page * per_page) + i;
-        if (off >= TBL_DATA.length) {
-            if (page != 0) {
-                document.getElementById("btn_next").disabled = true;
-                document.getElementById("btn_prev").disabled = false;
-            }
-            break;
-        }
-        
-        var data = TBL_DATA[off];
-        var row = tbl.insertRow(i + 1);
-        var cell_severity = row.insertCell(0);
-        switch (data.severity) {
-            case 10: 
-                cell_severity.innerHTML = "DEBUG";
-                row.classList.add("table-success");
-                break;
-            case 20: 
-                cell_severity.innerHTML = "INFO";
-                row.classList.add("table-info");
-                break;
-            case 30: 
-                cell_severity.innerHTML = "WARN";
-                row.classList.add("table-warning");
-                break;
-            case 40:
-                cell_severity.innerHTML = "ERROR";
-                row.classList.add("table-danger");
-                break;
-            case 50:
-                cell_severity.innerHTML = "CRITICAL";
-                row.classList.add("table-danger");
-                break;
-            default: 
-                cell_severity.innerHTML = "---";
-                row.classList.add("table-primary");
-                break;
-        }
-
-        var cell_ts = row.insertCell(1);
-        cell_ts.innerHTML = data.when_logged;
-        
-        var cell_mod = row.insertCell(2);
-        cell_mod.innerHTML = data.system;
-        
-        var cell_name = row.insertCell(3);
-        cell_name.innerHTML = data.type;
-        
-        var cell_usr = row.insertCell(4);
-        if (data.user == 'NONE') {
-            cell_usr.innerHTML = "---";
-        } else { 
-            cell_usr.innerHTML = "<a href=\"/user/" + data.user + "\">" + data.user + "</a>";
-        }
-
-        var cell_arcade = row.insertCell(5);
-        if (data.arcade == 'NONE') {
-            cell_arcade.innerHTML = "---";
-        } else { 
-            cell_arcade.innerHTML = "<a href=\"/shop/" + data.arcade + "\">" + data.arcade + "</a>";
-        }
-
-        var cell_machine = row.insertCell(6);
-        if (data.arcade == 'NONE') {
-            cell_machine.innerHTML = "---";
-        } else { 
-            cell_machine.innerHTML = "<a href=\"/cab/" + data.machine + "\">" + data.machine + "</a>";
-        }
-
-        var cell_game = row.insertCell(7);
-        if (data.game == 'NONE') {
-            cell_game.innerHTML = "---";
-        } else { 
-            cell_game.innerHTML = data.game;
-        }
-
-        var cell_version = row.insertCell(8);
-        if (data.version == 'NONE') {
-            cell_version.innerHTML = "---";
-        } else { 
-            cell_version.innerHTML = data.version;
-        }
-
-        var cell_msg = row.insertCell(9);
-        if (data.message == '') {
-            cell_msg.innerHTML = "---";
-        } else { 
-            cell_msg.innerHTML = data.message;
-        }
-
-        var cell_deets = row.insertCell(10);
-        if (data.details == '{}') {
-            cell_deets.innerHTML = "---";
-        } else { 
-            cell_deets.innerHTML = data.details;
-        }
-
-    }
-}
-
-function chg_page(num) {
-    var max_page = TBL_DATA.length / per_page;
-    console.log(max_page);
-    page = page + num;
-
-
-    if (page > max_page && max_page >= 1) {
-        page = max_page;
-        document.getElementById("btn_next").disabled = true;
-        document.getElementById("btn_prev").disabled = false;
-        return;
-    } else if (page < 0) {
-        page = 0;
-        document.getElementById("btn_next").disabled = false;
-        document.getElementById("btn_prev").disabled = true;
-        return;
-    } else if (page == 0) {
-        document.getElementById("btn_next").disabled = TBL_DATA.length == 0;
-        document.getElementById("btn_prev").disabled = true;
-    } else {
-        document.getElementById("btn_next").disabled = false;
-        document.getElementById("btn_prev").disabled = false;
-    }
-
-    update_tbl();
-}
-
-update_tbl();
-</script>
-{% endblock content %}

core/templates/user/index.jinja

@@ -28,28 +28,12 @@ function toggle_add_card_form() {
   }
 }
 
-function toggle_idm_disabled(is_disabled) {
-  document.getElementById("btn_add_card");
-  let dv = document.getElementById("add_card_container")
-
-  if (dv.style['display'] != "") {
-    btn.innerText = "Cancel";
-    dv.style['display'] = "";
-  } else {
-    btn.innerText = "Add";
-    dv.style['display'] = "none";
-  }
-}
-
-function prep_edit_form(access_code, chip_id, idm, card_type, u_memo, card_id) {
+function prep_edit_form(access_code, chip_id, idm, card_type, u_memo) {
   ac = document.getElementById("card_edit_frm_access_code");
   cid = document.getElementById("card_edit_frm_chip_id");
   fidm = document.getElementById("card_edit_frm_idm");
   memo = document.getElementById("card_edit_frm_memo");
 
-  
-  document.getElementById("card_edit_frm_card_id").value = card_id;
-
   if (chip_id == "None" || chip_id == undefined) {
     chip_id = ""
   }
@@ -65,14 +49,11 @@ function prep_edit_form(access_code, chip_id, idm, card_type, u_memo, card_id) {
   fidm.value = idm;
   memo.value = u_memo;
 
-  if (access_code.startsWith("3") || access_code.startsWith("010")) {
-    cid.disabled = false;
-    fidm.disabled = true;
-  } else if (access_code.startsWith("5") || access_code.startsWith("0008")) {
+  if (card_type == "AmusementIC") {
     cid.disabled = true;
     fidm.disabled = false;
   } else {
-    cid.disabled = true;
+    cid.disabled = false;
     fidm.disabled = true;
   }
 }
@@ -103,35 +84,16 @@ Card added successfully
 {% endif %}
 <div id="add_card_container" style="display: none; max-width: 33%;">
   <form action="/user/add.card" method="post", id="frm_add_card">
-    <div class="form-check">
-      <input type="radio" id="card_add_frm_type_aicc" value="0" name="card_add_frm_type" aria-describedby="aicc_help" onclick="document.getElementById('card_add_frm_idm').disabled = false;">
-      <label class="form-label" for="card_add_frm_type_aicc">AmusementIC</label>
-      <div id="aicc_help" class="form-text">Starts with 5. If you don't have the IDm, use the 0008 access code shown in-game</div>
-      <br>
-      <input type="radio" id="card_add_frm_type_old" value="1" name="card_add_frm_type" aria-describedby="old_help" onclick="document.getElementById('card_add_frm_idm').disabled = true;">
-      <label class="form-label" for="card_add_frm_type_old">Old Aime/Banapass</label>
-      <div id="old_help" class="form-text">Starts with 010 (aime) or 3 (banapass)</div>
-    </div>
-    
     <label class="form-label" for="card_add_frm_access_code">Access Code:</label>
     <input class="form-control" name="add_access_code" id="card_add_frm_access_code" maxlength="20" type="text" required aria-describedby="ac_help">
     <div id="ac_help" class="form-text">20 digit code on the back of the card.</div>
-    <label class="form-label" for="card_add_frm_access_code">IDm:</label>
-    <input class="form-control" name="add_idm" id="card_add_frm_idm" maxlength="16" type="text" aria-describedby="idm_help">
-    <div id="idm_help" class="form-text">AmusementIC cards only! 16 hexidecimal digits, sometimes called the serial number, gotten by scanning the card with a reader.</div>
-    <br>
     <button type="submit" class="btn btn-primary">Add</button>
   </form>
   <br>
 </div>
-{% if success is defined and success == 4 %}
-<div style="background-color: #00AA00; padding: 20px; margin-bottom: 10px; width: 15%;">
-Update successful
-</div>
-{% endif %}
 <ul style="font-size: 20px;">
 {% for c in cards %}
-<li>{{ c.access_code }} ({{ c.type if c.memo is none or not c.memo else c.memo }}): {{ c.status }}&nbsp;<button onclick="prep_edit_form('{{ c.access_code }}', '{{ c.chip_id}}', '{{ c.idm }}', '{{ c.type }}', '{{ c.memo }}', '{{ c.id }}')" data-bs-toggle="modal" data-bs-target="#card_edit" class="btn btn-secondary" id="btn_edit_card_{{ c.access_code }}">View</button>&nbsp;{% if c.status == 'Active'%}<button class="btn-warning btn">Lock</button>{% elif c.status == 'Locked' %}<button class="btn-warning btn">Unlock</button>{% endif %}&nbsp;<button class="btn-danger btn" {{ "disabled" if cards|length == 1 else ""}}>Delete</button></li>
+<li>{{ c.access_code }} ({{ c.type}}): {{ c.status }}&nbsp;<button onclick="prep_edit_form('{{ c.access_code }}', '{{ c.chip_id}}', '{{ c.idm }}', '{{ c.type }}', '{{ c.memo }}')" data-bs-toggle="modal" data-bs-target="#card_edit" class="btn btn-secondary" id="btn_edit_card_{{ c.access_code }}">Edit</button>&nbsp;{% if c.status == 'Active'%}<button class="btn-warning btn">Lock</button>{% elif c.status == 'Locked' %}<button class="btn-warning btn">Unlock</button>{% endif %}&nbsp;<button class="btn-danger btn">Delete</button></li>
 {% endfor %}
 </ul>
 
@@ -159,10 +121,19 @@ Update successful
 </form>
 
 {% if arcades is defined and arcades|length > 0 %}
-<h2>Arcades you manage</h2>
+<h2>Arcades</h2>
   <ul>
   {% for a in arcades %}
-    <li><h3><a href=/shop/{{a.id}}>{{ a.name }}</a></h3></li>
+    <li><h3>{{ a.name }}</h3>
+      {% if a.machines|length > 0 %}
+        <table>
+          <tr><th>Serial</th><th>Game</th><th>Last Seen</th></tr>
+          {% for m in a.machines %}
+            <tr><td>{{ m.serial }}</td><td>{{ m.game }}</td><td>{{ m.last_seen }}</td></tr>
+          {% endfor %}
+        </table>
+      {% endif %}
+    </li>
   {% endfor %}
   </ul>
 {% endif %}
@@ -171,31 +142,31 @@ Update successful
   <div class="modal-dialog">
     <div class="modal-content">
       <div class="modal-header">
-        <h1 class="modal-title fs-5" id="card_edit_label">Card Information</h1>
+        <h1 class="modal-title fs-5" id="card_edit_label">Edit Card</h1>
         <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
       </div>
       <div class="modal-body">
         <form action="/user/edit.card" method="post" id="frm_edit_card">
-          <input type="hidden" readonly name="card_edit_frm_card_id" id="card_edit_frm_card_id">
           <label class="form-label" for="card_edit_frm_access_code">Access Code:</label>
-          <input class="form-control-plaintext" readonly name="card_edit_frm_access_code" id="card_edit_frm_access_code" maxlength="20" type="text" required aria-describedby="ac_help">
+          <input class="form-control" readonly name="add_access_code" id="card_edit_frm_access_code" maxlength="20" type="text" required aria-describedby="ac_help">
           <div id="ac_help" class="form-text">20 digit code on the back of the card. If this is incorrect, contact a sysadmin.</div>
 
-          <label class="form-label" for="card_edit_frm_idm" id="card_edit_frm_idm_lbl">FeliCa IDm:</label>
-          <input class="form-control-plaintext" aria-describedby="idm_help" name="add_felica_idm" id="card_edit_frm_idm" maxlength="16" type="text" readonly>
-          <div id="idm_help" class="form-text">8 bytes that uniquly idenfites a FeliCa card. Obtained by reading the card with an NFC reader.</div>
-        
-          <label class="form-label" for="card_edit_frm_chip_id" id="card_edit_frm_chip_id_lbl">Mifare UID:</label>
-          <input class="form-control-plaintext" aria-describedby="chip_id_help" name="add_mifare_chip_id" id="card_edit_frm_chip_id" maxlength="8" type="text" readonly>
-          <div id="chip_id_help" class="form-text">4 byte integer that uniquly identifies a Mifare card. Obtained by reading the card with an NFC reader.</div>
-
           <label class="form-label" for="card_edit_frm_memo" id="card_edit_frm_memo_lbl">Memo:</label>
           <input class="form-control" aria-describedby="memo_help" name="add_memo" id="card_edit_frm_memo" maxlength="16" type="text">
           <div id="memo_help" class="form-text">Must be 16 characters or less.</div>
+
+          <label class="form-label" for="card_edit_frm_idm" id="card_edit_frm_idm_lbl">FeliCa IDm:</label>
+          <input class="form-control" aria-describedby="idm_help" name="add_felica_idm" id="card_edit_frm_idm" maxlength="16" type="text">
+          <div id="idm_help" class="form-text">8 bytes that uniquly idenfites a FeliCa card. Obtained by reading the card with an NFC reader.</div>
+        
+          <label class="form-label" for="card_edit_frm_chip_id" id="card_edit_frm_chip_id_lbl">Mifare UID:</label>
+          <input class="form-control" aria-describedby="chip_id_help" name="add_mifare_chip_id" id="card_edit_frm_chip_id" maxlength="8" type="text">
+          <div id="chip_id_help" class="form-text">4 byte integer that uniquly identifies a Mifare card. Obtained by reading the card with an NFC reader.</div>
+        </form>
       </div>
       <div class="modal-footer">
-        <button type="submit" class="btn btn-primary">Update Memo</button>
-        </form>
+        <button type="submit" class="btn btn-primary" form="frm_edit_card">Edit</button>
+        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
       </div>
     </div>
   </div>

core/templates/widgets/err_banner.jinja

@@ -19,18 +19,9 @@ New password not acceptable
 New Nickname too long
 {% elif error == 9 %}
 You must be logged in to preform this action
+New Nickname too long
 {% elif error == 10 %}
 Invalid serial number
-{% elif error == 11 %}
-Access Denied
-{% elif error == 12 %}
-Card already registered
-{% elif error == 13 %}
-AmusementIC Access Codes beginning with 5 must have IDm
-{% elif error == 14 %}
-Arcade does not exist
-{% elif error == 15 %}
-Some info failed to update
 {% else %}
 An unknown error occoured
 {% endif %}

core/title.py

@@ -80,17 +80,16 @@ class BaseServlet:
             cfg_dir (str): Config directory
 
         Returns:
-            Tuple[bool, List[str], List[str]]: Tuple where offset 0 is true if the game is enabled, false otherwise, and offset 1 is the game CDs handled
-            by this servlette, and offset 2 is mucha netID prefixes that should be used for each game CD. 
+            Tuple[bool, str]: Tuple where offset 0 is true if the game is enabled, false otherwise, and offset 1 is the game CD
         """
         return (False, [], [])
 
     async def render_POST(self, request: Request) -> bytes:
-        self.logger.warning(f"Game Does not dispatch POST")
+        self.logger.warn(f"Game Does not dispatch POST")
         return Response()
 
     async def render_GET(self, request: Request) -> bytes:
-        self.logger.warning(f"Game Does not dispatch GET")
+        self.logger.warn(f"Game Does not dispatch GET")
         return Response()
 
 class TitleServlet:

core/utils.py

@@ -1,48 +1,18 @@
-import importlib
+from typing import Dict, Any, Optional
+from types import ModuleType
+from starlette.requests import Request
 import logging
+import importlib
+from os import walk
+import jwt
 from base64 import b64decode
 from datetime import datetime, timezone
-from os import walk
-from types import ModuleType
-from typing import Any, Dict, Optional
-import math
-
-import jwt
-from starlette.requests import Request
 
 from .config import CoreConfig
 
-
-class _MissingSentinel:
-    __slots__: tuple[str, ...] = ()
-
-    def __eq__(self, other) -> bool:
-        return False
-
-    def __bool__(self) -> bool:
-        return False
-
-    def __hash__(self) -> int:
-        return 0
-
-    def __repr__(self):
-        return "..."
-
-
-MISSING: Any = _MissingSentinel()
-"""This is different from `None` in that its type is `Any`, and so it can be used
-as a placeholder for values that are *definitely* going to be initialized,
-so they don't have to be typed as `T | None`, which makes type checkers
-angry when an attribute is accessed.
-
-This can also be used for when `None` has actual meaning as a value, and so a
-separate value is needed to mean "unset"."""
-
-
 class Utils:
     real_title_port = None
     real_title_port_ssl = None
-
     @classmethod
     def get_all_titles(cls) -> Dict[str, ModuleType]:
         ret: Dict[str, Any] = {}
@@ -64,60 +34,28 @@ class Utils:
 
     @classmethod
     def get_ip_addr(cls, req: Request) -> str:
-        ip = req.headers.get("x-forwarded-for", req.client.host)
-        return ip.split(", ")[0]
-
+        return req.headers.get("x-forwarded-for", req.client.host)
+    
     @classmethod
     def get_title_port(cls, cfg: CoreConfig):
-        if cls.real_title_port is not None:
-            return cls.real_title_port
-
-        cls.real_title_port = (
-            cfg.server.proxy_port
-            if cfg.server.is_using_proxy and cfg.server.proxy_port
-            else cfg.server.port
-        )
+        if cls.real_title_port is not None: return cls.real_title_port
 
+        cls.real_title_port = cfg.server.proxy_port if cfg.server.is_using_proxy and cfg.server.proxy_port else cfg.server.port
+        
         return cls.real_title_port
-
+    
     @classmethod
     def get_title_port_ssl(cls, cfg: CoreConfig):
-        if cls.real_title_port_ssl is not None:
-            return cls.real_title_port_ssl
-
-        cls.real_title_port_ssl = (
-            cfg.server.proxy_port_ssl
-            if cfg.server.is_using_proxy and cfg.server.proxy_port_ssl
-            else 443
-        )
+        if cls.real_title_port_ssl is not None: return cls.real_title_port_ssl
 
+        cls.real_title_port_ssl = cfg.server.proxy_port_ssl if cfg.server.is_using_proxy and cfg.server.proxy_port_ssl else Utils.get_title_port(cfg)
+        
         return cls.real_title_port_ssl
 
-def floor_to_nearest_005(version: int) -> int:
-    return (version // 5) * 5
-
-def create_sega_auth_key(
-    aime_id: int,
-    game: str,
-    place_id: int,
-    keychip_id: str,
-    b64_secret: str,
-    exp_seconds: int = 86400,
-    err_logger: str = "aimedb",
-) -> Optional[str]:
+def create_sega_auth_key(aime_id: int, game: str, place_id: int, keychip_id: str, b64_secret: str, exp_seconds: int = 86400, err_logger: str = 'aimedb') -> Optional[str]:
     logger = logging.getLogger(err_logger)
     try:
-        return jwt.encode(
-            {
-                "aime_id": aime_id,
-                "game": game,
-                "place_id": place_id,
-                "keychip_id": keychip_id,
-                "exp": int(datetime.now(tz=timezone.utc).timestamp()) + exp_seconds,
-            },
-            b64decode(b64_secret),
-            algorithm="HS256",
-        )
+        return jwt.encode({ "aime_id": aime_id, "game": game, "place_id": place_id, "keychip_id": keychip_id, "exp": int(datetime.now(tz=timezone.utc).timestamp()) + exp_seconds }, b64decode(b64_secret), algorithm="HS256")
     except jwt.InvalidKeyError:
         logger.error("Failed to encode Sega Auth Key because the secret is invalid!")
         return None
@@ -125,19 +63,10 @@ def create_sega_auth_key(
         logger.error(f"Unknown exception occoured when encoding Sega Auth Key! {e}")
         return None
 
-
-def decode_sega_auth_key(
-    token: str, b64_secret: str, err_logger: str = "aimedb"
-) -> Optional[Dict]:
+def decode_sega_auth_key(token: str, b64_secret: str, err_logger: str = 'aimedb') -> Optional[Dict]:
     logger = logging.getLogger(err_logger)
     try:
-        return jwt.decode(
-            token,
-            "secret",
-            b64decode(b64_secret),
-            algorithms=["HS256"],
-            options={"verify_signature": True},
-        )
+        return jwt.decode(token, "secret", b64decode(b64_secret), algorithms=["HS256"], options={"verify_signature": True})
     except jwt.ExpiredSignatureError:
         logger.error("Sega Auth Key failed to validate due to an expired signature!")
         return None
@@ -153,3 +82,4 @@ def decode_sega_auth_key(
     except Exception as e:
         logger.error(f"Unknown exception occoured when decoding Sega Auth Key! {e}")
         return None
+    

dbutils.py

@@ -1,15 +1,14 @@
 #!/usr/bin/env python3
 import argparse
-import asyncio
 import logging
-from os import W_OK, access, environ, mkdir, path
-
+from os import mkdir, path, access, W_OK
 import yaml
+import asyncio
 
-from core.config import CoreConfig
 from core.data import Data
+from core.config import CoreConfig
 
-async def main():
+if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Database utilities")
     parser.add_argument(
         "--config", "-c", type=str, help="Config folder to use", default="config"
@@ -23,14 +22,13 @@ async def main():
     parser.add_argument("--email", "-e", type=str, help="Email for the new user")
     parser.add_argument("--access_code", "-a", type=str, help="Access code for new/transfer user", default="00000000000000000000")
     parser.add_argument("--message", "-m", type=str, help="Revision message")
-    parser.add_argument("action", type=str, help="create, upgrade, downgrade, create-owner, migrate, create-revision, create-autorevision")
+    parser.add_argument("action", type=str, help="create, upgrade, create-owner, migrate, create-revision")
     args = parser.parse_args()
 
-    environ["ARTEMIS_CFG_DIR"] = args.config
-
     cfg = CoreConfig()
     if path.exists(f"{args.config}/core.yaml"):
         cfg_dict = yaml.safe_load(open(f"{args.config}/core.yaml"))
+        cfg_dict.get("database", {})["loglevel"] = "info"
         cfg.update(cfg_dict)
 
     if not path.exists(cfg.server.log_dir):
@@ -45,32 +43,23 @@ async def main():
     data = Data(cfg)
 
     if args.action == "create":
-        await data.create_database()
+        data.create_database()
     
     elif args.action == "upgrade":
         data.schema_upgrade(args.version)
 
-    elif args.action == "downgrade":
-        if not args.version:
-            logging.getLogger("database").error(f"Version argument required for downgrade")
-            exit(1)
-        data.schema_downgrade(args.version)
-
     elif args.action == "create-owner":
-        await data.create_owner(args.email, args.access_code)
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(data.create_owner(args.email, args.access_code))
+        data.schema_upgrade(args.version)
 
     elif args.action == "migrate":
-        await data.migrate()
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(data.migrate())
 
     elif args.action == "create-revision":
-        await data.create_revision(args.message)
-
-    elif args.action == "create-autorevision":
-        await data.create_revision_auto(args.message)
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(data.create_revision(args.message))
 
     else:
         logging.getLogger("database").info(f"Unknown action {args.action}")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

docker-compose.yml

@@ -6,7 +6,6 @@ services:
     volumes:
       - ./aime:/app/aime
       - ./configs/config:/app/config
-      - ./cert:/app/cert
 
     environment:
       CFG_DEV: 1
@@ -15,8 +14,7 @@ services:
       CFG_CORE_MEMCACHED_HOSTNAME: ma.memcached
       CFG_CORE_AIMEDB_KEY: <INSERT AIMEDB KEY HERE>
       CFG_CHUNI_SERVER_LOGLEVEL: debug
-    
-    ##Note: comment 80 and 8443 when you plan to use with nginx
+
     ports:
       - "80:80"
       - "8443:8443"
@@ -66,18 +64,3 @@ services:
     ports:
     - "9090:8080"
 
-  ##Note: uncomment to allow use nginx with artemis, don't forget to comment 80 and 8443 ports on artemis
-  #nginx:
-  #  hostname: ma.nginx
-  #  image: nginx:latest
-  #  ports:
-  #    - "80:80"
-  #    - "443:443"
-  #    - "8443:8443"
-  #  volumes:
-  ##Note: copy example_config/example_nginx.conf to configs/nginx folder, edit it and rename to nginx.conf
-  #    - ./configs/nginx:/etc/nginx/conf.d
-  #    - ./cert:/etc/nginx/cert
-  #    - ./logs/nginx:/var/log/nginx
-  #  depends_on:
-  #    - app

docs/INSTALL_LINUX.md

@@ -1,107 +0,0 @@
-# Installing ARTEMiS on Linux
-This guide assumes a fresh install of Debian 12 or Rasperry Pi OS. If you're using a different distrubution, your package manager commands and package names may be different then what's listed below. Please check with your repository's package manager for package names.
-
-## Install prerequisits
-### Python
-Some installs may come with python already installed. You can verify this by trying the following commands:
-- `python --version`
-- `python3 --version`
-- `python3.<minor version> --version` where `<minor version>` is a python 3 release (eg 11, 10)
-
-If your python version is at least 3.7, you can move to the next step
-
-### Libraries and other software
-ARTEMiS depends on mysql and memcached. As stated above, package names may vary by distrubution, but this is generally what you should expect to install.
-#### Rasperry Pi OS
-`sudo apt install git mariadb-server python3-pip memcached libmemcached-dev `
-
-#### Debian 12
-`sudo apt install git mariadb-server python3-pip memcached libmemcached-dev default-libmysqlclient-dev pkg-config`
-
-### Optional: Install proxy
-If you intend to use a proxy (recomended for public-facing production setups), we recomend nginx
-`sudo apt install nginx`
-
-## Database setup
-### mysql_secure_installation
-If you already have your database installed and configured, and are able to log in, skip down to the [Creating the database](#creating-the-database) section below. Otherwise, setup your newly installed database.
-
-`sudo mysql_secure_installation`
-
-Leave the root password blank, do not switch to unix socket, do reset the root password to something secure, and answer yes to the rest of the prompts. You can then log into your database with `sudo mysql`
-
-### Creating the database
-Once you're logged in, run the following commands, as root, to set up our database. Make sure you note down whatever you decide to make the password for the aime account, as you will need it to configure artemis.
-
-```sql
-CREATE USER 'aime'@'localhost' IDENTIFIED BY '<password>';
-CREATE DATABASE aime;
-GRANT Alter,Create,Delete,Drop,Index,Insert,References,Select,Update ON aime.* TO 'aime'@'localhost';
-quit
-```
-We have now set up our new user, `aime`, created a database called `aime` and given our user all the permissions it needs on every table of that database.
-
-### Configure memcached
-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
-
-Restart memcached using:  sudo systemctl restart memcached
-
-## Getting ARTEMiS
-### Clone from gitea
-use `git clone https://gitea.tendokyu.moe/Hay1tsme/artemis.git` to pull down ARTEMiS into a folder called `artemis` created at wherever your current working directory is. `cd` into `artemis`.
-
-### Optional: Create a venv
-Python venvs are a way to install and manage packages on a per-project basis and are recomended on systems that will have multiple python scripts running on them to avoid dependancy issues. If this server will be running ARTEMiS and ONLY ARTEMiS, then it is possible to get away without creating one. If you do want to create one, you will have to install an additional package:
-
-`sudo apt install python3-venv` (like above, package name may vary depending on distro and python version)
-
-Now, simply run `python -m venv .venv` (may have to use python3 or python 3.11 instead of python) to create your virtual environment in the folder `.venv`. In order to install packages and run scripts in this environment, you have to 'activate' it by running `source .venv/bin/activate`. Your terminal should now have (venv) appended to it.
-
-### Optional: Use the develop branch
-By default, pulling down ARTEMiS from gitea will pull the `master` branch. This branch is updated less frequently, but is considered stable and ready for production use. If you'd rather have more updates, but a possibility for instability or bugs, you can switch to the develop branch by running `git checkout develop`. You can run `git checkout master` to switch back to stable.
-
-## Install python libraries
-Run `pip install -r requirements.txt` to install all of ARTEMiS' dependencies. If any installs fail, you may have missed a step in the [Install prerequisits](#install-prerequisits) section above. If you're absolutly sure you didn't, submit an issue on gitea.
-
-## Configuration
-### Copy example configs
-From the `artemis` directory, run `cp -r example_config config` to copy the example configuration files to a new folder called `config`. All of the config changes you make will be done in the `config` folder.
-
-### Optional: Generate AimeDB and Frontend JWT Secrets
-AimeDB and the frontend utalize JSON Web Tokens (JWT) for card authentication and session cookies respectivly. While generating a secret for AimeDB is optional, if you intend to run the frontend, a secret is required. You can generate a secret easily by running:
-
-`openssl rand --base64 64`
-
-With 64 being the number of bytes. You shouldn't need to go higher then 64, but you can if desired. **NOTE: When pasting secrets into the config file, make sure you remove any newlines!**
-
-### Edit `core.yaml`
-Before editing `core.yaml`, you should familiarize yourself with the name and function of each of the config options. You can find a full list in [config.md](config.md)
-
-Open `core.yaml` in the `config` folder in your prefered text editor. The only configuration option that it is absolutly mandatory to change is `aimedb`->`key`. This key must be set for the server to start, and the key must be correct, otherwise you will not be able to process aimedb requests. The correct key is floating around online, and finding it is left as an excersie to the reader. 
-
-Another option that should be changed is `database`->`password` to be the password you set when you created your database user. You did write it down somewhere, right?
-
-Since you are presumably not running the games on the same computer you're installing this server on, you're going to want to change `server`->`hostname` to be whatever hostname or IP address other PCs can reach this server by. Note that some games reject IPs and require hostnames, so setting a hostname is always recomended over an IP.
-
-### Edit game configs
-Every game has their own yaml file with settings that you may want to tweek. `InitialD Zero` and `Pokken` both have `hostname` fields in their config file that you should edit, and some games support encryption, if supplied with proper keys.
-
-### A note about IDZ
-InitialD Zero is currently the only game where it is required to specify encryption information (the AES key and at least one RSA key) for the game to start. These keys are, like the aimedb key, floating around online and will not be provided. If you don't have the keys, and don't plan on anybody connecting to your server playing InitialD Zero, it's best to set `enabled` to `False` in idz.yaml to disable the game.
-
-## Create database tables
-ARTEMiS uses alembic to manage datbase versioning. `dbutils.py` acts as a wrapper for alembic, and can execute some necessassary database functions. To create the database tables, run `python dbutils.py create`. Confirm that there are no errors, and you're good to go. If you intend to use the frontend, you may also want to run `python dbutils.py create-owner -a <your 20 digit access code here>` to create a superuser account to log in with.
-
-## Run ARTEMiS
-Once you have everything configured properly, simply run `python index.py` to start ARTEMiS. Verify that clients can connect to all services (allnet, billing, aimedb, and game servers) and setup is complete.

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

@@ -1,77 +1,102 @@
-# Installing ARTEMiS on Windows
-This guide assumes a fresh install of Windows 10. Please be aware that due to the lack of memcached and the general woes of running a server on Windows, this is only recommended for local setups or small hosting-for-the-homies type servers.
+# 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
 
-## Install prerequisites
-### Python
-- Python versions from 3.8 to 3.11 work with ARTEMiS. We recommend 3.11.
-    - https://www.python.org/ftp/python/3.11.7/python-3.11.7-amd64.exe
-- Install using whichever options best suit your environment, making sure that the Python executable is on path, such that you can open CMD, type `python --version` and see the version of Python you have installed.
-- If you already have a working version of Python installed, skip this step.
+# 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
 
-### MariaDB
-- It is always recommended to use MariaDB over MySQL because Oracle is a terrible company.
-- While the latest release of v10 is recommended, as it is an LTS release, v11 should work fine.
-    - https://ftp.osuosl.org/pub/mariadb//mariadb-10.11.6/winx64-packages/mariadb-10.11.6-winx64.msi
-- REMEMBER YOUR ROOT PASSWORD SO YOU CAN LOG IN IN FUTURE STEPS.
+## Install MySQL 8.0
+1. Download MySQL 8.0 Server : [Link](https://dev.mysql.com/get/Downloads/MySQLInstaller/mysql-installer-community-8.0.34.0.msi)
+2. Install mysql-installer-web-community-8.0.34.0.msi
+    1. Click on "Add ..." on the side
+    2. Click on the "+" next to MySQL Servers
+    3. Make sure MySQL Server 8.0.34 - 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. Change `<Enter Password Here>` to a new password for the user aime, type those commands to create your user and the database
 
-### Git
-- While technically optional, it is strongly recommended to obtain ARTEMiS via git clone instead of just downloading it.
-    - https://git-scm.com/download/win
-- It is recommended to use Notepad++ as the default editor (if you have it installed), other than that, the default settings should be fine.
-
-### Optional: GUI database viewer
-- Having a GUI database editor is recommended but not required.
-- MariaDB will try to install HeidiSQL, but we recommend DBeaver.
-    - https://dbeaver.io/download/
-
-## Obtain ARTEMiS
-### Via git (recommended)
-- `git clone https://gitea.tendokyu.moe/Hay1tsme/artemis.git` via cmd in whatever folder you want to install ARTEMiS.
-    - You can switch to the develop branch for latest changes via `git checkout develop`.
-
-### Via http download
-- Download [here](https://gitea.tendokyu.moe/Hay1tsme/artemis/archive/master.zip).
-    - Develop branch can be found [here](https://gitea.tendokyu.moe/Hay1tsme/artemis/archive/develop.zip).
-- Extract the zip file somewhere.
-
-## Database setup
-- Log into your server as root, either via GUI (recommended) or CMD
-- Create the `aime` user, replace `<password>` with a password you choose. Remember it!
-```
-CREATE USER 'aime'@'localhost' IDENTIFIED BY '<password>';
+```sql
+CREATE USER 'aime'@'localhost' IDENTIFIED BY '<Enter Password Here>';
 CREATE DATABASE aime;
 GRANT Alter,Create,Delete,Drop,Index,Insert,References,Select,Update ON aime.* TO 'aime'@'localhost';
+FLUSH PRIVILEGES;
+exit;
 ```
-- If you create the database via a GUI, make sure you grant all the above permissions.
 
-## Create a venv
-- Python virtual environments are a good way to manage packages and make dealing with python and pip easier.
-- `python -m pip venv venv`
-- `venv\Scripts\activate.bat` to activate the venv whenever you need to interact with ARTEMiS.
-- All the rest of the steps assume your venv is activated.
+## Install Python modules
+1. Change your work path to the artemis-master folder using 'cd' and install the requirements:
 
-## Install pip modules
-- `pip install -r requirements.txt`
+```shell
+pip install -r requirements.txt
+```	
 
-## Setup configuration
-- Create a new `config` folder and copy the files in `example_config` over.
-- edit `core.yaml`
-    - Put the password you created for the aime user into the `database` section.
-    - Put in the aimedb key (YOU DO NOT GENERATE THIS KEY, FIND IT SOMEWHERE).
-    - Set your hostname to be whatever hostname or IP address games can reach your server at (many games reject localhost and 127.0.0.1).
-    - Optional: generate base64-encoded secrets for aimedb and frontend using something like `openssl rand -base64 64`. It is advised to make all secrets different.
-    - See [config.md](docs/config.md) for a full list of options.
-- edit `idz.yaml`
-    - If you don't plan on anyone using your server to play Initial D Zero, it is best to disable it to cut down on console spam on boot.
-- Edit other game yamls
-    - Add keys, set hostnames, ports, etc. Specific settings will depend on the game. See [game_specific_info](docs/game_specific_info.md).
+## Copy/Rename the folder `example_config` to `config`
 
-## Create Database Tables
-- `python dbutils.py create`
+## Adjust `config/core.yaml`
 
-## Firewall
-- If you're planning on serving games not on your PC, open at least ports 80, 8443, and 22345 in windows firewall
-    - Also set `listen_address` to either your local IP to serve on your LAN, or `0.0.0.0` for all interfaces, to accept connections from other places.
+1. Make sure to change the server `hostname` to be set to your local machine IP (ex.: 192.168.xxx.xxx) 
+    - In case you want to run this only locally, set the following values:
 
-## Start ARTEMiS
-- `python index.py`
+```yaml
+server:
+    listen_address: 0.0.0.0
+title: 
+    hostname: 192.168.xxx.xxx
+```
+
+1. Adjust the proper MySQL information you created earlier
+```yaml
+database:
+  host: "localhost"
+  username: "aime"
+  password: "<Enter Password Here>"
+  name: "aime"
+```
+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
+
+```shell
+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
+```shell
+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:
+
+```shell
+pip install -r requirements.txt -U
+```

docs/config.md

@@ -8,7 +8,7 @@
 - `allow_user_registration`: Allows users to register in-game via the AimeDB `register` function. Disable to be able to control who can use cards on your server. Default `True`
 - `allow_unregistered_serials`: Allows games that do not have registered keychips to connect and authenticate. Disable to restrict who can connect to your server. Recomended to disable for production setups. Default `True`
 - `name`: Name for the server, used by some games in their default MOTDs. Default `ARTEMiS`
-- `is_develop`: Flags that the server is a development instance, and enables some useful development features. Disable for production setups. Default `True`.
+- `is_develop`: Flags that the server is a development instance without a proxy standing in front of it. Setting to `False` tells the server not to listen for SSL, because the proxy should be handling all SSL-related things, among other things. Default `True`
 - `is_using_proxy`: Flags that you'll be using some other software, such as nginx, to proxy requests, and to send `proxy_port` or `proxy_port_ssl` to games instead of `port`. Default `False`
 - `proxy_port`: Which port your front-facing proxy will be listening on. Ignored if `is_using_proxy` is `False` or if set to `0`. Default `0`
 - `proxy_port`: Which port your front-facing proxy will be listening for ssl connections on. Ignored if `is_using_proxy` is `False` or if set to `0`. Default `0`
@@ -17,8 +17,8 @@
 - `strict_ip_checking`: Rejects clients if there is no IP in the `arcade` table for the respective arcade. Default `False`
 ## Title
 - `loglevel`: Logging level for the title server. Default `info`
-- `reboot_start_time`: 24 hour JST time that clients will see as the start of maintenance period, ex `04:00`. A few games or early version will report errors if it is empty, ex maimai DX 1.00
-- `reboot_end_time`: 24 hour JST time that clients will see as the end of maintenance period, ex `07:00`. this must be set to 7:00 am for some game, please do not change it.
+- `reboot_start_time`: 24 hour JST time that clients will see as the start of maintenance period, ex `04:00`. Leave blank for no maintenance time. Default: `""`
+- `reboot_end_time`: 24 hour JST time that clients will see as the end of maintenance period, ex `05:00`. Leave blank for no maintenance time. Default: `""`
 ## Database
 - `host`: Host of the database. Default `localhost`
 - `username`: Username of the account the server should connect to the database with. Default `aime`
@@ -26,45 +26,31 @@
 - `name`: Name of the database the server should expect. Default `aime`
 - `port`: Port the database server is listening on. Default `3306`
 - `protocol`: Protocol used in the connection string, e.i `mysql` would result in `mysql://...`. Default `mysql`
-- `ssl_enabled`: Enforce SSL to be used in the connection string. Default `False`
-- `sha2_password`: Whether or not the password in the connection string should be hashed via SHA2. Default `False`
+- `sha2_password`: Weather or not the password in the connection string should be hashed via SHA2. Default `False`
 - `loglevel`: Logging level for the database. Default `info`
 - `memcached_host`: Host of the memcached server. Default `localhost`
 ## Frontend
-- `enable`: Whether or not the frontend servlet should run. Frontend can still be run via `python -m uvicorn core.frontend:app` even if this is set to `False`. Default `False`
+- `enable`: Weather or not the frontend should run. Default `False`
 - `port`: Port the frontend should listen on. Default `8080`
 - `loglevel`: Logging level for the frontend server. Default `info`
 - `secret`: Base64-encoded JWT secret for session cookies, generated by you. Default `""`
 ## Allnet
-- `standalone`: Whether allnet should launch it's own servlet on it's own port, or be part of the main servlet on the default port. Disable if you either have something proxying `naominet.jp` requests to port 80, or have port 80 set in `server` -> `port`
-- `port`: Port the allnet server should listen for connections on if it's running standalone. Games are hardcoded to ask for port `80` so only change if you have a proxy redirecting properly. Ignored if `standalone` is `False`. Default `80`
+- `standalone`: Weather allnet should be launched as a standalone service on it's own port.
+- `port`: Port the billing server should listen for connections on. Games are hardcoded to ask for port `80` so only change if you have a proxy redirecting properly. Default `80`
 - `loglevel`: Logging level for the allnet server. Default `info`
 - `allow_online_updates`: Allow allnet to distribute online updates via DownloadOrders. This system is currently non-functional, so leave it disabled. Default `False`
 - `update_cfg_folder`: Folder where delivery INI files will be checked for. Ignored if `allow_online_updates` is `False`. Default `""`
-- `allnet_lite_keys:` Allnet Lite (Chinese Allnet) PowerOn/DownloadOrder unique keys. Default ` `
-```yaml
-  allnet_lite_keys: 
-    "SDJJ": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
-    "SDHJ": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
-    "SDGB": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
-```
 ## Billing
-- `standalone`: Whether the billing server should launch it's own servlet on it's own port, or be part of the main servlet on the default port. Setting this to `True` requires that you have `ssl_key` and `ssl_cert` set. Default `False`
+- `standalone`: Weather or not the billing server should be launched as a standalone service on it's own port. Setting this to `True` requires that you have `ssl_key` and `ssl_cert` set. Default `False`
 - `loglevel`: Logging level for the billing server. Default `info`
 - `port`: Port the billing server should listen for connections on. Games are hardcoded to ask for port `8443` so only change if you have a proxy redirecting properly. Ignored if `standalone` is `False`. Default `8443`
 - `ssl_key`: Location of the ssl server key for the billing server. Ignored if `standalone` is `False`. Default `cert/server.key`
 - `ssl_cert`: Location of the ssl server certificate for the billing server. Ignored if `standalone` is `False`.  Must match the CA distributed to users or the billing server will not connect. Default `cert/server.pem`
 - `signing_key`: Location of the RSA Private key used to sign billing requests. Must match the public key distributed to users or the billing server will not connect. Default `cert/billing.key`
 ## Aimedb
-- `enable`: Whether or not aimedb should run. Default `True`
-- `listen_address`: IP Address or hostname that the aimedb server will listen for connections on. Leave this blank to use the listen address under `server`. Default `""`
+- `enable`: Weather or not aimedb should run. Default `True`
 - `loglevel`: Logging level for the aimedb server. Default `info`
 - `port`: Port the aimedb server should listen for connections on. Games are hardcoded to ask for port `22345` so only change if you have a proxy redirecting properly. Default `22345`
 - `key`: Key to encrypt/decrypt aimedb requests and responses. MUST be set or the server will not start. If set incorrectly, your server will not properly handle aimedb requests. Default `""`
 - `id_secret`: Base64-encoded JWT secret for Sega Auth IDs. Leaving this blank disables this feature. Default `""`
 - `id_lifetime_seconds`: Number of secons a JWT generated should be valid for. Default `86400` (1 day)
-## Chimedb
-- `enable`: Whether or not chimedb should run. Default `False`
-- `loglevel`: Logging level for the chimedb server. Default `info`
-- `key`: Key to hash chimedb requests and responses. MUST be set or the server will not start. If set incorrectly, your server will not properly handle chimedb requests. Default `""`
-

docs/game_specific_info.md

@@ -9,15 +9,7 @@ using the megaime database. Clean installations always create the latest databas
 To upgrade the core database and the database for every game, execute:
 
 ```shell
-python dbutils.py upgrade
-```
-
-If you are using the old master branch that was not setup with alembic, make sure to do the following steps in order:
-- Pull down latest master/develop
-- Update core.yaml
-- Back up your existing database
-```shell
-python dbutils.py migrate
+python dbutils.py autoupgrade
 ```
 
 # Table of content
@@ -26,14 +18,11 @@ python dbutils.py migrate
     - [CHUNITHM](#chunithm)
     - [crossbeats REV.](#crossbeats-rev)
     - [maimai DX](#maimai-dx)
-    - [Project Diva](#hatsune-miku-project-diva)
     - [O.N.G.E.K.I.](#o-n-g-e-k-i)
     - [Card Maker](#card-maker)
     - [WACCA](#wacca)
     - [Sword Art Online Arcade](#sao)
-    - [Initial D Zero](#initial-d-zero)
-    - [Initial D THE ARCADE](#initial-d-the-arcade)
-    - [Pokken Tournament](#pokken)
+	- [Initial D THE ARCADE](#initial-d-the-arcade)
 
 
 # Supported Games
@@ -60,15 +49,12 @@ Games listed below have been tested and confirmed working.
 
 ### SDHD/SDBT
 
-| Version ID | Version Name           |
-| ---------- | ---------------------- |
-| 11         | CHUNITHM NEW!!         |
-| 12         | CHUNITHM NEW PLUS!!    |
-| 13         | CHUNITHM SUN           |
-| 14         | CHUNITHM SUN PLUS      |
-| 15         | CHUNITHM LUMINOUS      |
-| 16         | CHUNITHM LUMINOUS PLUS |
-| 17         | CHUNITHM VERSE         |
+| Version ID | Version Name        |
+| ---------- | ------------------- |
+| 11         | CHUNITHM NEW!!      |
+| 12         | CHUNITHM NEW PLUS!! |
+| 13         | CHUNITHM SUN        |
+| 14         | CHUNITHM SUN PLUS   |
 
 
 ### Importer
@@ -79,37 +65,27 @@ In order to use the importer locate your game installation folder and execute:
 python read.py --game 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, Avatar Accesories, Nameplates, Characters, Trophies, Map Icons, and System Voices.
+The importer for Chunithm will import: Events, Music, Charge Items and Avatar Accesories.
 
 ### Config
 
 Config file is located in `config/chuni.yaml`.
 
-| Option                | Info                                                                                                                                      |
-|-----------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
-| `news_msg`            | If this is set, the news at the top of the main screen will be displayed (up to Chunithm Paradise Lost)                                   |
-| `name`                | If this is set, all players that are not on a team will use this one by default.                                                          |
-| `use_login_bonus`     | This is used to enable the login bonuses                                                                                                  |
-| `stock_tickets`       | If this is set, specifies tickets to auto-stock at login. Format is a comma-delimited list of IDs. Defaults to None                       |
-| `stock_count`         | Ignored if stock_tickets is not specified. Number to stock of each ticket. Defaults to 99                                                 |
-| `forced_item_unlocks` | Frontend UI customization overrides that allow all items of given types to be used (instead of just those unlocked/purchased by the user) |
-| `crypto`              | This option is used to enable the TLS Encryption                                                                                          |
+| Option           | Info                                                                                                           |
+|------------------|----------------------------------------------------------------------------------------------------------------|
+| `news_msg`       | If this is set, the news at the top of the main screen will be displayed (up to Chunithm Paradise Lost)        |
+| `name`           | If this is set, all players that are not on a team will use this one by default.                               |
+| `use_login_bonus`| This is used to enable the login bonuses                                                                       |
+| `crypto`         | This option is used to enable the TLS Encryption                                                               |
 
 
-If you would like to use network encryption, add the keys to the `keys` section under `crypto`, where the key
-is the version ID for Japanese (SDHD) versions and `"{versionID}_int"` for Export (SDGS) versions, and the value
-is an array containing `[key, iv, salt, iter_count]` in order.
-
-`iter_count` is optional for all Japanese (SDHD) versions but may be required for some Export (SDGS) versions.
-You will receive an error in the logs if it needs to be specified.
+**If you would like to use network encryption, the following will be required underneath but key, iv and hash are required:**
 
 ```yaml
 crypto:
   encrypted_only: False
   keys:
     13: ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000"]
-    "13_int": ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000", 42]
-	"13_chn": ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000", 8]
 ```
 
 ### Database upgrade
@@ -117,7 +93,7 @@ crypto:
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
+python dbutils.py --game SDBT upgrade
 ```
 
 ### Online Battle
@@ -157,15 +133,12 @@ INSERT INTO aime.chuni_profile_team (teamName) VALUES (<teamName>);
 Team names can be regular ASCII, and they will be displayed ingame.
 
 ### Favorite songs
-Favorites can be set through the Frontend Web UI for songs previously played. Alternatively, you can set the songs that will be in a user's Favorite Songs category using the following SQL entries:
+You can set the songs that will be in a user's Favorite Songs category using the following SQL entries:
 ```sql
 INSERT INTO aime.chuni_item_favorite (user, version, favId, favKind) VALUES (<user>, <version>, <songId>, 1);
 ```
 The songId is based on the actual ID within your version of Chunithm.
 
-### Profile Customization
-The Frontend Web UI supports configuration of the userbox, avatar (NEW!! and newer), map icon (AMAZON and newer), and system voice (AMAZON and newer).
-
 
 ## crossbeats REV.
 
@@ -194,18 +167,10 @@ Config file is located in `config/cxb.yaml`.
 
 ## maimai DX
 
-### Presents
-Presents are items given to the user when they login, with a little animation (for example, the KOP song was given to the finalists as a present). To add a present, you must insert it into the `mai2_item_present` table. In that table, a NULL version means any version, a NULL user means any user, a NULL start date means always open, and a NULL end date means it never expires. Below is a list of presents one might wish to add:
-
-| Game Version | Item ID | Item Kind            | Item Description                           | Present Description                                                        |
-|--------------|---------|----------------------|--------------------------------------------|----------------------------------------------------------------------------|
-| BUDDiES (21) | 409505  | Icon (3)             | 旅行スタンプ(月面基地) (Travel Stamp - Moon Base)    | Officially obtained on the webui with a serial number, for project raputa  |
-| PRiSM (23)   | 3       | KaleidxScopeKey (15) | 紫の鍵 (Purple Key)                           | Officially obtained on the webui with a serial number, for KaleidxScope    |
-
 ### Versions
 
 | Game Code | Version ID | Version Name            |
-|-----------|------------|-------------------------|
+| --------- | ---------- | ----------------------- |
 | SBXL      | 0          | maimai                  |
 | SBXL      | 1          | maimai PLUS             |
 | SBZF      | 2          | maimai GreeN            |
@@ -227,10 +192,6 @@ Presents are items given to the user when they login, with a little animation (f
 | SDEZ      | 18         | maimai DX UNiVERSE PLUS |
 | SDEZ      | 19         | maimai DX FESTiVAL      |
 | SDEZ      | 20         | maimai DX FESTiVAL PLUS |
-| SDEZ      | 21         | maimai DX BUDDiES       |
-| SDEZ      | 22         | maimai DX BUDDiES PLUS  |
-| SDEZ      | 23         | maimai DX PRiSM         |
-
 
 ### Importer
 
@@ -254,36 +215,11 @@ The importer for maimai Pre-DX will import Events and Music. Not all games will
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
+python dbutils.py --game SDEZ upgrade
 ```
 
 Pre-Dx uses the same database as DX, so only upgrade using the SDEZ game code!
 
-### Config
-
-Config file is located in `config/mai2.yaml`.
-
-| Option                | Info                                                                                                                                      |
-|-----------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
-| `crypto`              | This option is used to enable the TLS Encryption                                                                                          |
-
-
-If you would like to use network encryption, add the keys to the `keys` section under `crypto`, where the key
-is the version ID for Japanese (SDEZ) versions and `"{versionID}_int"` for Export (SDGA) versions, and the value
-is an array containing `[key, iv, salt]` in order.
-
-Just copy your salt in here, no need to convert anything.
-
-
-```yaml
-crypto:
-  encrypted_only: False
-  keys:
-    23: ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000"]
-    "23_int": ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000"]
-	"23_chn": ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000"]
-```
-
 ## Hatsune Miku Project Diva
 
 ### SBZV
@@ -309,14 +245,10 @@ the Shop, Modules and Customizations.
 
 Config file is located in `config/diva.yaml`.
 
-| Option               | Info                                                                                             |
-| -------------------- | ------------------------------------------------------------------------------------------------ |
-| `festa_enable`       | Enable or disable the ingame festa                                                               |
-| `festa_add_VP`       | Set the extra VP you get when clearing a song, if festa is not enabled no extra VP will be given |
-| `festa_multiply_VP`  | Multiplier for festa add VP                                                                      |
-| `festa_end_time`     | Set the date time for when festa will end and not show up in game anymore                        |
-| `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  |
+| 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 |
 
 ### Custom PV Lists (databanks)
 
@@ -327,24 +259,7 @@ In order to use custom PV Lists, simply drop in your .dat files inside of /title
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
-```
-
-### Using NGINX
-
-Diva's netcode does not send a `Host` header with it's network requests. This renders it incompatable with NGINX as configured in the example config, because nginx relies on the header to determine how to proxy the request. If you'd still like to use NGINX with diva, please see the sample config below.
-
-```conf
-server {
-    listen 80 default_server;
-    server_name _;
-
-    location / {
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_pass_request_headers on;
-        proxy_pass http://127.0.0.1:8080/;
-    }
-}
+python dbutils.py --game SBZV upgrade
 ```
 
 ## O.N.G.E.K.I.
@@ -400,7 +315,7 @@ crypto:
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
+python dbutils.py --game SDDT upgrade
 ```
 
 ### Controlling Events (Ranking Event, Technical Challenge Event, Mission Event)
@@ -491,11 +406,7 @@ After that, on next login the present should be received (or whenever it suppose
   * UNiVERSE PLUS: Yes
   * FESTiVAL: Yes (added in A031)
   * FESTiVAL PLUS: Yes (added in A035)
-  * BUDDiES: Yes (added in A039)
-  * BUDDiES PLUS: Yes (added in A047)
-* O.N.G.E.K.I.:
-  * bright MEMORY: Yes
-  * bright MEMORY Act.3 (added in A046)
+* O.N.G.E.K.I. bright MEMORY: Yes
 
 
 ### Importer
@@ -631,7 +542,7 @@ Config file is located in `config/wacca.yaml`.
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
+python dbutils.py --game SDFE upgrade
 ```
 
 ### VIP Rewards
@@ -683,7 +594,7 @@ Below is a list of VIP rewards. Currently, VIP is not implemented, and thus thes
 In order to use the importer locate your game installation folder and execute:
 
 ```shell
-python read.py --game SDEW --version 0 --binfolder /titles/sao/data/
+python read.py --game SDEW --version <version ID> --binfolder /path/to/game/extractedassets
 ```
 
 The importer for SAO will import all items, heroes, support skills and titles data.
@@ -704,36 +615,23 @@ Config file is located in `config/sao.yaml`.
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
+python dbutils.py --game SDEW upgrade
 ```
 
 ### Notes
-- Defrag Match and online coop requires a cloud instance of Photon and a working application ID
+- Defrag Match will crash at loading
+- Co-Op Online is not supported
+- Shop is not functionnal
 - Player title is currently static and cannot be changed in-game
-- QR Card Scanning of existing cards requires them to be registered on the webui
-- Daily Missions not implemented
-- Terminal functionality is almost entirely untested
+- QR Card Scanning currently only load a static hero
+
+**Network hashing in GssSite.dll must be disabled**
 
 ### Credits for SAO support:
 
-- Midorica - Network Support
+- Midorica - Limited Network Support
 - Dniel97 - Helping with network base
 - tungnotpunk - Source
-- Hay1tsme - fixing many issues with the original implemetation
-
-## Initial D Zero
-### SDDF
-
-| Version ID | Version Name         |
-| ---------- | -------------------- |
-| 0          | Initial D Zero v1.10 |
-| 1          | Initial D Zero v1.30 |
-| 2          | Initial D Zero v2.10 |
-| 3          | Initial D Zero v2.30 |
-
-### Info
-
-TODO, probably just leave disabled unless you're doing development things for it.
 
 ## Initial D THE ARCADE
 
@@ -780,7 +678,7 @@ Config file is located in `config/idac.yaml`.
 Always make sure your database (tables) are up-to-date:
 
 ```shell
-python dbutils.py upgrade
+python dbutils.py --game SDGT upgrade
 ```
 
 ### Notes
@@ -865,82 +763,3 @@ python dbutils.py upgrade
 
 A huge thanks to all people who helped shaping this project to what it is now and don't want to be mentioned here.
 
-## Pokken
-
-### SDAK
-
-| Version ID | Version Name |
-| ---------- | ------------ |
-| 0          | Pokken       |
-
-### Config
-
-Config file is `pokken.yaml`
-
-#### server
-
-| Option | Info | Default |
-| ------ | ---- | ------- | 
-| `hostname` | Hostname override for allnet to tell the game where to connect. Useful for local setups that need to use a different hostname for pokken's proxy. Otherwise, it should match `server`->`hostname` in `core.yaml`. | `localhost` | 
-| `enabled` | `True` if the pokken service should be enabled. `False` otherwise.  | `True` | 
-| `loglevel` | String indicating how verbose pokken logs should be. Acceptable values are `debug`, `info`, `warn`, and `error`. | `info` | 
-| `auto_register` | For games that don't use aimedb, this controls weather connecting cards that aren't registered should automatically be registered when making a profile. Set to `False` to require cards be already registered before being usable with Pokken. | `True` | 
-| `enable_matching` | If `True`, allow non-local matching. This doesn't currently work because BIWA, the matching protocol the game uses, is not understood, so this should be set to `False`. | `False` | 
-| `stun_server_host` |  Hostname of the STUN server the game will use for matching. | `stunserver.stunprotocol.org` (might not work anymore? recomend changing) | 
-| `stun_server_port` |  Port for the external STUN server. Will probably be moved to the `ports` section in the future. | `3478` | 
-
-#### ports
-| Option | Info | Default |
-| ------ | ---- | ------- | 
-| `game` | Override for the title server port sent by allnet. Useful for local setups utalizing NGINX. | `9000` |
-| `admission` | Port for the admission server used in global matching. May be obsolited later. | `9001` |
-
-### Connecting to Artemis
-
-Pokken is a bit tricky to get working due to it having a hard requirement of the connection being HTTPS. This is simplified somewhat by Pokken simply not validating the certificate in any way, shape or form (it can be self-signed, expired, for a different domain, etc.) but it does have to be there. The work-around is to spin up a local NGINX (or other proxy) instance and point traffic back to artemis. See below for a sample nginx config:
-`nginx.conf`
-```conf
-# This example assumes your artemis instance is configured to listed on port 8080, and your certs exists at /path/to/cert and are called title.crt and title.key.
-server {
-	listen 443 ssl;
-	server_name your.hostname.here;
-
-	ssl_certificate /path/to/cert/title.crt;
-	ssl_certificate_key /path/to/cert/title.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=0";
-	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://127.0.0.1:8080/;
-	}
-}
-```
-`pokken.yaml`
-```yaml
-server:
-  hostname: "your.hostname.here"
-  enable: True
-  loglevel: "info"
-  auto_register: True
-  enable_matching: False
-  stun_server_host: "stunserver.stunprotocol.org"
-  stun_server_port: 3478
-
-ports:
-  game: 443
-  admission: 9001
-```
-
-### Info
-
-The arcade release is missing a few fighters and supports compared to the switch version. It may be possible to mod these in in the future, but not much headway has been made on this as far as I know. Mercifully, the game uses the pokedex number (illustration_book_no) wherever possible when referingto both fighters and supports. Customization is entirely done on the webui. Artemis currently only supports changing your name, gender, and supporrt teams, but more is planned for the future.
-
-### Credits
-Special thanks to Pocky for pointing me in the right direction in terms of getting this game to function at all, and Lightning and other pokken cab owners for doing testing and reporting bugs/issues.

docs/migrating.md

@@ -1,34 +0,0 @@
-# Migrating from an older build of ARTEMiS
-If you haven't updated artemis in a while, you may find that configuration options have moved, been renamed, or no longer exist. This document exists to help migrate from legacy versions of artemis to newer builds.
-
-## Dependancies
-Make sure your dependiences are up to date with what's required to run artemis. A simple `pip install -r requirements.txt` will get you up to date.
-
-## Database
-Database migration is required if you are using a version of artemis that still uses the old custom-rolled database versioning system (raw SQL scripts). Artemis now uses alembic to manage database versioning, and you will need to move to this new system.
-
-**BEFORE DOING ANY DATABASE WORK, ALWAYS MAKE SURE YOU HAVE FUNCTIONAL, UP-TO-DATE BACKUPS!!**
-
-For almost all situations, simply running `python dbutils.py migrate` will do the job. This will upgrade you to the latest version of the old system, move you over to alembic, then upgrade you to the newest alembic version. If you encounter any errors or data loss, you should report this as a bug to our issue tracker.
-
-## Configuration
-Configuration management is the sewage cleaning of the sysadmin world. It sucks and nobody likes to do it, but it needs to be done or everyone ends up in deep shit. This section will walk through what configuration options have changed, and how to set them properly.
-
-### core.yaml
-`title`->`hostname` is now `server`->`hostname`. This hostname is what gets sent to clients in response to auth requests, so it should be both accessable from whereever the client is, and point properly to the title server.
-
-With the move to starlette and uvicorn, different services now run as seperate USGI applications. `billing`->`standalone` and `allnet`->`standalone` are flags that determine weather the service runs as a stand-alone service, on it's own seperate port, or as a part of the whole application. For example, setting `billing`->`standalone` to `True` will cause a seperate instance of the billing server to spin up listening on 8443 with SSL using the certs listed in the config file. Setting it to `False` will just allow the main server to also serve `/request/` and assumes that something is standing in front of it proxying 8443 SSL to whatever `server`->`port` is set to.
-
-Beforehand, if `server`->`is_develop` was `False`, the server assumed that there was a proxy standing in front of it, proxying requests to proper channels. This was, in hindsight, a very dumb assumption. Now, `server`->`is_using_proxy` is what flags the server as having nginx or another proxy in front of it. The effects of setting this to true are somewhat game-dependant, but generally artemis will use the port listed in `server`->`proxy_port` (and `server`->`proxy_port_ssl` for SSL connections, as defined by the games) instead of `server`->`port`. If set to 0, `server`->`proxy_port` will default to what `server`->`port` (and `server`->`proxy_port_ssl` will default to 443) make sure to set them accordingly. Note that some title servers have their own needs and specify their own specific ports. Refer to [game_specific_info.md](docs/game_specific_info.md) for more infomation. (For example, pokken requires SSL using an older, weaker certificate, and always requires the port to be sent even if it's port 443)
-
-`index.py`'s args have changed. You can now override what port the title server listens on with `-p` and tell the server to use ssl with `-s`.
-
-Rather then having a `standalone` config variable, the frontend is a seperate wsgi app entirely. Having `enable` be `True` will launch it on the port specified in the config file. Otherwise, the fontend will not run.
-
-`title`->`reboot_start_time`/`reboot_end_time` allow you to specify when the games should be told network maintanence is happening. It's exact implementation depends on the game. Do note that many games will beave unexpectly if `reboot_end_time` is not `07:00`.
-
-If you wish to make use of aimedb's SegaAuthId system to better protect the few title servers that actually use it, set `aimedb`->`id_secret` to base64-encoded random bytes (32 is a good length) using something like `openssl rand -base64 64`. If you intend to use the frontend, the same thing must be done for `frontend`->`secret` or you won't be able to log in.
-
-`mucha`'s only option is now just log level.
-
-`aimedb` now has it's own `listen_address` field, in case you want to proxy everything but aimedb, so it can still listen on `0.0.0.0` instead of `127.0.0.1`.

docs/prod.md

@@ -13,13 +13,9 @@ Step 1 is to edit your artemis configuration. Some recomended changes:
 - `allow_unregistered_serials` -> `False`
 ### `billing`
 - `standalone` -> `False`
-### `allnet`
-- `standalone` -> `False`
 ### `frontend`
 - `enable` -> `True` if you want the frontend
-- `port` -> `8090` if you're using the default nginx config, otherwise whatever port your proxy will be sending requests to
-### `aimedb`
-- `listen_address` -> `0.0.0.0` unless you're proxying aimedb requests (not recomended at this time), in which case, leave this option unchanged
+- `port` -> `8080` if you're using the default nginx config
 
 If you plan to serve artemis behind a VPN, these additional settings are also recomended
 - `check_arcade_ip` -> `True`

example_config/cardmaker.yaml

@@ -8,6 +8,6 @@ version:
     chuni: 2.00.00
     maimai: 1.20.00
   1:
-    ongeki: 1.45.01
-    chuni: 2.25.00
-    maimai: 1.45.00
+    ongeki: 1.35.03
+    chuni: 2.10.00
+    maimai: 1.30.00

example_config/chuni.yaml

@@ -2,29 +2,13 @@ server:
   enable: True
   loglevel: "info"
   news_msg: ""
-  use_https: False # for CRYSTAL PLUS and later or SUPERSTAR and later
 
 team:
   name: ARTEMiS # If this is set, all players that are not on a team will use this one by default.
 
 mods:
   use_login_bonus: True
-  # stock_tickets allows specified ticket IDs to be auto-stocked at login. Format is a comma-delimited string of ticket IDs
-  # note: quanity is not refreshed on "continue" after set - only on subsequent login
-  stock_tickets: 
-  stock_count: 99
 
-  # Allow use of all available customization items in frontend web ui
-  # note: This effectively makes every available item appear to be in the user's inventory. It does _not_ override the "disableFlag" setting on individual items
-  # warning: This can result in pushing a lot of data, especially the userbox items. Recommended for local network use only.
-  forced_item_unlocks:
-    map_icons: False
-    system_voices: False  
-    avatar_accessories: False
-    nameplates: False
-    trophies: False
-    character_icons: False
-      
 version:
   11:
     rom: 2.00.00
@@ -38,15 +22,6 @@ version:
   14:
     rom: 2.15.00
     data: 2.15.00
-  15:
-    rom: 2.20.00
-    data: 2.20.00
-  16:
-    rom: 2.25.00
-    data: 2.25.00
-  17:
-    rom: 2.30.00
-    data: 2.30.00
 
 crypto:
   encrypted_only: False

example_config/core.yaml

@@ -18,7 +18,7 @@ server:
 title:
   loglevel: "info"
   reboot_start_time: "04:00"
-  reboot_end_time: "07:00" # this must be set to 7:00 am for some game, please do not change it
+  reboot_end_time: "05:00"
 
 database:
   host: "localhost"
@@ -27,7 +27,6 @@ database:
   name: "aime"
   port: 3306
   protocol: "mysql"
-  ssl_enabled: False
   sha2_password: False
   loglevel: "info"
   enable_memcached: True
@@ -45,8 +44,6 @@ allnet:
   loglevel: "info"
   allow_online_updates: False
   update_cfg_folder: ""
-  save_billing: True
-  allnet_lite_keys: []
 
 billing:
   standalone: True
@@ -58,17 +55,11 @@ billing:
 
 aimedb:
   enable: True
-  listen_address: ""
   loglevel: "info"
   port: 22345
   key: ""
   id_secret: ""
   id_lifetime_seconds: 86400
 
-chimedb:
-  enable: False
-  loglevel: "info"
-  key: ""
-
 mucha:
   loglevel: "info"

example_config/cxb.yaml

@@ -1,4 +1,4 @@
 server:
   enable: True
   loglevel: "info"
-  use_https: True
+  use:https: True

example_config/diva.yaml

@@ -1,10 +1,7 @@
 server:
   enable: True
   loglevel: "info"
-  festa_enable: True
-  festa_add_VP: "20,5"
-  festa_multiply_VP: "1,2"
-  festa_end_time: "2029-01-01 00:00:00.0"
+  banner_msg: ""
 
 mods:
   unlock_all_modules: True

example_config/idz.yaml

@@ -1,5 +1,5 @@
 server:
-  enable: False
+  enable: True
   loglevel: "info"
   hostname: ""
   news: ""

example_config/mai2.yaml

@@ -1,22 +1,14 @@
 server:
   enable: True
   loglevel: "info"
-  use_https: False # for DX and later
 
 deliver:
   enable: False
   udbdl_enable: False
   content_folder: ""
 
-chart_deliver: #for Prism and later
-  enable: False
-  chart_folder: ""
-
 uploads:
   photos: False
   photos_dir: ""
   movies: False
   movies_dir: ""
-
-crypto:
-  encrypted_only: False

example_config/nginx_example.conf

@@ -6,7 +6,7 @@ server {
 	location / {
 		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 		proxy_pass_request_headers on;
-		proxy_pass http://127.0.0.1:8080/;
+		proxy_pass http://localhost:8080/;
 	}
 }
 
@@ -18,7 +18,7 @@ server {
 	location / {
 		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 		proxy_pass_request_headers on;
-		proxy_pass http://127.0.0.1:8080/;
+		proxy_pass http://localhost:8080/;
 	}
 }
 
@@ -38,9 +38,7 @@ server {
 	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://127.0.0.1:8080/;
+		proxy_pass http://localhost:8080/;
 	}
 }
 
@@ -60,55 +58,7 @@ server {
 	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://127.0.0.1:8080/;
-	}
-}
-
-# WAHLAP Billing, they use 443 port
-# comment this out if running billing standalone
-# still not work for some reason, please set
-# billing=127.0.0.1 in segatools.ini for now and looking for fix
-server {
-	listen 443 ssl;	
-	server_name bl.sys-all.cn;
-	
-	ssl_certificate /path/to/cert/server.pem;
-	ssl_certificate_key /path/to/cert/server.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=0";
-	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://127.0.0.1:8080/;
-	}
-}
-
-server {
-	listen 443 ssl;	
-	server_name bl.sys-allnet.cn;
-	
-	ssl_certificate /path/to/cert/server.pem;
-	ssl_certificate_key /path/to/cert/server.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=0";
-	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://127.0.0.1:8080/;
+		proxy_pass http://localhost:8080/;
 	}
 }
 
@@ -120,7 +70,7 @@ server {
     location / {
         return 301 https://$host$request_uri;
 		# If you don't want https redirection, or are using something like cloudflare to manage HTTPS, comment out the line above and uncomment the line below
-		# proxy_pass http://127.0.0.1:8090/;
+		# proxy_pass http://localhost:8080/;
     }
 }
 
@@ -146,6 +96,6 @@ server {
 	location / {
 		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 		proxy_pass_request_headers on;
-		proxy_pass http://127.0.0.1:8090/;
+		proxy_pass http://localhost:8080/;
 	}
 }

example_config/ongeki.yaml

@@ -7,12 +7,12 @@ gachas:
   enabled_gachas:
     - 1011
     - 1012
-    # - 1043
-    # - 1067
-    # - 1068
-    # - 1069
-    # - 1070
-    # - 1071
+    - 1043
+    - 1067
+    - 1068
+    - 1069
+    - 1070
+    - 1071
     - 1072
     - 1073
     - 1074
@@ -30,22 +30,12 @@ gachas:
     - 1156
     - 1163
     - 1164
-    # 5th anniversary gacha
-    - 1165
-    # 2024 gacha
-    - 1166
-    # 6th anniversary gacha
-    - 1167
-    # 2025 gacha
-    - 1168
 
 version:
   6:
     card_maker: 1.30.01
   7:
     card_maker: 1.35.03
-  8:
-    card_maker: 1.45.01
 
 crypto:
   encrypted_only: False

example_config/sao.yaml

@@ -2,19 +2,12 @@ server:
   enable: True
   loglevel: "info"
   auto_register: True
-  photon_app_id: "7df3a2f6-d69d-4073-aafe-810ee61e1cea"
-  data_version: 1
-  game_version: 33
 
 crypt:
   enable: False
   key: ""
+  iv: ""
 
 hash:
   verify_hash: False
-  hash_base: ""
-
-card:
-  enable: True
-  crypt_password: ""
-  crypt_salt: ""
+  hash_base: ""

index.py

@@ -6,8 +6,7 @@ import uvicorn
 import logging
 import asyncio
 
-from core.config import CoreConfig
-from core.aimedb import AimedbServlette
+from core import CoreConfig, AimedbServlette
 
 async def launch_main(cfg: CoreConfig, ssl: bool) -> None:
     if ssl:
@@ -41,8 +40,7 @@ async def launch_billing(cfg: CoreConfig) -> None:
         log_level="info" if cfg.server.is_develop else "critical",
         ssl_version=3,
         ssl_certfile=cfg.billing.ssl_cert,
-        ssl_keyfile=cfg.billing.ssl_key,
-        ssl_ciphers="DEFAULT:!aNULL:!eNULL:!MD5:!3DES:!DES:!RC4:!IDEA:!SEED:!aDSS:!SRP:!PSK",
+        ssl_keyfile=cfg.billing.ssl_key
     )
     server = uvicorn.Server(server_cfg)
     await server.serve()

read.py

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
 import argparse
-import asyncio
-import logging
-import os
 import re
-from logging.handlers import TimedRotatingFileHandler
-from os import path
-from typing import List, Optional
-
-import coloredlogs
+import os
 import yaml
+from os import path
+import logging
+import coloredlogs
+import asyncio
+
+from logging.handlers import TimedRotatingFileHandler
+from typing import List, Optional
 
 from core import CoreConfig, Utils
 
@@ -44,7 +44,7 @@ class BaseReader:
         pass
 
 
-async def main():
+if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Import Game Information")
     parser.add_argument(
         "--game",
@@ -140,12 +140,8 @@ async def main():
     for dir, mod in titles.items():
         if args.game in mod.game_codes:
             handler = mod.reader(config, args.version, bin_arg, opt_arg, args.extra)
-            
-            await handler.read()
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(handler.read())
             
 
     logger.info("Done")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

readme.md

@@ -4,105 +4,38 @@ A network service emulator for games running SEGA'S ALL.NET service, and similar
 # Supported games
 Games listed below have been tested and confirmed working. Only game versions older then the version currently active in arcades, or games versions that have not recieved a major update in over one year, are supported.
 
++ CHUNITHM
+    + All versions up to SUN PLUS
+
++ crossbeats REV.
+    + All versions + omnimix
+
++ maimai DX
+    + All versions up to FESTiVAL PLUS
+
++ Hatsune Miku: Project DIVA Arcade
+    + All versions
+
 + Card Maker
     + 1.30
     + 1.35
 
-+ CHUNITHM CHINA
-    + NEW
-    + 2024 (NEW)
-    + 2024 (LUMINOUS)
-
-+ CHUNITHM INTL
-    + SUPERSTAR
-    + SUPERSTAR PLUS
-    + NEW
-    + NEW PLUS
-    + SUN
-    + SUN PLUS
-    + LUMINOUS
-    + LUMINOUS PLUS
-
-+ CHUNITHM JP
-    + AIR
-    + AIR PLUS
-    + AMAZON
-    + AMAZON PLUS
-    + CRYSTAL
-    + CRYSTAL PLUS
-    + PARADISE
-    + PARADISE LOST
-    + NEW
-    + NEW PLUS
-    + SUN
-    + SUN PLUS
-    + LUMINOUS
-    + LUMINOUS PLUS
-    + VERSE
-
-+ crossbeats REV.
-    + Crossbeats REV.
-    + Crossbeats REV. SUNRiSE S1
-    + Crossbeats REV. SUNRiSE S2 + omnimix
-
-+ Hatsune Miku: Project DIVA Arcade
-    + Future Tone Arcade - All versions
-
-+ Initial D THE ARCADE
-    + Season 2
-
-+ maimai DX CHINA
-    + DX (Muji)
-    + 2021 (Muji)
-    + 2022 (Muji)
-    + 2023 (FESTiVAL)
-    + 2024 (BUDDiES)
-
-+ maimai DX INTL
-    + DX
-    + DX Plus
-    + Splash
-    + Splash Plus
-    + UNiVERSE
-    + UNiVERSE PLUS
-    + FESTiVAL
-    + FESTiVAL PLUS
-    + BUDDiES
-    + BUDDiES PLUS
-    + PRiSM
-    
-+ maimai DX
-    + DX
-    + DX Plus
-    + Splash
-    + Splash Plus
-    + UNiVERSE
-    + UNiVERSE PLUS
-    + FESTiVAL
-    + FESTiVAL PLUS
-    + BUDDiES
-    + BUDDiES PLUS
-    + PRiSM
-
 + O.N.G.E.K.I.
-    + SUMMER
-    + SUMMER PLUS
-    + R.E.D.
-    + R.E.D. PLUS
-    + bright
-    + bright MEMORY
-    + bright MEMORY Act.3
-
-+ POKKÉN TOURNAMENT
-    + Final Online
-
-+ Sword Art Online Arcade
-    + Final (Single player only)
+    + All versions up to bright MEMORY
 
 + WACCA
     + Lily R
     + Reverse
 
++ POKKÉN TOURNAMENT
+    + Final Online
+
++ Sword Art Online Arcade (partial support)
+    + Final
+
++ Initial D THE ARCADE
+    + Season 2
+
 ## Requirements
 - python 3 (tested working with 3.9 and 3.10, other versions YMMV)
 - pip
@@ -110,13 +43,10 @@ Games listed below have been tested and confirmed working. Only game versions ol
 - mysql/mariadb server
 
 ## Setup guides
-Follow the platform-specific guides for [windows](docs/INSTALL_WINDOWS.md), [linux (Debian 12 or Rasperry Pi OS recomended, but anything works)](docs/INSTALL_LINUX.md) or [docker](docs/INSTALL_DOCKER.md) to setup and run the server.
+Follow the platform-specific guides for [windows](docs/INSTALL_WINDOWS.md), [ubuntu](docs/INSTALL_UBUNTU.md) or [docker](docs/INSTALL_DOCKER.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.
-
-## Text User Interface
-Invoke `tui.py` (with optional `-c <command dir>` parameter) for an interactive TUI to perform management actions (add, edit or delete users, cards, arcades and machines) without needing to spin up the frontend. Requires installing asciimatics via `pip install asciimatics`

requirements.txt

@@ -1,24 +1,22 @@
-mypy
-wheel
-pytz
-pyyaml
-sqlalchemy==1.4.46
-aiomysql
-pyopenssl
-service_identity
-PyCryptodome
-inflection
-coloredlogs
-pylibmc; platform_system != "Windows"
-wacky
-bcrypt
-jinja2
-protobuf
-pillow
-pyjwt==2.8.0
-websockets
-starlette
-asyncio
-uvicorn
-alembic
-python-multipart
+mypy
+wheel
+pytz
+pyyaml
+sqlalchemy==1.4.46
+mysqlclient
+pyopenssl
+service_identity
+PyCryptodome
+inflection
+coloredlogs
+pylibmc; platform_system != "Windows"
+wacky
+bcrypt
+jinja2
+protobuf
+pillow
+pyjwt==2.8.0
+websockets
+starlette
+asyncio
+uvicorn

titles/chuni/__init__.py

@@ -1,11 +1,9 @@
-from .index import ChuniServlet
-from .const import ChuniConstants
-from .database import ChuniData
-from .read import ChuniReader
-from .frontend import ChuniFrontend
+from titles.chuni.index import ChuniServlet
+from titles.chuni.const import ChuniConstants
+from titles.chuni.database import ChuniData
+from titles.chuni.read import ChuniReader
 
 index = ChuniServlet
 database = ChuniData
 reader = ChuniReader
-frontend = ChuniFrontend
-game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW, ChuniConstants.GAME_CODE_INT, ChuniConstants.GAME_CODE_CHN]
+game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW, ChuniConstants.GAME_CODE_INT]

titles/chuni/base.py

@@ -1,16 +1,16 @@
-import itertools
-import json
 import logging
+import json
 from datetime import datetime, timedelta
-from typing import Any, Dict, List
+from time import strftime
 
 import pytz
+from typing import Dict, Any, List
 
 from core.config import CoreConfig
-from titles.chuni.config import ChuniConfig
-from titles.chuni.const import ChuniConstants, FavoriteItemKind, ItemKind
+from titles.chuni.const import ChuniConstants
 from titles.chuni.database import ChuniData
-
+from titles.chuni.config import ChuniConfig
+SCORE_BUFFER = {}
 
 class ChuniBase:
     def __init__(self, core_cfg: CoreConfig, game_cfg: ChuniConfig) -> None:
@@ -24,38 +24,21 @@ class ChuniBase:
 
     async def handle_game_login_api_request(self, data: Dict) -> Dict:
         """
-        Handles the login bonus and ticket stock logic, required for the game
-        because getUserLoginBonus gets called after getUserItem; therefore the
+        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 stock for each specified ticket (itemKind 5)
-        - 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)
+        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)
         """
 
-        user_id = data["userId"]
-
-        # If we want to make certain tickets always available, stock them now
-        if self.game_cfg.mods.stock_tickets:
-            for ticket in self.game_cfg.mods.stock_tickets.split(","):
-                await self.data.item.put_item(
-                    user_id,
-                    {
-                        "itemId": ticket.strip(),
-                        "itemKind": ItemKind.TICKET.value,
-                        "stock": self.game_cfg.mods.stock_count,
-                        "isValid": True,
-                    },
-                )
-
         # ignore the login bonus if disabled in config
         if not self.game_cfg.mods.use_login_bonus:
             return {"returnCode": 1}
 
-        login_bonus_presets = await self.data.static.get_login_bonus_presets(
-            self.version
-        )
+        user_id = data["userId"]
+        login_bonus_presets = await self.data.static.get_login_bonus_presets(self.version)
 
         for preset in login_bonus_presets:
             # check if a user already has some pogress and if not add the
@@ -118,7 +101,7 @@ class ChuniBase:
                         user_id,
                         {
                             "itemId": login_item["presentId"],
-                            "itemKind": ItemKind.PRESENT.value,
+                            "itemKind": 6,
                             "stock": login_item["itemNum"],
                             "isValid": True,
                         },
@@ -199,21 +182,15 @@ class ChuniBase:
 
     async def handle_get_game_message_api_request(self, data: Dict) -> Dict:
         return {
-            "type": data["type"],
-            "length": 1,
-            "gameMessageList": [
-                {
-                    "id": 1,
-                    "type": 1,
-                    "message": (
-                        f"Welcome to {self.core_cfg.server.name} network!"
-                        if not self.game_cfg.server.news_msg
-                        else self.game_cfg.server.news_msg
-                    ),
-                    "startDate": "2017-12-05 07:00:00.0",
-                    "endDate": "2099-12-31 00:00:00.0",
-                }
-            ],
+            "type": data["type"], 
+            "length": 1, 
+            "gameMessageList": [{ 
+                "id": 1, 
+                "type": 1,
+                "message": f"Welcome to {self.core_cfg.server.name} network!" if not self.game_cfg.server.news_msg else self.game_cfg.server.news_msg,
+                "startDate": "2017-12-05 07:00:00.0",
+                "endDate": "2099-12-31 00:00:00.0"
+            }]
         }
 
     async def handle_get_game_ranking_api_request(self, data: Dict) -> Dict:
@@ -225,10 +202,7 @@ class ChuniBase:
 
     async def handle_get_game_setting_api_request(self, data: Dict) -> Dict:
         # if reboot start/end time is not defined use the default behavior of being a few hours ago
-        if (
-            self.core_cfg.title.reboot_start_time == ""
-            or self.core_cfg.title.reboot_end_time == ""
-        ):
+        if self.core_cfg.title.reboot_start_time == "" or self.core_cfg.title.reboot_end_time == "":
             reboot_start = datetime.strftime(
                 datetime.utcnow() + timedelta(hours=6), self.date_time_format
             )
@@ -237,29 +211,15 @@ class ChuniBase:
             )
         else:
             # get current datetime in JST
-            current_jst = datetime.now(pytz.timezone("Asia/Tokyo")).date()
+            current_jst = datetime.now(pytz.timezone('Asia/Tokyo')).date()
 
             # parse config start/end times into datetime
-            reboot_start_time = datetime.strptime(
-                self.core_cfg.title.reboot_start_time, "%H:%M"
-            )
-            reboot_end_time = datetime.strptime(
-                self.core_cfg.title.reboot_end_time, "%H:%M"
-            )
+            reboot_start_time = datetime.strptime(self.core_cfg.title.reboot_start_time, "%H:%M")
+            reboot_end_time = datetime.strptime(self.core_cfg.title.reboot_end_time, "%H:%M")
 
             # offset datetimes with current date/time
-            reboot_start_time = reboot_start_time.replace(
-                year=current_jst.year,
-                month=current_jst.month,
-                day=current_jst.day,
-                tzinfo=pytz.timezone("Asia/Tokyo"),
-            )
-            reboot_end_time = reboot_end_time.replace(
-                year=current_jst.year,
-                month=current_jst.month,
-                day=current_jst.day,
-                tzinfo=pytz.timezone("Asia/Tokyo"),
-            )
+            reboot_start_time = reboot_start_time.replace(year=current_jst.year, month=current_jst.month, day=current_jst.day, tzinfo=pytz.timezone('Asia/Tokyo'))
+            reboot_end_time = reboot_end_time.replace(year=current_jst.year, month=current_jst.month, day=current_jst.day, tzinfo=pytz.timezone('Asia/Tokyo'))
 
             # create strings for use in gameSetting
             reboot_start = reboot_start_time.strftime(self.date_time_format)
@@ -280,7 +240,6 @@ class ChuniBase:
             "isDumpUpload": "false",
             "isAou": "false",
         }
-
     async def handle_get_user_activity_api_request(self, data: Dict) -> Dict:
         user_activity_list = await self.data.profile.get_profile_activity(
             data["userId"], data["kind"]
@@ -303,39 +262,35 @@ class ChuniBase:
         }
 
     async def handle_get_user_character_api_request(self, data: Dict) -> Dict:
-        user_id = int(data["userId"])
-        next_idx = int(data["nextIndex"])
-        max_ct = int(data["maxCount"])
-
-        # add one to the limit so we know if there's a next page of items
-        rows = await self.data.item.get_characters(
-            user_id, limit=max_ct + 1, offset=next_idx
-        )
-
-        if rows is None or len(rows) == 0:
+        characters = await self.data.item.get_characters(data["userId"])
+        if characters is None:
             return {
-                "userId": user_id,
+                "userId": data["userId"],
                 "length": 0,
                 "nextIndex": -1,
                 "userCharacterList": [],
             }
 
         character_list = []
+        next_idx = int(data["nextIndex"])
+        max_ct = int(data["maxCount"])
 
-        for row in rows[:max_ct]:
-            tmp = row._asdict()
-            tmp.pop("id")
+        for x in range(next_idx, len(characters)):
+            tmp = characters[x]._asdict()
             tmp.pop("user")
-
+            tmp.pop("id")
             character_list.append(tmp)
 
-        if len(rows) > max_ct:
+            if len(character_list) >= max_ct:
+                break
+
+        if len(characters) >= next_idx + max_ct:
             next_idx += max_ct
         else:
             next_idx = -1
 
         return {
-            "userId": user_id,
+            "userId": data["userId"],
             "length": len(character_list),
             "nextIndex": next_idx,
             "userCharacterList": character_list,
@@ -361,35 +316,33 @@ class ChuniBase:
         return {
             "userId": data["userId"],
             "length": 0,
-            "userRecentPlayerList": [],  # playUserId, playUserName, playDate, friendPoint
+            "userRecentPlayerList": [], # playUserId, playUserName, playDate, friendPoint
         }
 
     async def handle_get_user_course_api_request(self, data: Dict) -> Dict:
-        user_id = int(data["userId"])
-        next_idx = int(data["nextIndex"])
-        max_ct = int(data["maxCount"])
-
-        rows = await self.data.score.get_courses(
-            user_id, limit=max_ct + 1, offset=next_idx
-        )
-
-        if rows is None or len(rows) == 0:
+        user_course_list = await self.data.score.get_courses(data["userId"])
+        if user_course_list is None:
             return {
-                "userId": user_id,
+                "userId": data["userId"],
                 "length": 0,
                 "nextIndex": -1,
                 "userCourseList": [],
             }
 
         course_list = []
+        next_idx = int(data.get("nextIndex", 0))
+        max_ct = int(data.get("maxCount", 300))
 
-        for row in rows[:max_ct]:
-            tmp = row._asdict()
+        for x in range(next_idx, len(user_course_list)):
+            tmp = user_course_list[x]._asdict()
             tmp.pop("user")
             tmp.pop("id")
             course_list.append(tmp)
 
-        if len(rows) > max_ct:
+            if len(user_course_list) >= max_ct:
+                break
+
+        if len(user_course_list) >= next_idx + max_ct:
             next_idx += max_ct
         else:
             next_idx = -1
@@ -447,105 +400,85 @@ class ChuniBase:
         p = await self.data.profile.get_rival(data["rivalId"])
         if p is None:
             return {}
-        userRivalData = {"rivalId": p.user, "rivalName": p.userName}
-        return {"userId": data["userId"], "userRivalData": userRivalData}
-
+        userRivalData = {
+            "rivalId": p.user,
+            "rivalName": p.userName
+        }
+        return {
+            "userId": data["userId"],
+            "userRivalData": userRivalData
+        }
+    
     async def handle_get_user_rival_music_api_request(self, data: Dict) -> Dict:
-        user_id = int(data["userId"])
-        rival_id = int(data["rivalId"])
-        next_idx = int(data["nextIndex"])
-        max_ct = int(data["maxCount"])
-        rival_levels = [int(x["level"]) for x in data["userRivalMusicLevelList"]]
+        rival_id = data["rivalId"]
+        next_index = int(data["nextIndex"])
+        max_count = int(data["maxCount"])
+        user_rival_music_list = []
 
         # Fetch all the rival music entries for the user
-        rows = await self.data.score.get_scores(
-            rival_id,
-            levels=rival_levels,
-            limit=max_ct + 1,
-            offset=next_idx,
-        )
+        all_entries = await self.data.score.get_rival_music(rival_id)
 
-        if rows is None or len(rows) == 0:
-            return {
-                "userId": user_id,
-                "rivalId": rival_id,
-                "nextIndex": -1,
-                "userRivalMusicList": [],
-            }
+        # Process the entries based on max_count and nextIndex
+        for music in all_entries:
+            music_id = music["musicId"]
+            level = music["level"]
+            score = music["scoreMax"]
+            rank = music["scoreRank"]
 
-        music_details = [x._asdict() for x in rows]
-        returned_music_details_count = 0
-        music_list = []
-
-        # note that itertools.groupby will only work on sorted keys, which is already sorted by
-        # the query in get_scores
-        for music_id, details_iter in itertools.groupby(
-            music_details, key=lambda x: x["musicId"]
-        ):
-            details: list[dict[Any, Any]] = [
-                {"level": d["level"], "scoreMax": d["scoreMax"]} for d in details_iter
-            ]
-
-            music_list.append(
-                {
+            # Create a music entry for the current music_id if it's unique
+            music_entry = next((entry for entry in user_rival_music_list if entry["musicId"] == music_id), None)
+            if music_entry is None:
+                music_entry = {
                     "musicId": music_id,
-                    "length": len(details),
-                    "userRivalMusicDetailList": details,
+                    "length": 0,
+                    "userRivalMusicDetailList": []
                 }
-            )
-            returned_music_details_count += len(details)
+                user_rival_music_list.append(music_entry)
 
-            if len(music_list) >= max_ct:
-                break
+            # Create a level entry for the current level if it's unique or has a higher score
+            level_entry = next((entry for entry in music_entry["userRivalMusicDetailList"] if entry["level"] == level), None)
+            if level_entry is None:
+                level_entry = {
+                    "level": level,
+                    "scoreMax": score,
+                    "scoreRank": rank
+                }
+                music_entry["userRivalMusicDetailList"].append(level_entry)
+            elif score > level_entry["scoreMax"]:
+                level_entry["scoreMax"] = score
+                level_entry["scoreRank"] = rank
 
-        # if we returned fewer PBs than we originally asked for from the database, that means
-        # we queried for the PBs of max_ct + 1 songs.
-        if returned_music_details_count < len(rows):
-            next_idx += max_ct
-        else:
-            next_idx = -1
+        # Calculate the length for each "musicId" by counting the unique levels
+        for music_entry in user_rival_music_list:
+            music_entry["length"] = len(music_entry["userRivalMusicDetailList"])
 
-        return {
-            "userId": user_id,
-            "rivalId": rival_id,
-            "length": len(music_list),
-            "nextIndex": next_idx,
-            "userRivalMusicList": music_list,
+        # Prepare the result dictionary with user rival music data
+        result = {
+            "userId": data["userId"],
+            "rivalId": data["rivalId"],
+            "nextIndex": str(next_index + len(user_rival_music_list[next_index: next_index + max_count]) if max_count <= len(user_rival_music_list[next_index: next_index + max_count]) else -1),
+            "userRivalMusicList": user_rival_music_list[next_index: next_index + max_count]
         }
+        return result
 
+    
     async def handle_get_user_favorite_item_api_request(self, data: Dict) -> Dict:
-        user_id = int(data["userId"])
-        next_idx = int(data["nextIndex"])
-        max_ct = int(data["maxCount"])
-        kind = int(data["kind"])
-        is_all_favorite_item = str(data["isAllFavoriteItem"]) == "true"
-
         user_fav_item_list = []
 
         # still needs to be implemented on WebUI
         # 1: Music, 2: User, 3: Character
-        rows = await self.data.item.get_all_favorites(
-            user_id,
-            self.version,
-            fav_kind=kind,
-            limit=max_ct + 1,
-            offset=next_idx,
+        fav_list = await self.data.item.get_all_favorites(
+            data["userId"], self.version, fav_kind=int(data["kind"])
         )
-
-        if rows is not None:
-            for fav in rows[:max_ct]:
+        if fav_list is not None:
+            for fav in fav_list:
                 user_fav_item_list.append({"id": fav["favId"]})
 
-        if rows is None or len(rows) <= max_ct:
-            next_idx = -1
-        else:
-            next_idx += max_ct
-
         return {
-            "userId": user_id,
+            "userId": data["userId"],
             "length": len(user_fav_item_list),
-            "kind": kind,
-            "nextIndex": next_idx,
+            "kind": data["kind"],
+            "nextIndex": -1,
             "userFavoriteItemList": user_fav_item_list,
         }
 
@@ -557,39 +490,36 @@ class ChuniBase:
         return {"userId": data["userId"], "length": 0, "userFavoriteMusicList": []}
 
     async def handle_get_user_item_api_request(self, data: Dict) -> Dict:
-        user_id = int(data["userId"])
-        next_idx = int(data["nextIndex"])
-        max_ct = int(data["maxCount"])
+        kind = int(int(data["nextIndex"]) / 10000000000)
+        next_idx = int(int(data["nextIndex"]) % 10000000000)
+        user_item_list = await self.data.item.get_items(data["userId"], kind)
 
-        kind = next_idx // 10000000000
-        next_idx = next_idx % 10000000000
-        rows = await self.data.item.get_items(
-            user_id, kind, limit=max_ct + 1, offset=next_idx
-        )
-
-        if rows is None or len(rows) == 0:
+        if user_item_list is None or len(user_item_list) == 0:
             return {
-                "userId": user_id,
+                "userId": data["userId"],
                 "nextIndex": -1,
                 "itemKind": kind,
                 "userItemList": [],
             }
 
         items: List[Dict[str, Any]] = []
-
-        for row in rows[:max_ct]:
-            tmp = row._asdict()
+        for i in range(next_idx, len(user_item_list)):
+            tmp = user_item_list[i]._asdict()
             tmp.pop("user")
             tmp.pop("id")
             items.append(tmp)
+            if len(items) >= int(data["maxCount"]):
+                break
 
-        if len(rows) > max_ct:
-            next_idx = kind * 10000000000 + next_idx + max_ct
+        xout = kind * 10000000000 + next_idx + len(items)
+
+        if len(items) < int(data["maxCount"]):
+            next_idx = 0
         else:
-            next_idx = -1
+            next_idx = xout
 
         return {
-            "userId": user_id,
+            "userId": data["userId"],
             "nextIndex": next_idx,
             "itemKind": kind,
             "length": len(items),
@@ -598,9 +528,7 @@ class ChuniBase:
 
     async def handle_get_user_login_bonus_api_request(self, data: Dict) -> Dict:
         user_id = data["userId"]
-        user_login_bonus = await self.data.item.get_all_login_bonus(
-            user_id, self.version
-        )
+        user_login_bonus = await self.data.item.get_all_login_bonus(user_id, self.version)
         # ignore the loginBonus request if its disabled in config
         if user_login_bonus is None or not self.game_cfg.mods.use_login_bonus:
             return {"userId": user_id, "length": 0, "userLoginBonusList": []}
@@ -643,57 +571,62 @@ class ChuniBase:
         }
 
     async def handle_get_user_music_api_request(self, data: Dict) -> Dict:
-        user_id = int(data["userId"])
-        next_idx = int(data["nextIndex"])
-        max_ct = int(data["maxCount"])
-
-        rows = await self.data.score.get_scores(
-            user_id, limit=max_ct + 1, offset=next_idx
-        )
-
-        if rows is None or len(rows) == 0:
+        music_detail = await self.data.score.get_scores(data["userId"])
+        if music_detail is None:
             return {
-                "userId": user_id,
+                "userId": data["userId"],
                 "length": 0,
                 "nextIndex": -1,
                 "userMusicList": [],  # 240
             }
 
-        music_details = [x._asdict() for x in rows]
-        returned_music_details_count = 0
-        music_list = []
+        song_list = []
+        next_idx = int(data["nextIndex"])
+        max_ct = int(data["maxCount"])
 
-        # note that itertools.groupby will only work on sorted keys, which is already sorted by
-        # the query in get_scores
-        for _music_id, details_iter in itertools.groupby(
-            music_details, key=lambda x: x["musicId"]
-        ):
-            details: list[dict[Any, Any]] = []
+        for x in range(next_idx, len(music_detail)):
+            found = False
+            tmp = music_detail[x]._asdict()
+            tmp.pop("user")
+            tmp.pop("id")
 
-            for d in details_iter:
-                d.pop("id")
-                d.pop("user")
+            for song in song_list:
+                score_buf = SCORE_BUFFER.get(str(data["userId"])) or []
+                if song["userMusicDetailList"][0]["musicId"] == tmp["musicId"]:
+                    found = True
+                    song["userMusicDetailList"].append(tmp)
+                    song["length"] = len(song["userMusicDetailList"])
+                    score_buf.append(tmp["musicId"])
+                    SCORE_BUFFER[str(data["userId"])] = score_buf
 
-                details.append(d)
+            score_buf = SCORE_BUFFER.get(str(data["userId"])) or []
+            if not found and tmp["musicId"] not in score_buf:
+                song_list.append({"length": 1, "userMusicDetailList": [tmp]})
+                score_buf.append(tmp["musicId"])
+                SCORE_BUFFER[str(data["userId"])] = score_buf
 
-            music_list.append({"length": len(details), "userMusicDetailList": details})
-            returned_music_details_count += len(details)
-
-            if len(music_list) >= max_ct:
+            if len(song_list) >= max_ct:
                 break
-
-        # if we returned fewer PBs than we originally asked for from the database, that means
-        # we queried for the PBs of max_ct + 1 songs.
-        if returned_music_details_count < len(rows):
-            next_idx += max_ct
+    
+        for songIdx in range(len(song_list)): 
+            for recordIdx in range(x+1, len(music_detail)):
+                if song_list[songIdx]["userMusicDetailList"][0]["musicId"] == music_detail[recordIdx]["musicId"]:
+                    music = music_detail[recordIdx]._asdict()
+                    music.pop("user")
+                    music.pop("id")
+                    song_list[songIdx]["userMusicDetailList"].append(music)
+                    song_list[songIdx]["length"] += 1
+    
+        if len(song_list) >= max_ct:
+            next_idx += len(song_list)
         else:
             next_idx = -1
-
+            SCORE_BUFFER[str(data["userId"])] = []
         return {
-            "userId": user_id,
-            "length": len(music_list),
+            "userId": data["userId"],
+            "length": len(song_list),
             "nextIndex": next_idx,
-            "userMusicList": music_list,
+            "userMusicList": song_list,  # 240
         }
 
     async def handle_get_user_option_api_request(self, data: Dict) -> Dict:
@@ -718,9 +651,7 @@ class ChuniBase:
         return bytes([ord(c) for c in src]).decode("utf-8")
 
     async def handle_get_user_preview_api_request(self, data: Dict) -> Dict:
-        profile = await self.data.profile.get_profile_preview(
-            data["userId"], self.version
-        )
+        profile = await self.data.profile.get_profile_preview(data["userId"], self.version)
         if profile is None:
             return None
         profile_character = await self.data.item.get_character(
@@ -762,9 +693,7 @@ class ChuniBase:
         }
 
     async def handle_get_user_recent_rating_api_request(self, data: Dict) -> Dict:
-        recent_rating_list = await self.data.profile.get_profile_recent_rating(
-            data["userId"]
-        )
+        recent_rating_list = await self.data.profile.get_profile_recent_rating(data["userId"])
         if recent_rating_list is None:
             return {
                 "userId": data["userId"],
@@ -791,14 +720,9 @@ class ChuniBase:
         team_id = 65535
         team_name = self.game_cfg.team.team_name
         team_rank = 0
-        team_user_point = 0
 
         # Get user profile
         profile = await self.data.profile.get_profile_data(data["userId"], self.version)
-
-        if profile is None:
-            return {"userId": data["userId"], "teamId": 0}
-
         if profile and profile["teamId"]:
             # Get team by id
             team = await self.data.profile.get_team_by_id(profile["teamId"])
@@ -807,12 +731,7 @@ class ChuniBase:
                 team_id = team["id"]
                 team_name = team["teamName"]
                 team_rank = await self.data.profile.get_team_rank(team["id"])
-                team_point = team["teamPoint"]
-                if team["userTeamPoint"] is not None and team["userTeamPoint"] != "":
-                    user_team_point_data = json.loads(team["userTeamPoint"])
-                    for user_point_data in user_team_point_data:
-                        if user_point_data["user"] == data["userId"]:
-                            team_user_point = int(user_point_data["userPoint"])
+
         # Don't return anything if no team name has been defined for defaults and there is no team set for the player
         if not profile["teamId"] and team_name == "":
             return {"userId": data["userId"], "teamId": 0}
@@ -822,16 +741,15 @@ class ChuniBase:
             "teamId": team_id,
             "teamRank": team_rank,
             "teamName": team_name,
-            "assaultTimeRate": 1,  # TODO: Figure out assaultTime, which might be team point boost?
             "userTeamPoint": {
                 "userId": data["userId"],
                 "teamId": team_id,
-                "orderId": 0,
-                "teamPoint": team_user_point,
+                "orderId": 1,
+                "teamPoint": 1,
                 "aggrDate": data["playDate"],
             },
         }
-
+    
     async def handle_get_team_course_setting_api_request(self, data: Dict) -> Dict:
         return {
             "userId": data["userId"],
@@ -840,9 +758,7 @@ class ChuniBase:
             "teamCourseSettingList": [],
         }
 
-    async def handle_get_team_course_setting_api_request_proto(
-        self, data: Dict
-    ) -> Dict:
+    async def handle_get_team_course_setting_api_request_proto(self, data: Dict) -> Dict:
         return {
             "userId": data["userId"],
             "length": 1,
@@ -857,11 +773,11 @@ class ChuniBase:
                     "teamCourseMusicList": [
                         {"track": 184, "type": 1, "level": 3, "selectLevel": -1},
                         {"track": 184, "type": 1, "level": 3, "selectLevel": -1},
-                        {"track": 184, "type": 1, "level": 3, "selectLevel": -1},
+                        {"track": 184, "type": 1, "level": 3, "selectLevel": -1}
                     ],
                     "teamCourseRankingInfoList": [],
                     "recodeDate": "2099-12-31 11:59:99.0",
-                    "isPlayed": False,
+                    "isPlayed": False
                 }
             ],
         }
@@ -871,7 +787,7 @@ class ChuniBase:
             "userId": data["userId"],
             "length": 0,
             "nextIndex": -1,
-            "teamCourseRuleList": [],
+            "teamCourseRuleList": []
         }
 
     async def handle_get_team_course_rule_api_request_proto(self, data: Dict) -> Dict:
@@ -886,7 +802,7 @@ class ChuniBase:
                     "damageMiss": 1,
                     "damageAttack": 1,
                     "damageJustice": 1,
-                    "damageJusticeC": 1,
+                    "damageJusticeC": 1
                 }
             ],
         }
@@ -895,12 +811,6 @@ class ChuniBase:
         upsert = data["upsertUserAll"]
         user_id = data["userId"]
 
-        if int(user_id) & 0x1000000000001 == 0x1000000000001:
-            place_id = int(user_id) & 0xFFFC00000000
-
-            self.logger.info("Guest play from place ID %d, ignoring.", place_id)
-            return {"returnCode": "1"}
-
         if "userData" in upsert:
             try:
                 upsert["userData"][0]["userName"] = self.read_wtf8(
@@ -919,9 +829,7 @@ class ChuniBase:
             )
 
         if "userGameOption" in upsert:
-            await self.data.profile.put_profile_option(
-                user_id, upsert["userGameOption"][0]
-            )
+            await self.data.profile.put_profile_option(user_id, upsert["userGameOption"][0])
 
         if "userGameOptionEx" in upsert:
             await self.data.profile.put_profile_option_ex(
@@ -968,41 +876,33 @@ class ChuniBase:
             for playlog in upsert["userPlaylogList"]:
                 # convert the player names to utf-8
                 if playlog["playedUserName1"] is not None:
-                    playlog["playedUserName1"] = self.read_wtf8(
-                        playlog["playedUserName1"]
-                    )
+                  playlog["playedUserName1"] = self.read_wtf8(playlog["playedUserName1"])
                 if playlog["playedUserName2"] is not None:
-                    playlog["playedUserName2"] = self.read_wtf8(
-                        playlog["playedUserName2"]
-                    )
+                  playlog["playedUserName2"] = self.read_wtf8(playlog["playedUserName2"])
                 if playlog["playedUserName3"] is not None:
-                    playlog["playedUserName3"] = self.read_wtf8(
-                        playlog["playedUserName3"]
-                    )
+                  playlog["playedUserName3"] = self.read_wtf8(playlog["playedUserName3"])
                 await self.data.score.put_playlog(user_id, playlog, self.version)
 
         if "userTeamPoint" in upsert:
             team_points = upsert["userTeamPoint"]
             try:
                 for tp in team_points:
-                    if tp["teamId"] != "65535":
+                    if tp["teamId"] != '65535':
                         # Fetch the current team data
-                        current_team = await self.data.profile.get_team_by_id(
-                            tp["teamId"]
-                        )
+                        current_team = await self.data.profile.get_team_by_id(tp["teamId"])
 
                         # Calculate the new teamPoint
-                        new_team_point = (
-                            int(tp["teamPoint"]) + current_team["teamPoint"]
-                        )
+                        new_team_point = int(tp["teamPoint"]) + current_team["teamPoint"]
 
                         # Prepare the data to update
-                        team_data = {"teamPoint": new_team_point}
+                        team_data = {
+                            "teamPoint": new_team_point
+                        }
 
                         # Update the team data
                         await self.data.profile.update_team(tp["teamId"], team_data)
             except:
-                pass  # Probably a better way to catch if the team is not set yet (new profiles), but let's just pass
+                pass # Probably a better way to catch if the team is not set yet (new profiles), but let's just pass
         if "userMapAreaList" in upsert:
             for map_area in upsert["userMapAreaList"]:
                 await self.data.item.put_map_area(user_id, map_area)
@@ -1020,91 +920,11 @@ class ChuniBase:
                 await self.data.item.put_login_bonus(
                     user_id, self.version, login["presetId"], isWatched=True
                 )
-
-        if (
-            "userRecentPlayerList" in upsert
-        ):  # TODO: Seen in Air, maybe implement sometime
+        
+        if "userRecentPlayerList" in upsert: # TODO: Seen in Air, maybe implement sometime
             for rp in upsert["userRecentPlayerList"]:
                 pass
 
-        for rating_type in {
-            "userRatingBaseList",
-            "userRatingBaseHotList",
-            "userRatingBaseNextList",
-        }:
-            if rating_type not in upsert:
-                continue
-
-            await self.data.profile.put_profile_rating(
-                user_id,
-                self.version,
-                rating_type,
-                upsert[rating_type],
-            )
-
-        # added in LUMINOUS
-        if "userCMissionList" in upsert:
-            for cmission in upsert["userCMissionList"]:
-                mission_id = cmission["missionId"]
-
-                await self.data.item.put_cmission(
-                    user_id,
-                    {
-                        "missionId": mission_id,
-                        "point": cmission["point"],
-                    },
-                )
-
-                for progress in cmission["userCMissionProgressList"]:
-                    await self.data.item.put_cmission_progress(
-                        user_id, mission_id, progress
-                    )
-
-        if "userNetBattleData" in upsert:
-            net_battle = upsert["userNetBattleData"][0]
-
-            # fix the boolean
-            net_battle["isRankUpChallengeFailed"] = (
-                False if net_battle["isRankUpChallengeFailed"] == "false" else True
-            )
-            await self.data.profile.put_net_battle(user_id, net_battle)
-
-        # New in LUMINOUS PLUS
-        if "userFavoriteMusicList" in upsert:
-            # musicId, orderId
-            music_ids = set(
-                int(m["musicId"])
-                for m in upsert["userFavoriteMusicList"]
-                if m["musicId"] != "-1"
-            )
-            current_favorites = await self.data.item.get_all_favorites(
-                user_id, self.version, fav_kind=FavoriteItemKind.MUSIC.value
-            )
-
-            if current_favorites is None:
-                current_favorites = []
-
-            current_favorite_ids = set(x.favId for x in current_favorites)
-            keep_ids = current_favorite_ids.intersection(music_ids)
-            deleted_ids = current_favorite_ids - keep_ids
-            added_ids = music_ids - keep_ids
-
-            for fav_id in deleted_ids:
-                await self.data.item.delete_favorite_music(
-                    user_id, self.version, fav_id
-                )
-
-            for fav_id in added_ids:
-                await self.data.item.put_favorite_music(user_id, self.version, fav_id)
-        
-        # added in CHUNITHM VERSE
-        if "userUnlockChallengeList" in upsert:
-            for unlock_challenge in upsert["userUnlockChallengeList"]:
-                await self.data.item.put_unlock_challenge(
-                    user_id, self.version, unlock_challenge
-                )
-
-
         return {"returnCode": "1"}
 
     async def handle_upsert_user_chargelog_api_request(self, data: Dict) -> Dict:
@@ -1132,4 +952,4 @@ class ChuniBase:
         return {
             "userId": data["userId"],
             "userNetBattleData": {"recentNBSelectMusicList": []},
-        }
+        }

titles/chuni/config.py

@@ -25,12 +25,6 @@ class ChuniServerConfig:
         return CoreConfig.get_config_field(
             self.__config, "chuni", "server", "news_msg", default=""
         )
-    
-    @property
-    def use_https(self) -> bool:
-        return CoreConfig.get_config_field(
-                self.__config, "chuni", "server", "use_https", default=False
-            )
 
 
 class ChuniTeamConfig:
@@ -59,29 +53,6 @@ class ChuniModsConfig:
             self.__config, "chuni", "mods", "use_login_bonus", default=True
         )
 
-    @property
-    def stock_tickets(self) -> str:
-        return CoreConfig.get_config_field(
-            self.__config, "chuni", "mods", "stock_tickets", default=None
-        )
-
-    @property
-    def stock_count(self) -> int:
-        return CoreConfig.get_config_field(
-            self.__config, "chuni", "mods", "stock_count", default=99
-        )
-
-    def forced_item_unlocks(self, item: str) -> bool:
-        forced_item_unlocks = CoreConfig.get_config_field(
-            self.__config, "chuni", "mods", "forced_item_unlocks", default={}
-        )
-
-        if item not in forced_item_unlocks.keys():
-            # default to no forced unlocks
-            return False
- 
-        return forced_item_unlocks[item]
-
 
 class ChuniVersionConfig:
     def __init__(self, parent_config: "ChuniConfig") -> None:
@@ -92,14 +63,9 @@ class ChuniVersionConfig:
         in the form of:
         11: {"rom": 2.00.00, "data": 2.00.00}
         """
-        versions = CoreConfig.get_config_field(
+        return CoreConfig.get_config_field(
             self.__config, "chuni", "version", default={}
-        )
-
-        if version not in versions.keys():
-            return None
-
-        return versions[version]
+        )[version]
 
 
 class ChuniCryptoConfig:

titles/chuni/const.py

@@ -1,12 +1,7 @@
-from enum import Enum, IntEnum
-from typing import Optional
-from core.utils import floor_to_nearest_005
-
 class ChuniConstants:
     GAME_CODE = "SDBT"
     GAME_CODE_NEW = "SDHD"
     GAME_CODE_INT = "SDGS"
-    GAME_CODE_CHN = "SDHJ"
 
     CONFIG_NAME = "chuni.yaml"
 
@@ -21,15 +16,10 @@ class ChuniConstants:
     VER_CHUNITHM_CRYSTAL = 8
     VER_CHUNITHM_CRYSTAL_PLUS = 9
     VER_CHUNITHM_PARADISE = 10
-
     VER_CHUNITHM_NEW = 11
     VER_CHUNITHM_NEW_PLUS = 12
     VER_CHUNITHM_SUN = 13
     VER_CHUNITHM_SUN_PLUS = 14
-    VER_CHUNITHM_LUMINOUS = 15
-    VER_CHUNITHM_LUMINOUS_PLUS = 16
-    VER_CHUNITHM_VERSE = 17
-
     VERSION_NAMES = [
         "CHUNITHM",
         "CHUNITHM PLUS",
@@ -45,143 +35,9 @@ class ChuniConstants:
         "CHUNITHM NEW!!",
         "CHUNITHM NEW PLUS!!",
         "CHUNITHM SUN",
-        "CHUNITHM SUN PLUS",
-        "CHUNITHM LUMINOUS",
-        "CHUNITHM LUMINOUS PLUS",
-        "CHUNITHM VERSE"
+        "CHUNITHM SUN PLUS"
     ]
 
-    SCORE_RANK_INTERVALS_OLD = [
-        (1007500, "SSS"),
-        (1000000, "SS"),
-        ( 975000, "S"),
-        ( 950000, "AAA"),
-        ( 925000, "AA"),
-        ( 900000, "A"),
-        ( 800000, "BBB"),
-        ( 700000, "BB"),
-        ( 600000, "B"),
-        ( 500000, "C"),
-        (      0, "D"),
-    ]
-
-    SCORE_RANK_INTERVALS_NEW = [
-        (1009000, "SSS+"),  # New only
-        (1007500, "SSS"),
-        (1005000, "SS+"),  # New only
-        (1000000, "SS"),
-        ( 990000, "S+"),  # New only
-        ( 975000, "S"),
-        ( 950000, "AAA"),
-        ( 925000, "AA"),
-        ( 900000, "A"),
-        ( 800000, "BBB"),
-        ( 700000, "BB"),
-        ( 600000, "B"),
-        ( 500000, "C"),
-        (      0, "D"),
-    ]
-
-    VERSION_LUT = {
-        "100": VER_CHUNITHM,
-        "105": VER_CHUNITHM_PLUS,
-        "110": VER_CHUNITHM_AIR,
-        "115": VER_CHUNITHM_AIR_PLUS,
-        "120": VER_CHUNITHM_STAR,
-        "125": VER_CHUNITHM_STAR_PLUS,
-        "130": VER_CHUNITHM_AMAZON,
-        "135": VER_CHUNITHM_AMAZON_PLUS,
-        "140": VER_CHUNITHM_CRYSTAL,
-        "145": VER_CHUNITHM_CRYSTAL_PLUS,
-        "150": VER_CHUNITHM_PARADISE,
-        "200": VER_CHUNITHM_NEW,
-        "205": VER_CHUNITHM_NEW_PLUS,
-        "210": VER_CHUNITHM_SUN,
-        "215": VER_CHUNITHM_SUN_PLUS,
-        "220": VER_CHUNITHM_LUMINOUS,
-        "225": VER_CHUNITHM_LUMINOUS_PLUS,
-    }
-
     @classmethod
     def game_ver_to_string(cls, ver: int):
-        return cls.VERSION_NAMES[ver]
-
-    @classmethod
-    def int_ver_to_game_ver(cls, ver: int) -> Optional[int]:
-        """ Takes an int ver (ex 100 for 1.00) and returns an internal game version """
-        return cls.VERSION_LUT.get(str(floor_to_nearest_005(ver)), None)
-
-class MapAreaConditionType(IntEnum):
-    """Condition types for the GetGameMapAreaConditionApi endpoint. Incomplete.
-
-    For the MAP_CLEARED/MAP_AREA_CLEARED/TROPHY_OBTAINED conditions, the conditionId
-    is the map/map area/trophy.
-
-    For the RANK_*/ALL_JUSTICE conditions, the conditionId is songId * 100 + difficultyId.
-    For example, Halcyon [ULTIMA] would be 173 * 100 + 4 = 17304.
-    """
-
-    ALWAYS_UNLOCKED = 0
-    
-    MAP_CLEARED = 1
-    MAP_AREA_CLEARED = 2
-    
-    TROPHY_OBTAINED = 3
-
-    RANK_SSSP = 18
-    RANK_SSS = 19
-    RANK_SSP = 20
-    RANK_SS = 21
-    RANK_SP = 22
-    RANK_S = 23
-
-    ALL_JUSTICE = 28
-
-
-class MapAreaConditionLogicalOperator(Enum):
-    AND = 1
-    OR = 2
-
-
-class AvatarCategory(Enum):
-    WEAR = 1
-    HEAD = 2
-    FACE = 3
-    SKIN = 4
-    ITEM = 5
-    FRONT = 6
-    BACK = 7
-
-class ItemKind(IntEnum):
-    NAMEPLATE = 1
-    
-    FRAME = 2
-    """
-    "Frame" is the background for the gauge/score/max combo display
-    shown during gameplay. This item cannot be equipped (as of LUMINOUS PLUS)
-    and is hardcoded to the current game's version.
-    """
-
-    TROPHY = 3
-    SKILL = 4
-
-    TICKET = 5
-    """A statue is also a ticket."""
-
-    PRESENT = 6
-    MUSIC_UNLOCK = 7
-    MAP_ICON = 8
-    SYSTEM_VOICE = 9
-    SYMBOL_CHAT = 10
-    AVATAR_ACCESSORY = 11
-
-    ULTIMA_UNLOCK = 12
-    """This only applies to ULTIMA difficulties that are *not* unlocked by
-    reaching S rank on EXPERT difficulty or above.
-    """
-
-
-class FavoriteItemKind(IntEnum):
-    MUSIC = 1
-    RIVAL = 2
-    CHARACTER = 3
+        return cls.VERSION_NAMES[ver]

titles/chuni/database.py

@@ -1,17 +1,13 @@
 from core.data import Data
 from core.config import CoreConfig
 from titles.chuni.schema import *
-from .config import ChuniConfig
+
 
 class ChuniData(Data):
-    def __init__(self, cfg: CoreConfig, chuni_cfg: ChuniConfig = None) -> None:
+    def __init__(self, cfg: CoreConfig) -> None:
         super().__init__(cfg)
 
         self.item = ChuniItemData(cfg, self.session)
         self.profile = ChuniProfileData(cfg, self.session)
         self.score = ChuniScoreData(cfg, self.session)
         self.static = ChuniStaticData(cfg, self.session)
-
-        # init rom versioning for use with score playlog data
-        if chuni_cfg:
-            ChuniRomVersion.init_versions(chuni_cfg)

titles/chuni/frontend.py

@@ -1,783 +0,0 @@
-from typing import List, Tuple, Dict
-from starlette.routing import Route, Mount
-from starlette.requests import Request
-from starlette.responses import Response, RedirectResponse
-from starlette.staticfiles import StaticFiles
-from sqlalchemy.engine import Row
-from os import path
-import yaml
-import jinja2
-
-from core.frontend import FE_Base, UserSession
-from core.config import CoreConfig
-from .database import ChuniData
-from .config import ChuniConfig
-from .const import ChuniConstants, AvatarCategory, ItemKind
-
-
-def pairwise(iterable):
-    # https://docs.python.org/3/library/itertools.html#itertools.pairwise
-    # but for Python < 3.10. pairwise('ABCDEFG') → AB BC CD DE EF FG
-    iterator = iter(iterable)
-    a = next(iterator, None)
-    for b in iterator:
-        yield a, b
-        a = b
-
-
-def calculate_song_rank(score: int, game_version: int) -> str:
-    if game_version >= ChuniConstants.VER_CHUNITHM_NEW:
-        intervals = ChuniConstants.SCORE_RANK_INTERVALS_NEW
-    else:
-        intervals = ChuniConstants.SCORE_RANK_INTERVALS_OLD
-
-    for (min_score, rank) in intervals:
-        if score >= min_score:
-            return rank
-
-    return "D"
-
-
-def calculate_song_rating(score: int, chart_constant: float, game_version: int) -> float:
-    is_new = game_version >= ChuniConstants.VER_CHUNITHM_NEW
-
-    if is_new:  # New and later
-        max_score = 1009000
-        max_rating_modifier = 2.15
-    else:  # Up to Paradise Lost
-        max_score = 1007500
-        max_rating_modifier = 2.0
-
-    if (score < 500000):
-        return 0.0  # D
-    elif (score >= max_score):
-        return chart_constant + max_rating_modifier  # SSS/SSS+
-
-    # Okay, we're doing this the hard way.
-    # Rating goes up linearly between breakpoints listed below.
-    # Pick the score interval in which we are in, then calculate
-    # the position between possible ratings.
-    score_intervals = [
-        ( 500000, 0.0),  # C
-        ( 800000, max(0.0, (chart_constant - 5.0) / 2)),  # BBB
-        ( 900000, max(0.0, (chart_constant - 5.0))),  # A
-        ( 925000, max(0.0, (chart_constant - 3.0))),  # AA
-        ( 975000, chart_constant),  # S
-        (1000000, chart_constant + 1.0),  # SS
-        (1005000, chart_constant + 1.5),  # SS+
-        (1007500, chart_constant + 2.0),  # SSS
-        (1009000, chart_constant + max_rating_modifier),  # SSS+!
-    ]
-
-    for ((lo_score, lo_rating), (hi_score, hi_rating)) in pairwise(score_intervals):
-        if not (lo_score <= score < hi_score):
-            continue
-
-        interval_pos = (score - lo_score) / (hi_score - lo_score)
-        return lo_rating + ((hi_rating - lo_rating) * interval_pos)
-
-
-
-class ChuniFrontend(FE_Base):
-    def __init__(
-        self, cfg: CoreConfig, environment: jinja2.Environment, cfg_dir: str
-    ) -> None:
-        super().__init__(cfg, environment)
-        self.game_cfg = ChuniConfig()
-        if path.exists(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"):
-            self.game_cfg.update(
-                yaml.safe_load(open(f"{cfg_dir}/{ChuniConstants.CONFIG_NAME}"))
-            )
-        self.data = ChuniData(cfg, self.game_cfg)
-        self.nav_name = "Chunithm"
-
-    def get_routes(self) -> List[Route]:
-        return [
-            Route("/", self.render_GET, methods=['GET']),
-            Route("/rating", self.render_GET_rating, methods=['GET']),
-            Mount("/playlog", routes=[
-                Route("/", self.render_GET_playlog, methods=['GET']),
-                Route("/{index}", self.render_GET_playlog, methods=['GET']),
-            ]),
-            Route("/favorites", self.render_GET_favorites, methods=['GET']),
-            Route("/userbox", self.render_GET_userbox, methods=['GET']),
-            Route("/avatar", self.render_GET_avatar, methods=['GET']),
-            Route("/update.map-icon", self.update_map_icon, methods=['POST']),
-            Route("/update.system-voice", self.update_system_voice, methods=['POST']),            
-            Route("/update.userbox", self.update_userbox, methods=['POST']),
-            Route("/update.avatar", self.update_avatar, methods=['POST']),
-            Route("/update.name", self.update_name, methods=['POST']),
-            Route("/update.favorite_music_playlog", self.update_favorite_music_playlog, methods=['POST']),
-            Route("/update.favorite_music_favorites", self.update_favorite_music_favorites, methods=['POST']),
-            Route("/version.change", self.version_change, methods=['POST']),
-            Mount('/img', app=StaticFiles(directory='titles/chuni/img'), name="img")
-        ]
-
-    async def render_GET(self, request: Request) -> bytes:
-        template = self.environment.get_template(
-            "titles/chuni/templates/chuni_index.jinja"
-        )
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            versions = await self.data.profile.get_all_profile_versions(usr_sesh.user_id)
-            profile = None
-            if versions:
-                # chunithm_version is -1 means it is not initialized yet, select a default version from existing.
-                if usr_sesh.chunithm_version < 0:
-                    usr_sesh.chunithm_version = versions[0]
-                profile = await self.data.profile.get_profile_data(usr_sesh.user_id, usr_sesh.chunithm_version)
-
-            user_id = usr_sesh.user_id
-            version = usr_sesh.chunithm_version
-
-            # While map icons and system voices weren't present prior to AMAZON, we don't need to bother checking 
-            # version here - it'll just end up being empty sets and the jinja will ignore the variables anyway.
-            map_icons, total_map_icons = await self.get_available_map_icons(version, profile)
-            system_voices, total_system_voices = await self.get_available_system_voices(version, profile)
-
-            resp = Response(template.render(
-                title=f"{self.core_config.server.name} | {self.nav_name}",
-                game_list=self.environment.globals["game_list"],
-                sesh=vars(usr_sesh),
-                user_id=user_id,
-                profile=profile,
-                version_list=ChuniConstants.VERSION_NAMES,
-                versions=versions,
-                cur_version=version,
-                cur_version_name=ChuniConstants.game_ver_to_string(version),
-                map_icons=map_icons,
-                system_voices=system_voices,
-                total_map_icons=total_map_icons,
-                total_system_voices=total_system_voices
-            ), media_type="text/html; charset=utf-8")
-
-            if usr_sesh.chunithm_version >= 0:
-                encoded_sesh = self.encode_session(usr_sesh)
-                resp.set_cookie("ARTEMIS_SESH", encoded_sesh)
-            return resp
-
-        else:
-            return RedirectResponse("/gate/", 303)
-
-    async def render_GET_rating(self, request: Request) -> bytes:
-        template = self.environment.get_template(
-            "titles/chuni/templates/chuni_rating.jinja"
-        )
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            if usr_sesh.chunithm_version < 0:
-                return RedirectResponse("/game/chuni/", 303)
-            profile = await self.data.profile.get_profile_data(usr_sesh.user_id, usr_sesh.chunithm_version)
-            rating = await self.data.profile.get_profile_rating(usr_sesh.user_id, usr_sesh.chunithm_version)
-            hot_list=[]
-            base_list=[]
-            if profile and rating:
-                song_records = []
-
-                for song in rating:
-                    music_chart = await self.data.static.get_music_chart(usr_sesh.chunithm_version, song.musicId, song.difficultId)
-                    if not music_chart:
-                        continue
-
-                    rank = calculate_song_rank(song.score, profile.version)
-                    rating = calculate_song_rating(song.score, music_chart.level, profile.version)
-
-                    song_rating = int(rating * 10 ** 2) / 10 ** 2
-                    song_records.append({
-                        "difficultId": song.difficultId,
-                        "musicId": song.musicId,
-                        "title": music_chart.title,
-                        "level": music_chart.level,
-                        "score": song.score,
-                        "type": song.type,
-                        "rank": rank,
-                        "song_rating": song_rating,
-                    })
-
-                hot_list = [obj for obj in song_records if obj["type"] == "userRatingBaseHotList"]
-                base_list = [obj for obj in song_records if obj["type"] == "userRatingBaseList"]
-            return Response(template.render(
-                title=f"{self.core_config.server.name} | {self.nav_name}",
-                game_list=self.environment.globals["game_list"],
-                sesh=vars(usr_sesh),
-                profile=profile,
-                hot_list=hot_list,
-                base_list=base_list,
-                cur_version=usr_sesh.chunithm_version,
-                cur_version_name=ChuniConstants.game_ver_to_string(usr_sesh.chunithm_version)
-            ), media_type="text/html; charset=utf-8")
-        else:
-            return RedirectResponse("/gate/", 303)
-
-    async def render_GET_playlog(self, request: Request) -> bytes:
-        template = self.environment.get_template(
-            "titles/chuni/templates/chuni_playlog.jinja"
-        )
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            if usr_sesh.chunithm_version < 0:
-                return RedirectResponse("/game/chuni/", 303)
-            path_index = request.path_params.get('index')
-            if not path_index or int(path_index) < 1:
-                index = 0
-            else:
-                index = int(path_index) - 1 # 0 and 1 are 1st page
-            user_id = usr_sesh.user_id
-            version = usr_sesh.chunithm_version
-            playlog_count = await self.data.score.get_user_playlogs_count(user_id, version)
-            if playlog_count < index * 20 :
-                return Response(template.render(
-                    title=f"{self.core_config.server.name} | {self.nav_name}",
-                    game_list=self.environment.globals["game_list"],
-                    sesh=vars(usr_sesh),
-                    playlog_count=0,
-                    cur_version=version,
-                    cur_version_name=ChuniConstants.game_ver_to_string(version)
-                ), media_type="text/html; charset=utf-8")
-            playlog = await self.data.score.get_playlogs_limited(user_id, version, index, 20)
-            playlog_with_title = []
-            for idx,record in enumerate(playlog):
-                music_chart = await self.data.static.get_music_chart(version, record.musicId, record.level)
-                if music_chart:
-                    difficultyNum=music_chart.level
-                    artist=music_chart.artist
-                    title=music_chart.title
-                    (jacket, ext) = path.splitext(music_chart.jacketPath)
-                    jacket += ".png"
-                else:
-                    difficultyNum=0
-                    artist="unknown"
-                    title="musicid: " + str(record.musicId)
-                    jacket = "unknown.png"
-
-                # Check if this song is a favorite so we can populate the add/remove button
-                is_favorite = await self.data.item.is_favorite(user_id, version, record.musicId)
-
-                playlog_with_title.append({
-                    # Values for the actual readable results
-                    "raw": record,
-                    "title": title,
-                    "difficultyNum": difficultyNum,
-                    "artist": artist,
-                    "jacket": jacket,
-                    # Values used solely for favorite updates
-                    "idx": idx,
-                    "musicId": record.musicId,
-                    "isFav": is_favorite
-                })
-            return Response(template.render(
-                title=f"{self.core_config.server.name} | {self.nav_name}",
-                game_list=self.environment.globals["game_list"],
-                sesh=vars(usr_sesh),
-                user_id=user_id,
-                playlog=playlog_with_title,
-                playlog_count=playlog_count,
-                cur_version=version,
-                cur_version_name=ChuniConstants.game_ver_to_string(version)
-            ), media_type="text/html; charset=utf-8")
-        else:
-            return RedirectResponse("/gate/", 303)
-
-    async def render_GET_favorites(self, request: Request) -> bytes:
-        template = self.environment.get_template(
-            "titles/chuni/templates/chuni_favorites.jinja"
-        )
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            if usr_sesh.chunithm_version < 0:
-                return RedirectResponse("/game/chuni/", 303)
-
-            user_id = usr_sesh.user_id
-            version = usr_sesh.chunithm_version
-            favorites = await self.data.item.get_all_favorites(user_id, version, 1)
-            favorites_count = len(favorites)
-            favorites_with_title = []
-            favorites_by_genre = dict()
-            for idx,favorite in enumerate(favorites):
-                song = await self.data.static.get_song(favorite.favId)
-                if song:
-                    # we likely got multiple results - one for each chart. Just use the first
-                    artist=song.artist
-                    title=song.title
-                    genre=song.genre
-                    (jacket, ext) = path.splitext(song.jacketPath)
-                    jacket += ".png"
-                else:
-                    artist="unknown"
-                    title="musicid: " + str(favorite.favId)
-                    genre="unknown"
-                    jacket = "unknown.png"
-
-                # add a new collection for the genre if this is our first time seeing it
-                if genre not in favorites_by_genre:
-                    favorites_by_genre[genre] = []
-
-                # add the song to the appropriate genre collection
-                favorites_by_genre[genre].append({
-                    "idx": idx,
-                    "title": title,
-                    "artist": artist,
-                    "jacket": jacket,
-                    "favId": favorite.favId
-                })
-
-            # Sort favorites by title before rendering the page
-            for g in favorites_by_genre:
-                favorites_by_genre[g].sort(key=lambda x: x["title"].lower())
-
-            return Response(template.render(
-                title=f"{self.core_config.server.name} | {self.nav_name}",
-                game_list=self.environment.globals["game_list"],
-                sesh=vars(usr_sesh),
-                user_id=user_id,
-                favorites_by_genre=favorites_by_genre,
-                favorites_count=favorites_count,
-                cur_version=version,
-                cur_version_name=ChuniConstants.game_ver_to_string(version)
-            ), media_type="text/html; charset=utf-8")
-        else:
-            return RedirectResponse("/gate/", 303)
-
-    async def get_available_map_icons(self, version: int, profile: Row) -> Tuple[List[Dict], int]:
-        if profile is None:
-            return ([], 0)
-        items = dict()
-        rows = await self.data.static.get_map_icons(version)
-        if rows is None:
-            return (items, 0) # can only happen with old db
-
-        force_unlocked = self.game_cfg.mods.forced_item_unlocks("map_icons")
-
-        user_map_icons = []
-        if not force_unlocked:
-            user_map_icons = await self.data.item.get_items(profile.user, ItemKind.MAP_ICON.value)
-            user_map_icons = [icon["itemId"] for icon in user_map_icons] + [profile.mapIconId]
-
-        for row in rows:
-            if force_unlocked or row["defaultHave"] or row["mapIconId"] in user_map_icons:
-                item = dict()
-                item["id"] = row["mapIconId"]
-                item["name"] = row["name"]
-                item["iconPath"] = path.splitext(row["iconPath"])[0] + ".png"
-                items[row["mapIconId"]] = item
-                 
-        return (items, len(rows))
-
-    async def get_available_system_voices(self, version: int, profile: Row) -> Tuple[List[Dict], int]:
-        if profile is None:
-            return ([], 0)
-        items = dict()
-        rows = await self.data.static.get_system_voices(version)
-        if rows is None:
-            return (items, 0) # can only happen with old db
-        
-        force_unlocked = self.game_cfg.mods.forced_item_unlocks("system_voices")
-
-        user_system_voices = []
-        if not force_unlocked:
-            user_system_voices = await self.data.item.get_items(profile.user, ItemKind.SYSTEM_VOICE.value)
-            user_system_voices = [icon["itemId"] for icon in user_system_voices] + [profile.voiceId]
-
-        for row in rows:
-            if force_unlocked or row["defaultHave"] or row["voiceId"] in user_system_voices:
-                item = dict()
-                item["id"] = row["voiceId"]
-                item["name"] = row["name"]
-                item["imagePath"] = path.splitext(row["imagePath"])[0] + ".png"
-                items[row["voiceId"]] = item
-                 
-        return (items, len(rows))
-
-    async def get_available_nameplates(self, version: int, profile: Row) -> Tuple[List[Dict], int]:
-        items = dict()
-        rows = await self.data.static.get_nameplates(version)
-        if rows is None:
-            return (items, 0) # can only happen with old db
-
-        force_unlocked = self.game_cfg.mods.forced_item_unlocks("nameplates")
-
-        user_nameplates = []
-        if not force_unlocked:
-            user_nameplates = await self.data.item.get_items(profile.user, ItemKind.NAMEPLATE.value)
-            user_nameplates = [item["itemId"] for item in user_nameplates] + [profile.nameplateId]
-
-        for row in rows:
-            if force_unlocked or row["defaultHave"] or row["nameplateId"] in user_nameplates:
-                item = dict()
-                item["id"] = row["nameplateId"]
-                item["name"] = row["name"]
-                item["texturePath"] = path.splitext(row["texturePath"])[0] + ".png"
-                items[row["nameplateId"]] = item
-                 
-        return (items, len(rows))
-
-    async def get_available_trophies(self, version: int, profile: Row) -> Tuple[List[Dict], int]:
-        items = dict()
-        rows = await self.data.static.get_trophies(version)
-        if rows is None:
-            return (items, 0) # can only happen with old db
-            
-        force_unlocked = self.game_cfg.mods.forced_item_unlocks("trophies")
-
-        user_trophies = []
-        if not force_unlocked:
-            user_trophies = await self.data.item.get_items(profile.user, ItemKind.TROPHY.value)
-            user_trophies = [item["itemId"] for item in user_trophies] + [profile.trophyId]
-
-        for row in rows:
-            if force_unlocked or row["defaultHave"] or row["trophyId"] in user_trophies:
-                item = dict()
-                item["id"] = row["trophyId"]
-                item["name"] = row["name"]
-                item["rarity"] = row["rareType"]
-                items[row["trophyId"]] = item
-                 
-        return (items, len(rows))
-
-    async def get_available_characters(self, version: int, profile: Row) -> Tuple[List[Dict], int]:
-        items = dict()
-        rows = await self.data.static.get_characters(version)
-        if rows is None:
-            return (items, 0) # can only happen with old db
-            
-        force_unlocked = self.game_cfg.mods.forced_item_unlocks("character_icons")
-            
-        user_characters = []
-        if not force_unlocked:
-            user_characters = await self.data.item.get_characters(profile.user)
-            user_characters = [chara["characterId"] for chara in user_characters] + [profile.characterId]
-
-        for row in rows:
-            if force_unlocked or row["defaultHave"] or row["characterId"] in user_characters:
-                item = dict()
-                item["id"] = row["characterId"]
-                item["name"] = row["name"]
-                item["iconPath"] = path.splitext(row["imagePath3"])[0] + ".png"
-                items[row["characterId"]] = item
-                 
-        return (items, len(rows))   
-
-    async def get_available_avatar_items(self, version: int, category: AvatarCategory, user_unlocked_items: List[int]) -> Tuple[List[Dict], int]:
-        items = dict()
-        rows = await self.data.static.get_avatar_items(version, category.value)
-        if rows is None:
-            return (items, 0) # can only happen with old db
-
-        force_unlocked = self.game_cfg.mods.forced_item_unlocks("avatar_accessories")
-
-        for row in rows:
-            if force_unlocked or row["defaultHave"] or row["avatarAccessoryId"] in user_unlocked_items:
-                item = dict()
-                item["id"] = row["avatarAccessoryId"]
-                item["name"] = row["name"]
-                item["iconPath"] = path.splitext(row["iconPath"])[0] + ".png"
-                item["texturePath"] = path.splitext(row["texturePath"])[0] + ".png"
-                items[row["avatarAccessoryId"]] = item
-                 
-        return (items, len(rows))
-
-    async def render_GET_userbox(self, request: Request) -> bytes:
-        template = self.environment.get_template(
-            "titles/chuni/templates/chuni_userbox.jinja"
-        )
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            if usr_sesh.chunithm_version < 0:
-                return RedirectResponse("/game/chuni/", 303)
-
-            user_id = usr_sesh.user_id
-            version = usr_sesh.chunithm_version
-
-            # Get the user profile so we know how the userbox is currently configured
-            profile = await self.data.profile.get_profile_data(user_id, version)
-
-            # Build up lists of available userbox components
-            nameplates, total_nameplates = await self.get_available_nameplates(version, profile)
-            trophies, total_trophies = await self.get_available_trophies(version, profile)
-            characters, total_characters = await self.get_available_characters(version, profile)
-
-            # Get the user's team
-            team_name = "ARTEMiS"
-            if profile["teamId"]:
-                team = await self.data.profile.get_team_by_id(profile["teamId"])
-                team_name = team["teamName"]
-            # Figure out the rating color we should use (rank maps to the stylesheet)
-            rating = profile.playerRating / 100;
-            rating_rank = 0
-            if rating >= 16:
-                rating_rank = 8
-            elif rating >= 15.25:
-                rating_rank = 7
-            elif rating >= 14.5:
-                rating_rank = 6
-            elif rating >= 13.25:
-                rating_rank = 5
-            elif rating >= 12:
-                rating_rank = 4
-            elif rating >= 10:
-                rating_rank = 3
-            elif rating >= 7:
-                rating_rank = 2
-            elif rating >= 4:
-                rating_rank = 1
-
-            return Response(template.render(
-                title=f"{self.core_config.server.name} | {self.nav_name}",
-                game_list=self.environment.globals["game_list"],
-                sesh=vars(usr_sesh),
-                user_id=user_id,
-                cur_version=version,
-                cur_version_name=ChuniConstants.game_ver_to_string(version),
-                profile=profile,
-                team_name=team_name,
-                rating_rank=rating_rank,
-                nameplates=nameplates,
-                trophies=trophies,
-                characters=characters,
-                total_nameplates=total_nameplates,
-                total_trophies=total_trophies,
-                total_characters=total_characters
-            ), media_type="text/html; charset=utf-8")            
-        else:
-            return RedirectResponse("/gate/", 303)
-
-    async def render_GET_avatar(self, request: Request) -> bytes:
-        template = self.environment.get_template(
-            "titles/chuni/templates/chuni_avatar.jinja"
-        )
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            if usr_sesh.chunithm_version < 11:
-                # Avatar configuration only for NEW!! and newer
-                return RedirectResponse("/game/chuni/", 303)
-
-            user_id = usr_sesh.user_id
-            version = usr_sesh.chunithm_version
-
-            # Get the user profile so we know what avatar items are currently in use
-            profile = await self.data.profile.get_profile_data(user_id, version)
-            # Get all the user avatar accessories so we know what to populate
-            user_accessories = await self.data.item.get_items(user_id, ItemKind.AVATAR_ACCESSORY.value)
-            user_accessories = [item["itemId"] for item in user_accessories] + \
-                               [profile.avatarBack, profile.avatarItem, profile.avatarWear, \
-                                profile.avatarFront, profile.avatarSkin, profile.avatarHead, profile.avatarFace]
-
-            # Build up available list of items for each avatar category
-            wears, total_wears = await self.get_available_avatar_items(version, AvatarCategory.WEAR, user_accessories)
-            faces, total_faces = await self.get_available_avatar_items(version, AvatarCategory.FACE, user_accessories)
-            heads, total_heads = await self.get_available_avatar_items(version, AvatarCategory.HEAD, user_accessories)
-            skins, total_skins = await self.get_available_avatar_items(version, AvatarCategory.SKIN, user_accessories)
-            items, total_items = await self.get_available_avatar_items(version, AvatarCategory.ITEM, user_accessories)
-            fronts, total_fronts = await self.get_available_avatar_items(version, AvatarCategory.FRONT, user_accessories)
-            backs, total_backs = await self.get_available_avatar_items(version, AvatarCategory.BACK, user_accessories)
-
-            return Response(template.render(
-                title=f"{self.core_config.server.name} | {self.nav_name}",
-                game_list=self.environment.globals["game_list"],
-                sesh=vars(usr_sesh),
-                user_id=user_id,
-                cur_version=version,
-                cur_version_name=ChuniConstants.game_ver_to_string(version),
-                profile=profile,
-                wears=wears,
-                faces=faces,
-                heads=heads,
-                skins=skins,
-                items=items,
-                fronts=fronts,
-                backs=backs,
-                total_wears=total_wears,
-                total_faces=total_faces,
-                total_heads=total_heads,
-                total_skins=total_skins,
-                total_items=total_items,
-                total_fronts=total_fronts,
-                total_backs=total_backs
-            ), media_type="text/html; charset=utf-8")
-        else:
-            return RedirectResponse("/gate/", 303)
-
-    async def update_map_icon(self, request: Request) -> bytes:
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        form_data = await request.form()
-        new_map_icon: str = form_data.get("id")
-        
-        if not new_map_icon:
-            return RedirectResponse("/gate/?e=4", 303)
-
-        if not await self.data.profile.update_map_icon(usr_sesh.user_id, usr_sesh.chunithm_version, new_map_icon):
-            return RedirectResponse("/gate/?e=999", 303)
-
-        return RedirectResponse("/game/chuni/", 303)
-
-    async def update_system_voice(self, request: Request) -> bytes:
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        form_data = await request.form()
-        new_system_voice: str = form_data.get("id")
-        
-        if not new_system_voice:
-            return RedirectResponse("/gate/?e=4", 303)
-
-        if not await self.data.profile.update_system_voice(usr_sesh.user_id, usr_sesh.chunithm_version, new_system_voice):
-            return RedirectResponse("/gate/?e=999", 303)
-
-        return RedirectResponse("/game/chuni/", 303)
-
-    async def update_userbox(self, request: Request) -> bytes:
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        form_data = await request.form()
-        new_nameplate: str = form_data.get("nameplate")
-        new_trophy: str = form_data.get("trophy")
-        new_trophy_sub_1: str = form_data.get("trophySub1")
-        new_trophy_sub_2: str = form_data.get("trophySub2")
-        new_character: str = form_data.get("character")
-        
-        if not new_nameplate or \
-           not new_trophy or \
-           not new_trophy_sub_1 or \
-           not new_trophy_sub_2 or \
-           not new_character:
-            return RedirectResponse("/game/chuni/userbox?e=4", 303)
-
-        if not await self.data.profile.update_userbox(usr_sesh.user_id, usr_sesh.chunithm_version, new_nameplate, new_trophy, new_trophy_sub_1, new_trophy_sub_2, new_character):
-            return RedirectResponse("/gate/?e=999", 303)
-
-        return RedirectResponse("/game/chuni/userbox", 303)
-
-    async def update_avatar(self, request: Request) -> bytes:
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        form_data = await request.form()
-        new_wear: str = form_data.get("wear")
-        new_face: str = form_data.get("face")
-        new_head: str = form_data.get("head")
-        new_skin: str = form_data.get("skin")
-        new_item: str = form_data.get("item")
-        new_front: str = form_data.get("front")
-        new_back: str = form_data.get("back")
-        
-        if not new_wear or \
-           not new_face or \
-           not new_head or \
-           not new_skin or \
-           not new_item or \
-           not new_front or \
-           not new_back:
-            return RedirectResponse("/game/chuni/avatar?e=4", 303)
-
-        if not await self.data.profile.update_avatar(usr_sesh.user_id, usr_sesh.chunithm_version, new_wear, new_face, new_head, new_skin, new_item, new_front, new_back):
-            return RedirectResponse("/gate/?e=999", 303)
-
-        return RedirectResponse("/game/chuni/avatar", 303)
-
-
-    async def update_name(self, request: Request) -> bytes:
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse("/gate/", 303)
-
-        form_data = await request.form()
-        new_name: str  = form_data.get("new_name")
-        new_name_full = ""
-
-        if not new_name:
-            return RedirectResponse("/gate/?e=4", 303)
-
-        if len(new_name) > 8:
-            return RedirectResponse("/gate/?e=8", 303)
-
-        for x in new_name: # FIXME: This will let some invalid characters through atm
-            o = ord(x)
-            try:
-                if o == 0x20:
-                    new_name_full += chr(0x3000)
-                elif o < 0x7F and o > 0x20:
-                    new_name_full += chr(o + 0xFEE0)
-                elif o <= 0x7F:
-                    self.logger.warning(f"Invalid ascii character {o:02X}")
-                    return RedirectResponse("/gate/?e=4", 303)
-                else:
-                    new_name_full += x
-
-            except Exception as e:
-                self.logger.error(f"Something went wrong parsing character {o:04X} - {e}")
-                return RedirectResponse("/gate/?e=4", 303)
-
-        if not await self.data.profile.update_name(usr_sesh.user_id, new_name_full):
-            return RedirectResponse("/gate/?e=999", 303)
-
-        return RedirectResponse("/game/chuni/?s=1", 303)
-
-    async def update_favorite_music(self, request: Request, retPage: str):
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            return RedirectResponse(retPage, 303)
-
-        user_id = usr_sesh.user_id
-        version = usr_sesh.chunithm_version
-        form_data = await request.form()
-        music_id: str = form_data.get("musicId")
-        isAdd: int = int(form_data.get("isAdd"))
-
-        if isAdd:
-            if await self.data.item.put_favorite_music(user_id, version, music_id) == None:
-                return RedirectResponse("/gate/?e=999", 303)
-        else:
-            if await self.data.item.delete_favorite_music(user_id, version, music_id) == None:
-                return RedirectResponse("/gate/?e=999", 303)
-
-        return RedirectResponse(retPage, 303)
-
-    async def update_favorite_music_playlog(self, request: Request):
-        return await self.update_favorite_music(request, "/game/chuni/playlog")
-    
-    async def update_favorite_music_favorites(self, request: Request):
-        return await self.update_favorite_music(request, "/game/chuni/favorites")    
-
-    async def version_change(self, request: Request):
-        usr_sesh = self.validate_session(request)
-        if not usr_sesh:
-            usr_sesh = UserSession()
-
-        if usr_sesh.user_id > 0:
-            form_data = await request.form()
-            chunithm_version = form_data.get("version")
-            self.logger.debug(f"version change to: {chunithm_version}")
-            if(chunithm_version.isdigit()):
-                usr_sesh.chunithm_version=int(chunithm_version)
-                encoded_sesh = self.encode_session(usr_sesh)
-                self.logger.debug(f"Created session with JWT {encoded_sesh}")
-                resp = RedirectResponse("/game/chuni/", 303)
-                resp.set_cookie("ARTEMIS_SESH", encoded_sesh)
-            return resp
-        else:
-            return RedirectResponse("/gate/", 303)

titles/chuni/img/avatar/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore

titles/chuni/img/character/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore

titles/chuni/img/jacket/.gitignore

@@ -1,5 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file and default unknown
-!.gitignore
-!unknown.png

titles/chuni/img/mapIcon/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore

titles/chuni/img/nameplate/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore