hiddifypanel 9.0.0.dev90__py3-none-any.whl → 10.5.0.dev0__py3-none-any.whl

hiddifypanel/models/config.py

@@ -1,11 +1,13 @@
-from hiddifypanel.models.config_enum import ConfigEnum
+from typing import Optional
+from hiddifypanel.models.config_enum import ConfigEnum, LogLevel, PanelMode, Lang
 from flask import g
-from sqlalchemy_serializer import SerializerMixin
+
 from hiddifypanel import Events
 from hiddifypanel.database import db
 from hiddifypanel.cache import cache
 from hiddifypanel.models.child import Child, ChildMode
 from sqlalchemy import Column, String, Boolean, Enum, ForeignKey, Integer
+from strenum import StrEnum
 
 
 def error(st):
@@ -13,7 +15,7 @@ def error(st):
     err(st)
 
 
-class BoolConfig(db.Model, SerializerMixin):
+class BoolConfig(db.Model):
     child_id = Column(Integer, ForeignKey('child.id'), primary_key=True, default=0)
     # category = db.Column(db.String(128), primary_key=True)
     key = Column(Enum(ConfigEnum), primary_key=True)
@@ -26,8 +28,17 @@ class BoolConfig(db.Model, SerializerMixin):
             'child_unique_id': d.child.unique_id if d.child else ''
         }
 
+    @staticmethod
+    def from_schema(schema):
+        return schema.dump(BoolConfig())
+
+    def to_schema(self):
+        conf_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import HConfigSchema
+        return HConfigSchema().load(conf_dict)
 
-class StrConfig(db.Model, SerializerMixin):
+
+class StrConfig(db.Model):
     child_id = Column(Integer, ForeignKey('child.id'), primary_key=True, default=0)
     # category = db.Column(db.String(128), primary_key=True)
     key = Column(Enum(ConfigEnum), primary_key=True, default=ConfigEnum.admin_secret)
@@ -40,11 +51,20 @@ class StrConfig(db.Model, SerializerMixin):
             'child_unique_id': d.child.unique_id if d.child else ''
         }
 
+    @staticmethod
+    def from_schema(schema):
+        return schema.dump(StrConfig())
+
+    def to_schema(self):
+        conf_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import HConfigSchema
+        return HConfigSchema().load(conf_dict)
+
 
 @cache.cache(ttl=500)
-def hconfig(key: ConfigEnum, child_id: int | None = None) -> str | int | None:
+def hconfig(key: ConfigEnum, child_id: Optional[int] = None):  # -> str | int | StrEnum | None:
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
 
     value = None
     try:
@@ -63,20 +83,29 @@ def hconfig(key: ConfigEnum, child_id: int | None = None) -> str | int | None:
     except BaseException:
         error(f'{key} error!')
         raise
+    if value != None:
+        if key.type == int:
+            return int(value)
+        elif hasattr(key.type, 'from_str'):
+            return key.type.from_str(value)
 
     return value
 
 
-def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int = None, commit: bool = True):
+def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int | None = None, commit: bool = True):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
+
     print(f"chainging .... {key}---{value}---{child_id}---{commit}")
+    if key.type == int and value != None:
+        int(value)  # for testing int
+
     # hconfig.invalidate(key, child_id)
     # get_hconfigs.invalidate(child_id)
     hconfig.invalidate(key, child_id)
     hconfig.invalidate(key, child_id=child_id)
     hconfig.invalidate(key=key, child_id=child_id)
-    if child_id == Child.current.id:
+    if child_id == Child.current().id:
         hconfig.invalidate(key)
     # hconfig.invalidate_all()
     get_hconfigs.invalidate_all()
@@ -108,12 +137,12 @@ def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int = None,
 
 
 @cache.cache(ttl=500,)
