Merge remote-tracking branch 'origin/develop' into fork_develop

core/__init__.py

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

core/data/schema/user.py

@@ -1,9 +1,14 @@
 from enum import Enum
 from typing import Dict, Optional
-from sqlalchemy import Table, Column
+from sqlalchemy import Table, Column, and_
 from sqlalchemy.types import Integer, String, TIMESTAMP
 from sqlalchemy.sql.schema import ForeignKey
 from sqlalchemy.sql import func
+from sqlalchemy.dialects.mysql import insert
+from sqlalchemy.sql import func, select, Delete
+from uuid import uuid4
+from datetime import datetime, timedelta
+from sqlalchemy.engine import Row
 
 from core.data.schema.base import BaseData, metadata
 
@@ -26,6 +31,7 @@ frontend_session = Table(
     metadata,
     Column("id", Integer, primary_key=True, unique=True),
     Column("user", ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"), nullable=False),
+    Column("ip", String(15)),
     Column('session_cookie', String(32), nullable=False, unique=True),
     Column("expires", TIMESTAMP, nullable=False),
     mysql_charset='utf8mb4'
@@ -37,21 +43,83 @@ class PermissionBits(Enum):
     PermSysAdmin = 4
 
 class UserData(BaseData):
-    def create_user(self, username: str = None, email: str = None, password: str = None) -> Optional[int]:
-
+    def create_user(self, id: int = None, username: str = None, email: str = None, password: str = None, permission: int = 1) -> Optional[int]:
         if email is None:
-            permission = None
-        else:
-            permission = 0
+            permission = 1
 
-        sql = aime_user.insert().values(username=username, email=email, password=password, permissions=permission)
+        if id is None:
+            sql = insert(aime_user).values(
+                username=username, 
+                email=email, 
+                password=password, 
+                permissions=permission
+            )
+        else:
+            sql = insert(aime_user).values(
+                id=id, 
+                username=username, 
+                email=email, 
+                password=password, 
+                permissions=permission
+            )
+
+        conflict = sql.on_duplicate_key_update(
+            username=username, 
+            email=email, 
+            password=password, 
+            permissions=permission
+        )
         
-        result = self.execute(sql)
+        result = self.execute(conflict)
         if result is None: return None
         return result.lastrowid
     
+    def login(self, user_id: int, passwd: bytes = None, ip: str = "0.0.0.0") -> Optional[str]:
+        sql = select(aime_user).where(and_(aime_user.c.id == user_id, aime_user.c.password == passwd))
+
+        result = self.execute(sql)
+        if result is None: return None
+        
+        usr = result.fetchone()
+        if usr is None: return None
+
+        return self.create_session(user_id, ip)
+    
+    def check_session(self, cookie: str, ip: str = "0.0.0.0") -> Optional[Row]:
+        sql = select(frontend_session).where(
+            and_(
+                frontend_session.c.session_cookie == cookie,
+                frontend_session.c.ip == ip
+            )
+        )
+
+        result = self.execute(sql)
+        if result is None: return None        
+        return result.fetchone()
+    
+    def delete_session(self, session_id: int) -> bool:
+        sql = Delete(frontend_session).where(frontend_session.c.id == session_id)
+
+        result = self.execute(sql)
+        if result is None: return False
+        return True
+
+    def create_session(self, user_id: int, ip: str = "0.0.0.0", expires: datetime = datetime.now() + timedelta(days=1)) -> Optional[str]:
+        cookie = uuid4().hex
+
+        sql = insert(frontend_session).values(
+            user = user_id,
+            ip = ip,
+            session_cookie = cookie,
+            expires = expires
+        )
+
+        result = self.execute(sql)
+        if result is None:
+            return None
+        return cookie
+
     def reset_autoincrement(self, ai_value: int) -> None:
-        # Didn't feel like learning how to do this the right way
-        # if somebody wants a free PR go nuts I guess
+        # ALTER TABLE isn't in sqlalchemy so we do this the ugly way
         sql = f"ALTER TABLE aime_user AUTO_INCREMENT={ai_value}"
         self.execute(sql)

core/data/schema/versions/CORE_1_rollback.sql

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

core/data/schema/versions/CORE_2_upgrade.sql

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

core/frontend.py

@@ -0,0 +1,176 @@
+import logging, coloredlogs
+from typing import Any, Dict
+from twisted.web import resource
+from twisted.web.util import redirectTo
+from twisted.web.http import Request
+from logging.handlers import TimedRotatingFileHandler
+import jinja2
+import bcrypt
+
+from core.config import CoreConfig
+from core.data import Data
+from core.utils import Utils
+
+class FrontendServlet(resource.Resource):
+    children: Dict[str, Any] = {}
+    def getChild(self, name: bytes, request: Request):
+        self.logger.debug(f"{request.getClientIP()} -> {name.decode()}")
+        if name == b'':
+            return self
+        return resource.Resource.getChild(self, name, request)
+
+    def __init__(self, cfg: CoreConfig, config_dir: str) -> None:
+        self.config = cfg
+        log_fmt_str = "[%(asctime)s] Frontend | %(levelname)s | %(message)s"
+        log_fmt = logging.Formatter(log_fmt_str)
+        self.logger = logging.getLogger("frontend")
+        self.environment = jinja2.Environment(loader=jinja2.FileSystemLoader("core/frontend"))
+
+        fileHandler = TimedRotatingFileHandler("{0}/{1}.log".format(self.config.server.log_dir, "frontend"), when="d", backupCount=10)
+        fileHandler.setFormatter(log_fmt)
+        
+        consoleHandler = logging.StreamHandler()
+        consoleHandler.setFormatter(log_fmt)
+
+        self.logger.addHandler(fileHandler)
+        self.logger.addHandler(consoleHandler)
+        
+        self.logger.setLevel(cfg.frontend.loglevel)
+        coloredlogs.install(level=cfg.frontend.loglevel, logger=self.logger, fmt=log_fmt_str)
+
+        fe_game = FE_Game(cfg, self.environment)
+        games = Utils.get_all_titles()
+        for game_dir, game_mod in games.items():
+            if hasattr(game_mod, "frontend"):
+                try:
+                    fe_game.putChild(game_dir.encode(), game_mod.frontend(cfg, self.environment, config_dir))
+                except:
+                    raise
+
+        self.putChild(b"gate", FE_Gate(cfg, self.environment))
+        self.putChild(b"user", FE_User(cfg, self.environment))
+        self.putChild(b"game", fe_game)
+
+        self.logger.info(f"Ready on port {self.config.frontend.port} serving {len(fe_game.children)} games")
+
+    def render_GET(self, request):
+        self.logger.debug(f"{request.getClientIP()} -> {request.uri.decode()}")
+        template = self.environment.get_template("index.jinja")        
+        return template.render(server_name=self.config.server.name, title=self.config.server.name).encode("utf-16")
+
+class FE_Base(resource.Resource):
+    """
+    A Generic skeleton class that all frontend handlers should inherit from
+    Initializes the environment, data, logger, config, and sets isLeaf to true
+    It is expected that game implementations of this class overwrite many of these
+    """
+    isLeaf = True    
+    def __init__(self, cfg: CoreConfig, environment: jinja2.Environment, cfg_dir: str = None) -> None:
+        self.core_config = cfg
+        self.data = Data(cfg)
+        self.logger = logging.getLogger('frontend')
+        self.environment = environment
+
+class FE_Gate(FE_Base):
+    def render_GET(self, request: Request):        
+        self.logger.debug(f"{request.getClientIP()} -> {request.uri.decode()}")
+        uri: str = request.uri.decode()
+        if uri.startswith("/gate/create"):
+            return self.create_user(request)
+
+        if b'e' in request.args:
+            try:
+                err = int(request.args[b'e'][0].decode())
+            except:
+                err = 0
+
+        else: err = 0
+
+        template = self.environment.get_template("gate/gate.jinja")        
+        return template.render(title=f"{self.core_config.server.name} | Login Gate", error=err).encode("utf-16")
+    
+    def render_POST(self, request: Request):
+        uri = request.uri.decode()
+        ip = request.getClientAddress().host
+        
+        if uri == "/gate/gate.login":            
+            access_code: str = request.args[b"access_code"][0].decode()
+            passwd: str = request.args[b"passwd"][0]
+            if passwd == b"":
+                passwd = None
+
+            uid = self.data.card.get_user_id_from_card(access_code)
+            if uid is None:
+                return redirectTo(b"/gate?e=1", request)
+                        
+            if passwd is None:
+                sesh = self.data.user.login(uid, ip=ip)
+
+                if sesh is not None:
+                    return redirectTo(f"/gate/create?ac={access_code}".encode(), request)
+                return redirectTo(b"/gate?e=1", request)
+
+            salt = bcrypt.gensalt()
+            hashed = bcrypt.hashpw(passwd, salt)
+            sesh = self.data.user.login(uid, hashed, ip)
+
+            if sesh is None:
+                return redirectTo(b"/gate?e=1", request)
+
+            request.addCookie('session', sesh)            
+            return redirectTo(b"/user", request)
+        
+        elif uri == "/gate/gate.create":
+            access_code: str = request.args[b"access_code"][0].decode()
+            username: str = request.args[b"username"][0]
+            email: str = request.args[b"email"][0].decode()
+            passwd: str = request.args[b"passwd"][0]
+
+            uid = self.data.card.get_user_id_from_card(access_code)
+            if uid is None:
+                return redirectTo(b"/gate?e=1", request)
+
+            salt = bcrypt.gensalt()
+            hashed = bcrypt.hashpw(passwd, salt)
+
+            result = self.data.user.create_user(uid, username, email, hashed.decode(), 1)
+            if result is None:
+                return redirectTo(b"/gate?e=3", request)
+            
+            sesh = self.data.user.login(uid, hashed, ip)
+            if sesh is None:
+                return redirectTo(b"/gate", request)
+            request.addCookie('session', sesh)
+            
+            return redirectTo(b"/user", request)
+
+        else:
+            return b""
+
+    def create_user(self, request: Request):
+        if b'ac' not in request.args or len(request.args[b'ac'][0].decode()) != 20:            
+            return redirectTo(b"/gate?e=2", request)
+
+        ac = request.args[b'ac'][0].decode()
+        
+        template = self.environment.get_template("gate/create.jinja")        
+        return template.render(title=f"{self.core_config.server.name} | Create User", code=ac).encode("utf-16")
+
+class FE_User(FE_Base):
+    def render_GET(self, request: Request):
+        template = self.environment.get_template("user/index.jinja")
+        return template.render().encode("utf-16")
+        if b'session' not in request.cookies:
+            return redirectTo(b"/gate", request)
+
+class FE_Game(FE_Base):
+    isLeaf = False
+    children: Dict[str, Any] = {}
+
+    def getChild(self, name: bytes, request: Request):
+        if name == b'':
+            return self
+        return resource.Resource.getChild(self, name, request)
+
+    def render_GET(self, request: Request) -> bytes:
+        return redirectTo(b"/user", request)

core/frontend/gate/create.jinja

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

core/frontend/gate/gate.jinja

@@ -0,0 +1,17 @@
+{% extends "index.jinja" %}
+{% block content %}
+<h1>Gate</h1>
+{% include "widgets/err_banner.jinja" %}
+<form id="login" style="max-width: 240px; min-width: 10%;" action="/gate/gate.login" method="post">
+    <div class="form-group row">
+        <label for="access_code">Card Access Code</label><br>
+        <input form="login" class="form-control" name="access_code" id="access_code" type="text" placeholder="00000000000000000000" maxlength="20" required>
+    </div>
+    <div class="form-group row">
+        <label for="passwd">Password</label><br>
+        <input id="passwd" class="form-control" name="passwd" type="password" placeholder="password">
+    </div>
+    <p></p>
+    <input id="submit" class="btn btn-primary" style="display: block; margin: 0 auto;" form="login" type="submit" value="Login">
+</form>
+{% endblock content %}

core/frontend/index.jinja

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

core/frontend/user/index.jinja

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

core/frontend/widgets/err_banner.jinja

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

core/frontend/widgets/topbar.jinja

@@ -0,0 +1,6 @@
+<div style="background: #333; color: #f9f9f9; width: 10%; height: 50px; line-height: 50px; text-align: center; float: left;">
+    Navigation
+</div>
+<div style="background: #333; color: #f9f9f9; width: 90%; height: 50px; line-height: 50px; text-align: center; float: right;">
+    <a href="/gate"><button class="btn btn-primary">Gate</button></a>
+</div>

index.py

@@ -95,6 +95,7 @@ if __name__ == "__main__":
     allnet_server_str = f"tcp:{cfg.allnet.port}:interface={cfg.server.listen_address}"    
     title_server_str = f"tcp:{cfg.title.port}:interface={cfg.server.listen_address}"
     adb_server_str = f"tcp:{cfg.aimedb.port}:interface={cfg.server.listen_address}"
+    frontend_server_str = f"tcp:{cfg.frontend.port}:interface={cfg.server.listen_address}"
 
     billing_server_str = f"tcp:{cfg.billing.port}:interface={cfg.server.listen_address}"
     if cfg.server.is_develop:
@@ -106,6 +107,9 @@ if __name__ == "__main__":
     endpoints.serverFromString(reactor, allnet_server_str).listen(server.Site(dispatcher))
     endpoints.serverFromString(reactor, adb_server_str).listen(AimedbFactory(cfg))
 
+    if cfg.frontend.enable:
+        endpoints.serverFromString(reactor, frontend_server_str).listen(server.Site(FrontendServlet(cfg, args.config)))
+
     if cfg.billing.port > 0:
         endpoints.serverFromString(reactor, billing_server_str).listen(server.Site(dispatcher))
     

requirements.txt

@@ -13,3 +13,5 @@ coloredlogs
 pylibmc
 wacky
 Routes
+bcrypt
+jinja2

requirements_win.txt

@@ -12,3 +12,5 @@ inflection
 coloredlogs
 wacky
 Routes
+bcrypt
+jinja2

titles/wacca/__init__.py

@@ -2,10 +2,12 @@ from titles.wacca.const import WaccaConstants
 from titles.wacca.index import WaccaServlet
 from titles.wacca.read import WaccaReader
 from titles.wacca.database import WaccaData
+from titles.wacca.frontend import WaccaFrontend
 
 index = WaccaServlet
 database = WaccaData
 reader = WaccaReader
+frontend = WaccaFrontend
 
 use_default_title = True
 include_protocol = True

titles/wacca/frontend.py

@@ -0,0 +1,18 @@
+import yaml
+import jinja2
+from twisted.web.http import Request
+
+from core.frontend import FE_Base
+from core.config import CoreConfig
+from titles.wacca.database import WaccaData
+from titles.wacca.config import WaccaConfig
+
+class WaccaFrontend(FE_Base):
+    def __init__(self, cfg: CoreConfig, environment: jinja2.Environment, cfg_dir: str) -> None:
+        super().__init__(cfg, environment)
+        self.data = WaccaData(cfg)
+        self.game_cfg = WaccaConfig()
+        self.game_cfg.update(yaml.safe_load(open(f"{cfg_dir}/wacca.yaml")))
+    
+    def render_GET(self, request: Request) -> bytes:
+        return b""