-def get_hconfigs(child_id: int | None = None, json=False):
+def get_hconfigs(child_id: int | None = None, json=False) -> dict:
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
 
     return {**{f'{u.key}' if json else u.key: u.value for u in BoolConfig.query.filter(BoolConfig.child_id == child_id).all() if u.key.type == bool},
-            **{f'{u.key}' if json else u.key: u.value for u in StrConfig.query.filter(StrConfig.child_id == child_id).all() if u.key.type != bool},
+            **{f'{u.key}' if json else u.key: int(u.value) if u.key.type == int and u.value != None else u.value for u in StrConfig.query.filter(StrConfig.child_id == child_id).all() if u.key.type != bool},
             # ConfigEnum.telegram_fakedomain:hdomain(DomainType.telegram_faketls),
             # ConfigEnum.ssfaketls_fakedomain:hdomain(DomainType.ss_faketls),
             # ConfigEnum.fake_cdn_domain:hdomain(DomainType.fake_cdn)
@@ -126,9 +155,9 @@ def get_hconfigs_childs(child_ids: list[int], json=False):
     return {c: get_hconfigs(c, json) for c in child_ids}
 
 
-def add_or_update_config(commit: bool = True, child_id: int = None, override_unique_id: bool = True, **config):
+def add_or_update_config(commit: bool = True, child_id: int | None = None, override_unique_id: bool = True, **config):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
     c = config['key']
     ckey = ConfigEnum(c)
     if c == ConfigEnum.unique_id and not override_unique_id:
@@ -140,13 +169,13 @@ def add_or_update_config(commit: bool = True, child_id: int = None, override_uni
     set_hconfig(ckey, v, child_id, commit=commit)
 
 
-def bulk_register_configs(hconfigs, commit: bool = True, override_child_unique_id: int | None = None, override_unique_id: bool = True):
+def bulk_register_configs(hconfigs, commit: bool = True, froce_child_unique_id: str | None = None, override_unique_id: bool = True):
     from hiddifypanel.panel import hiddify
     for conf in hconfigs:
         # print(conf)
         if conf['key'] == ConfigEnum.unique_id and not override_unique_id:
             continue
-        child_id = hiddify.get_child(unique_id=None)
+        child_id = hiddify.get_child(unique_id=froce_child_unique_id)
         # print(conf, child_id, conf.get('child_unique_id', None), override_child_unique_id)
         add_or_update_config(commit=False, child_id=child_id, **conf)
     if commit:

hiddifypanel/models/config_enum.py

@@ -5,7 +5,13 @@ from strenum import StrEnum
 from fast_enum import FastEnum
 
 
-class Lang(StrEnum):
+class HEnum(StrEnum):
+    @classmethod
+    def from_str(cls, key: str) -> 'HEnum':
+        return cls[key]
+
+
+class Lang(HEnum):
     en = auto()
     fa = auto()
     ru = auto()
@@ -13,6 +19,22 @@ class Lang(StrEnum):
     zh = auto()
 
 
+class PanelMode(HEnum):
+    standalone = auto()
+    parent = auto()
+    child = auto()
+
+
+class LogLevel(HEnum):
+    TRACE = auto()
+    DEBUG = auto()
+    INFO = auto()
+    SUCCESS = auto()
+    WARNING = auto()
+    ERROR = auto()
+    CRITICAL = auto()
+
+
 class ConfigCategory(StrEnum):
     admin = auto()
     branding = auto()
@@ -55,11 +77,19 @@ def _StrConfigDscr(category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.n
     return category, apply_mode, str, show_in_parent
 
 
+def _IntConfigDscr(category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.nothing, show_in_parent: bool = True, hide_in_virtual_child=False):
+    return category, apply_mode, int, show_in_parent
+
+
+def _TypedConfigDscr(ctype: type, category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.nothing, show_in_parent: bool = True, hide_in_virtual_child=False):
+    return category, apply_mode, ctype, show_in_parent
+
+
 class ConfigEnum(metaclass=FastEnum):
     # category: ConfigCategory
-    __slots__ = ('category', 'apply_mode', 'type', 'show_in_parent', 'hide_in_virtual_child')
+    __slots__ = ('name', 'value', 'category', 'apply_mode', 'type', 'show_in_parent', 'hide_in_virtual_child')
 
-    def __init__(self, category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.apply, ctype=str, show_in_parent: bool = True, hide_in_virtual_child=False, name=auto):
+    def __init__(self, category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.apply, ctype=type, show_in_parent: bool = True, hide_in_virtual_child=False, name=auto):
         self.value = name
         self.name = name
         self.category = category
@@ -106,13 +136,27 @@ class ConfigEnum(metaclass=FastEnum):
     package_mode = _StrConfigDscr(ConfigCategory.advanced, hide_in_virtual_child=True)
     utls = _StrConfigDscr(ConfigCategory.advanced)
     telegram_bot_token = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.apply, hide_in_virtual_child=True)
+
+    # region child-parent
+    # deprecated
     is_parent = _BoolConfigDscr(ConfigCategory.hidden)
-    parent_panel = _StrConfigDscr(ConfigCategory.hidden)
+    # parent panel domain
+    parent_panel = _StrConfigDscr(ConfigCategory.hidden)  # should be able to change by user
+    parent_domain = _StrConfigDscr(ConfigCategory.hidden)
+    parent_admin_proxy_path = _StrConfigDscr(ConfigCategory.hidden)
+
+    # the panel mode could be one of these: "parent", "child", "standalone"
+    # this config value would be 'standalone' by default. and would be set by panel itself
+    panel_mode = _TypedConfigDscr(PanelMode, ConfigCategory.hidden, ApplyMode.nothing, hide_in_virtual_child=True)
+    # endregion
+
+    log_level = _TypedConfigDscr(LogLevel, ConfigCategory.hidden, ApplyMode.restart, hide_in_virtual_child=True)
+
     unique_id = _StrConfigDscr(ConfigCategory.hidden)
     last_hash = _StrConfigDscr(ConfigCategory.hidden)
     cdn_forced_host = _StrConfigDscr(ConfigCategory.hidden)  # removed
-    lang = _StrConfigDscr(ConfigCategory.branding)
-    admin_lang = _StrConfigDscr(ConfigCategory.admin)
+    lang = _TypedConfigDscr(Lang, ConfigCategory.branding)
+    admin_lang = _TypedConfigDscr(Lang, ConfigCategory.admin)
     admin_secret = _StrConfigDscr(ConfigCategory.hidden)  # removed
 
     # tls
@@ -128,13 +172,13 @@ class ConfigEnum(metaclass=FastEnum):
     # mux
     mux_enable = _BoolConfigDscr(ConfigCategory.mux, ApplyMode.apply)
     mux_protocol = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_max_connections = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_min_streams = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_max_streams = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_max_connections = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_min_streams = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_max_streams = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
     mux_padding_enable = _BoolConfigDscr(ConfigCategory.mux, ApplyMode.apply)
     mux_brutal_enable = _BoolConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_brutal_up_mbps = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_brutal_down_mbps = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_brutal_up_mbps = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_brutal_down_mbps = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
 
     http_ports = _StrConfigDscr(ConfigCategory.http, ApplyMode.apply)
     kcp_ports = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
@@ -155,11 +199,11 @@ class ConfigEnum(metaclass=FastEnum):
 
     shared_secret = _StrConfigDscr(ConfigCategory.proxies, ApplyMode.apply, hide_in_virtual_child=True)
 
-    telegram_enable = _BoolConfigDscr(ConfigCategory.telegram, ApplyMode.apply)
+    telegram_enable = _BoolConfigDscr(ConfigCategory.telegram, ApplyMode.restart)
     # telegram_secret=auto()
-    telegram_adtag = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.apply, hide_in_virtual_child=True)
-    telegram_lib = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.apply, hide_in_virtual_child=True)
-    telegram_fakedomain = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.apply, hide_in_virtual_child=True)
+    telegram_adtag = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.restart, hide_in_virtual_child=True)
+    telegram_lib = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.restart, hide_in_virtual_child=True)
+    telegram_fakedomain = _StrConfigDscr(ConfigCategory.telegram, ApplyMode.restart, hide_in_virtual_child=True)
 
     v2ray_enable = _BoolConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
     torrent_block = _BoolConfigDscr(ConfigCategory.general, ApplyMode.apply)
@@ -195,6 +239,13 @@ class ConfigEnum(metaclass=FastEnum):
     ws_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     grpc_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     httpupgrade_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    vless_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    trojan_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    reality_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    tcp_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    quic_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    xtls_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    h2_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
 
     db_version = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
 
@@ -230,7 +281,7 @@ class ConfigEnum(metaclass=FastEnum):
         return not self.__eq__(other)
 
     def endswith(self, other):
-        return self.name.endswith(other)
+        return self.name.endswith(other)  # type: ignore
 
     def startswith(self, other):
-        return self.name.startswith(other)
+        return self.name.startswith(other)  # type: ignore

hiddifypanel/models/domain.py

@@ -4,7 +4,7 @@ from typing import List
 from urllib.parse import urlparse
 
 from flask import request
-from sqlalchemy_serializer import SerializerMixin
+
 from flask_babel import lazy_gettext as _
 from sqlalchemy.orm import backref
 from urllib.parse import urlparse
@@ -40,7 +40,7 @@ ShowDomain = db.Table('show_domain',
                       )
 
 
-class Domain(db.Model, SerializerMixin):
+class Domain(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
     domain = db.Column(db.String(200), nullable=False, unique=False)
@@ -67,7 +67,7 @@ class Domain(db.Model, SerializerMixin):
             'domain': self.domain.lower(),
             'mode': self.mode,
             'alias': self.alias,
-            # 'sub_link_only':d.sub_link_only,
+            'sub_link_only': self.sub_link_only,
             'child_unique_id': self.child.unique_id if self.child else '',
             'cdn_ip': self.cdn_ip,
             'servernames': self.servernames,
@@ -84,6 +84,15 @@ class Domain(db.Model, SerializerMixin):
 
         return data
 
+    @staticmethod
+    def from_schema(schema):
+        return schema.dump(Domain())
+
+    def to_schema(self):
+        domain_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import DomainSchema
+        return DomainSchema().load(domain_dict)
+
     @property
     def need_valid_ssl(self):
         return self.mode in [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]
@@ -137,14 +146,22 @@ def get_domain(domain):
     return Domain.query.filter(Domain.domain == domain).first()
 
 
+def get_panel_link(child_id: int | None = None) -> Domain | None:
+    if child_id is None:
+        child_id = Child.current().id
+    domains = Domain.query.filter(Domain.mode.in_(
+        [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]),
+        Domain.child_id == child_id
+    ).all()
+    if not domains:
+        return None
+    return domains[0]
+
+
 def get_panel_domains(always_add_ip=False, always_add_all_domains=False) -> List[Domain]:
     from hiddifypanel import hutils
     domains = []
-    # if hconfig(ConfigEnum.is_parent):
-    #     from .parent_domain import ParentDomain
-    #     domains = ParentDomain.query.all()
-    # else:
-    domains = Domain.query.filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current.id).all()
+    domains = Domain.query.filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current().id).all()
     if not len(domains) or always_add_all_domains:
         domains = Domain.query.filter(Domain.mode.notin_([DomainType.fake, DomainType.reality])).all()
 
@@ -156,11 +173,7 @@ def get_panel_domains(always_add_ip=False, always_add_all_domains=False) -> List
 
 
 def get_proxy_domains(domain):
-    # if hconfig(ConfigEnum.is_parent):
-    #     from hiddifypanel.models.parent_domain import ParentDomain
-    #     db_domain = ParentDomain.query.filter(ParentDomain.domain == domain).first() or ParentDomain(domain=domain, show_domains=[])
-    # else:
-    db_domain = Domain.query.filter(Domain.domain == domain, Domain.child_id == Child.current.id).first()
+    db_domain = Domain.query.filter(Domain.domain == domain, Domain.child_id == Child.current().id).first()
     if not db_domain:
         db_domain = Domain(domain=domain, mode=DomainType.direct, cdn_ip='', show_domains=[])
     return get_proxy_domains_db(db_domain)
@@ -202,11 +215,11 @@ def add_or_update_domain(commit=True, child_id=0, **domain):
         db.session.commit()
 
 
-def bulk_register_domains(domains, commit=True, remove=False, override_child_unique_id=None):
+def bulk_register_domains(domains, commit=True, remove=False, force_child_unique_id: str | None = None):
     from hiddifypanel.panel import hiddify
     child_ids = {}
     for domain in domains:
-        child_id = hiddify.get_child(unique_id=None)
+        child_id = hiddify.get_child(unique_id=force_child_unique_id)
         child_ids[child_id] = 1
         add_or_update_domain(commit=False, child_id=child_id, **domain)
     if remove and len(child_ids):
@@ -215,10 +228,5 @@ def bulk_register_domains(domains, commit=True, remove=False, override_child_uni
             if d.domain not in dd:
                 db.session.delete(d)
 
-    # if commit:
-    db.session.commit()
-    for domain in domains:
-        child_id = hiddify.get_child(unique_id=None)
-        add_or_update_domain(commit=False, child_id=child_id, **domain)
     if commit:
         db.session.commit()

hiddifypanel/models/parent_domain.py

@@ -1,6 +1,6 @@
 # from hiddifypanel.models.domain import Domain
 # from sqlalchemy.orm import backref
-# from sqlalchemy_serializer import SerializerMixin
+#
 
 # from hiddifypanel.database import db
 
@@ -10,7 +10,7 @@
 #                             )
 
 
-# class ParentDomain(db.Model, SerializerMixin):
+# class ParentDomain(db.Model):
 #     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
 #     domain = db.Column(db.String(200), nullable=False, unique=True)
 #     alias = db.Column(db.String(200), nullable=False, unique=False)

hiddifypanel/models/proxy.py

@@ -1,7 +1,7 @@
-from enum import auto
 
-from sqlalchemy_serializer import SerializerMixin
 from strenum import StrEnum
+from enum import auto
+from sqlalchemy import Column, String, Integer, Boolean, Enum, ForeignKey
 
 from hiddifypanel.database import db
 
@@ -39,7 +39,7 @@ class ProxyProto(StrEnum):
     ssr = auto()
     ssh = auto()
     tuic = auto()
-    # hysteria = auto()
+    hysteria = auto()
     hysteria2 = auto()
     wireguard = auto()
 
@@ -57,15 +57,15 @@ class ProxyL3(StrEnum):
     custom = auto()
 
 
-class Proxy(db.Model, SerializerMixin):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
-    name = db.Column(db.String(200), nullable=False, unique=False)
-    enable = db.Column(db.Boolean, nullable=False)
-    proto = db.Column(db.Enum(ProxyProto), nullable=False)
-    l3 = db.Column(db.Enum(ProxyL3), nullable=False)
-    transport = db.Column(db.Enum(ProxyTransport), nullable=False)
-    cdn = db.Column(db.Enum(ProxyCDN), nullable=False)
+class Proxy(db.Model):  # type: ignore
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    child_id = Column(Integer, ForeignKey('child.id'), default=0)
+    name = Column(String(200), nullable=False, unique=False)
+    enable = Column(Boolean, nullable=False)
+    proto = Column(Enum(ProxyProto), nullable=False)
+    l3 = Column(Enum(ProxyL3), nullable=False)
+    transport = Column(Enum(ProxyTransport), nullable=False)
+    cdn = Column(Enum(ProxyCDN), nullable=False)
 
     @property
     def enabled(self):
@@ -82,12 +82,15 @@ class Proxy(db.Model, SerializerMixin):
             'child_unique_id': self.child.unique_id if self.child else ''
         }
 
+    def __str__(self):
+        return str(self.to_dict())
+
     @staticmethod
     def add_or_update(commit=True, child_id=0, **proxy):
         dbproxy = Proxy.query.filter(Proxy.name == proxy['name']).first()
         if not dbproxy:
             dbproxy = Proxy()
-            db.session.add(dbproxy)
+            db.session.add(dbproxy)  # type: ignore
         dbproxy.enable = proxy['enable']
         dbproxy.name = proxy['name']
         dbproxy.proto = proxy['proto']
@@ -96,16 +99,22 @@ class Proxy(db.Model, SerializerMixin):
         dbproxy.l3 = proxy['l3']
         dbproxy.child_id = child_id
         if commit:
-            db.session.commit()
+            db.session.commit()  # type: ignore
 
     @staticmethod
-    def bulk_register(proxies, commit=True, override_child_unique_id=None):
+    def from_schema(schema):
+        return schema.dump(Proxy())
+
+    def to_schema(self):
+        proxy_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.parent.schema import ProxySchema
+        return ProxySchema().load(proxy_dict)
+
+    @staticmethod
+    def bulk_register(proxies, commit=True, force_child_unique_id: str | None = None):
         from hiddifypanel.panel import hiddify
         for proxy in proxies:
-            child_id = hiddify.get_child(unique_id=None)
+            child_id = hiddify.get_child(unique_id=force_child_unique_id)
             Proxy.add_or_update(commit=False, child_id=child_id, **proxy)
         if commit:
-            db.session.commit()
-
-    def __str__(self):
-        return str(self.to_dict())
+            db.session.commit()  # type: ignore

hiddifypanel/models/report.py

@@ -1,11 +1,10 @@
 import datetime
 
-from sqlalchemy_serializer import SerializerMixin
 
 from hiddifypanel.database import db
 
 
-class Report(db.Model, SerializerMixin):
+class Report(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     user_id = db.Column(db.Integer, db.ForeignKey('user.id'), default=0, nullable=False)
     asn_id = db.Column(db.String(200), nullable=False, unique=False)
@@ -19,7 +18,7 @@ class Report(db.Model, SerializerMixin):
     details = db.relationship('ReportDetail', cascade="all,delete", backref='report', lazy='dynamic',)
 
 
-class ReportDetail(db.Model, SerializerMixin):
+class ReportDetail(db.Model):
     report_id = db.Column(db.Integer, db.ForeignKey('report.id'), primary_key=True, )
     proxy_id = db.Column(db.Integer, db.ForeignKey('proxy.id'), primary_key=True, )
     ping = db.Column(db.Integer, default=-1)

hiddifypanel/models/usage.py

@@ -3,12 +3,12 @@ from datetime import timedelta, date
 
 from flask import g
 from sqlalchemy import func
-from sqlalchemy_serializer import SerializerMixin
+
 
 from hiddifypanel.database import db
 
 
-class DailyUsage(db.Model, SerializerMixin):
+class DailyUsage(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     date = db.Column(db.Date, default=datetime.date.today(), index=True)
     usage = db.Column(db.BigInteger, default=0, nullable=False)

hiddifypanel/models/user.py

@@ -2,13 +2,12 @@ import datetime
 from enum import auto
 from hiddifypanel.models.role import Role
 from dateutil import relativedelta
-from sqlalchemy_serializer import SerializerMixin
+
 from strenum import StrEnum
 from sqlalchemy import event
 
 from hiddifypanel.database import db
 from hiddifypanel.models import Lang
-from hiddifypanel.models.utils import fill_password, fill_username
 from hiddifypanel.models.base_account import BaseAccount
 from hiddifypanel.models.admin import AdminUser
 
@@ -36,13 +35,13 @@ package_mode_dic = {
 }
 
 
-class UserDetail(db.Model, SerializerMixin):
+class UserDetail(db.Model):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     user_id = db.Column(db.Integer, db.ForeignKey('user.id'), default=0, nullable=False)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0, nullable=False)
     last_online = db.Column(db.DateTime, nullable=False, default=datetime.datetime.min)
     current_usage = db.Column(db.BigInteger, default=0, nullable=False)
-    connected_ips = db.Column(db.String(512), default='', nullable=False)
+    connected_devices = db.Column(db.String(512), default='', nullable=False)
 
     @property
     def current_usage_GB(self):
@@ -53,8 +52,8 @@ class UserDetail(db.Model, SerializerMixin):
         self.current_usage = (value or 0) * ONE_GIG
 
     @property
-    def ips(self):
-        return [] if not self.connected_ips else self.connected_ips.split(",")
+    def devices(self):
+        return [] if not self.connected_devices else self.connected_devices.split(",")
 
 
 class User(BaseAccount):
@@ -122,16 +121,16 @@ class User(BaseAccount):
             is_active = False
         elif self.remaining_days < 0:
             is_active = False
-        elif len(self.ips) > max(3, self.max_ips):
+        elif len(self.devices) > max(3, self.max_ips):
             is_active = False
         return is_active
 
     @property
-    def ips(self):
+    def devices(self):
         res = {}
         for detail in UserDetail.query.filter(UserDetail.user_id == self.id):
-            for ip in detail.ips:
-                res[ip] = 1
+            for device in detail.devices:
+                res[device] = 1
         return list(res.keys())
 
     def user_should_reset(self) -> bool:
@@ -208,7 +207,7 @@ class User(BaseAccount):
         from hiddifypanel import hutils
         dbuser = super().add_or_update(commit=commit, **data)
         if data.get('added_by_uuid'):
-            admin = AdminUser.by_uuid(data.get('added_by_uuid'), create=True) or AdminUser.current_admin_or_owner()
+            admin = AdminUser.by_uuid(data.get('added_by_uuid'), create=True) or AdminUser.current_admin_or_owner()  # type: ignore
             dbuser.added_by = admin.id
         else:
             dbuser.added_by = 1
@@ -233,17 +232,17 @@ class User(BaseAccount):
         if data.get('ed25519_private_key', ''):
             dbuser.ed25519_private_key = data.get('ed25519_private_key', '')
             dbuser.ed25519_public_key = data.get('ed25519_public_key', '')
-        if not dbuser.ed25519_private_key:
-            from hiddifypanel.panel import hiddify
-            priv, publ = hiddify.get_ed25519_private_public_pair()
-            dbuser.ed25519_private_key = priv
-            dbuser.ed25519_public_key = publ
+        # if not dbuser.ed25519_private_key:
+        #     priv, publ = hutils.crypto.get_ed25519_private_public_pair()
+        #     dbuser.ed25519_private_key = priv
+        #     dbuser.ed25519_public_key = publ
+
         dbuser.wg_pk = data.get('wg_pk', dbuser.wg_pk)
         dbuser.wg_pub = data.get('wg_pub', dbuser.wg_pub)
         dbuser.wg_psk = data.get('wg_psk', dbuser.wg_psk)
-        if not dbuser.wg_pk:
-            from hiddifypanel.panel import hiddify
-            dbuser.wg_pk, dbuser.wg_pub, dbuser.wg_psk = hiddify.get_wg_private_public_psk_pair()
+
+        # if not dbuser.wg_pk:
+        #     dbuser.wg_pk, dbuser.wg_pub, dbuser.wg_psk = hutils.crypto.get_wg_private_public_psk_pair()
 
         mode = data.get('mode', UserMode.no_reset)
         if mode == 'disable':
@@ -257,6 +256,15 @@ class User(BaseAccount):
             db.session.commit()
         return dbuser
 
+    @staticmethod
+    def form_schema(schema):
+        return schema.dump(User())
+
+    def to_schema(self):
+        user_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.admin.user_api import UserSchema
+        return UserSchema().load(user_dict)
+
     def to_dict(self, convert_date=True, dump_id=False) -> dict:
         base = super().to_dict()
         from hiddifypanel import hutils
@@ -270,7 +278,7 @@ class User(BaseAccount):
                 'start_date': hutils.convert.date_to_json(self.start_date)if convert_date else self.start_date,
                 'current_usage_GB': self.current_usage_GB,
                 'last_reset_time': hutils.convert.date_to_json(self.last_reset_time) if convert_date else self.last_reset_time,
-                'added_by_uuid': self.admin.uuid,
+                'added_by_uuid': self.admin.uuid if self.admin else None,
                 'ed25519_private_key': self.ed25519_private_key,
                 'ed25519_public_key': self.ed25519_public_key,
                 'wg_pk': self.wg_pk,
@@ -302,5 +310,8 @@ class User(BaseAccount):
 
 @event.listens_for(User, 'before_insert')
 def on_user_insert(mapper, connection, target):
-    fill_username(target)
-    fill_password(target)
+    from hiddifypanel import hutils
+    hutils.model.gen_username(target)
+    hutils.model.gen_password(target)
+    hutils.model.gen_ed25519_keys(target)
+    hutils.model.gen_wg_keys(target)