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

hiddifypanel/hutils/proxy/xrayjson.py

@@ -0,0 +1,391 @@
+import datetime
+import json
+import copy
+from flask import render_template, request, g
+from hiddifypanel import hutils
+from hiddifypanel.models import Proxy, ProxyTransport, ProxyL3, ProxyCDN, ProxyProto, Domain, ConfigEnum, DomainType
+from flask_babel import gettext as _
+from .xray import is_muxable_agent
+OUTBOUND_LEVEL = 8
+
+
+def configs_as_json(domains: list[Domain], remarks: str) -> str:
+    '''Returns xray configs as json'''
+    outbounds = []
+    for proxy in hutils.proxy.get_valid_proxies(domains):
+        outbound = to_xray(proxy)
+        if 'msg' not in outbound:
+            outbounds.append(outbound)
+
+    outbounds_len = len(outbounds)
+    # reutrn no outbound
+    if outbounds_len < 1:
+        return ''
+
+    all_configs = []
+    base_config = json.loads(render_template('base_xray_config.json.j2', remarks=remarks))
+    # multiple outbounds needs multiple whole base config not just one with multiple outbounds (at least for v2rayng)
+    # https://github.com/2dust/v2rayNG/pull/2827#issue-2127534078
+    if outbounds_len > 1:
+        for out in outbounds:
+            base_config['remarks'] = out['tag']
+            base_config['outbounds'].insert(0, out)
+            all_configs.append(copy.deepcopy(base_config))
+            del base_config['outbounds'][0]
+    else:  # single outbound
+        base_config['outbounds'].insert(0, outbounds[0])
+        all_configs = base_config
+
+    json_configs = json.dumps(all_configs, indent=2, cls=hutils.proxy.ProxyJsonEncoder)
+    return json_configs
+
+
+def to_xray(proxy: dict) -> dict:
+    outbound = {
+        'tag': f'{proxy["extra_info"]} {proxy["name"]} § {proxy["port"]} {proxy["dbdomain"].id}',
+        'protocol': str(proxy['proto']),
+        'settings': {},
+        'streamSettings': {},
+        'mux': {  # default value
+            'enabled': False,
+            'concurrency': -1
+        }
+    }
+    # add multiplex to outbound
+    add_multiplex(outbound, proxy)
+
+    # add stream setting to outbound
+    add_stream_settings(outbound, proxy)
+
+    # add protocol settings to outbound
+    add_proto_settings(outbound, proxy)
+
+    return outbound
+
+# region proto settings
+
+
+def add_proto_settings(base: dict, proxy: dict):
+    if proxy['proto'] == ProxyProto.wireguard:
+        add_wireguard_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.ss:
+        add_shadowsocks_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.vless:
+        add_vless_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.vmess:
+        add_vmess_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.trojan:
+        proxy['password'] = proxy['uuid']
+        add_trojan_settings(base, proxy)
+
+
+def add_wireguard_settings(base: dict, proxy: dict):
+
+    base['settings']['secretKey'] = proxy['wg_pk']
+    base['settings']['reversed'] = [0, 0, 0]
+    base['settings']['mtu'] = 1380  # optional
+    base['settings']['peers'] = [{
+        'endpoint': f'{proxy["server"]}:{int(proxy["port"])}',
+        'publicKey': proxy["wg_server_pub"]
+        # 'allowedIPs':'', 'preSharedKey':'', 'keepAlive':'' # optionals
+    }]
+
+    # optionals
+    # base['settings']['address'] = [f'{proxy["wg_ipv4"]}/32',f'{proxy["wg_ipv6"]}/128']
+    # base['settings']['workers'] = 4
+    # base['settings']['domainStrategy'] = 'ForceIP' # default
+
+
+def add_vless_settings(base: dict, proxy: dict):
+    base['settings']['vnext'] = [
+        {
+            'address': proxy['server'],
+            'port': proxy['port'],
+            "users": [
+                {
+                    'id': proxy['uuid'],
+                    'encryption': 'none',
+                    # 'security': 'auto',
+                    'flow': 'xtls-rprx-vision' if (proxy['transport'] == ProxyTransport.XTLS or base['streamSettings']['security'] == 'reality') else '',
+                    'level': OUTBOUND_LEVEL
+                }
+            ]
+        }
+    ]
+
+
+def add_vmess_settings(base: dict, proxy: dict):
+    base['settings']['vnext'] = [
+        {
+            "address": proxy['server'],
+            "port": proxy['port'],
+            "users": [
+                {
+                    "id": proxy['uuid'],
+                    "security": proxy['cipher'],
+                    "level": OUTBOUND_LEVEL
+                }
+            ]
+        }
+    ]
+
+
+def add_trojan_settings(base: dict, proxy: dict):
+    base['settings']['servers'] = [
+        {
+            # 'email': proxy['uuid'], optional
+            'address': proxy['server'],
+            'port': proxy['port'],
+            'password': proxy['password'],
+            'level': OUTBOUND_LEVEL
+        }
+    ]
+
+
+def add_shadowsocks_settings(base: dict, proxy: dict):
+    base['settings']['servers'] = [
+        {
+            'address': proxy['server'],
+            'port': proxy['port'],
+            'method': proxy['cipher'],
+            'password': proxy['password'],
+            'uot': True,
+            'level': OUTBOUND_LEVEL
+            # 'email': '', optional
+        }
+    ]
+
+# endregion
+
+
+# region stream settings
+
+def add_stream_settings(base: dict, proxy: dict):
+    ss = base['streamSettings']
+    ss['security'] = 'none'  # default
+
+    # security
+    if proxy['l3'] == ProxyL3.reality:
+        ss['security'] = 'reality'
+    elif proxy['l3'] in [ProxyL3.tls, ProxyL3.tls_h2, ProxyL3.tls_h2_h1]:
+        ss['security'] = 'tls'
+
+    # network and transport settings
+    if ss['security'] == 'tls' or 'xtls':
+        ss['tlsSettings'] = {
+            'serverName': proxy['sni'],
+            'allowInsecure': proxy['allow_insecure'],
+            'fingerprint': proxy['fingerprint'],
+            'alpn': [proxy['alpn']],
+            # 'minVersion': '1.2',
+            # 'disableSystemRoot': '',
+            # 'enableSessionResumption': '',
+            # 'pinnedPeerCertificateChainSha256': '',
+            # 'certificates': '',
+            # 'maxVersion': '1.3', # Go lang sets
+            # 'cipherSuites': '', # Go lang sets
+            # 'rejectUnknownSni': '', # default is false
+        }
+    if ss['security'] == 'reality':
+        ss['network'] = proxy['transport']
+        add_reality_stream(ss, proxy)
+    if proxy['l3'] == ProxyL3.kcp:
+        ss['network'] = 'kcp'
+        add_kcp_stream(ss, proxy)
+
+    if proxy['l3'] == ProxyL3.h3_quic:
+        add_quic_stream(ss, proxy)
+
+    if proxy['transport'] == 'tcp' or ss['security'] == 'reality' or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS]):
+        ss['network'] = proxy['transport']
+        add_tcp_stream(ss, proxy)
+    if proxy['transport'] == ProxyTransport.h2 and ss['security'] == 'none' and ss['security'] != 'reality':
+        ss['network'] = proxy['transport']
+        add_http_stream(ss, proxy)
+    if proxy['transport'] == ProxyTransport.grpc:
+        ss['network'] = proxy['transport']
+        add_grpc_stream(ss, proxy)
+    if proxy['transport'] == ProxyTransport.httpupgrade:
+        ss['network'] = proxy['transport']
+        add_httpupgrade_stream(ss, proxy)
+    if proxy['transport'] == 'ws':
+        ss['network'] = proxy['transport']
+        add_ws_stream(ss, proxy)
+
+    # tls fragmentaion
+    add_tls_fragmentation_stream_settings(base, proxy)
+
+
+def add_tcp_stream(ss: dict, proxy: dict):
+    if proxy['l3'] == ProxyL3.http:
+        ss['tcpSettings'] = {
+            'header': {
+                'type': 'http',
+                'request': {
+                    'path': [proxy['path']]
+                }
+            }
+            # 'acceptProxyProtocol': False
+        }
+    else:
+        ss['tcpSettings'] = {
+            'header': {
+                'type': 'none'
+            }
+            # 'acceptProxyProtocol': False
+        }
+
+
+def add_http_stream(ss: dict, proxy: dict):
+    ss['httpSettings'] = {
+        'host': proxy['host'],
+        'path': proxy['path'],
+        # 'read_idle_timeout': 10,  # default disabled
+        # 'health_check_timeout': 15,  # default is 15
+        # 'method': 'PUT',  # default is 15
+        # 'headers': {
+
+        # }
+    }
+
+
+def add_ws_stream(ss: dict, proxy: dict):
+    ss['wsSettings'] = {
+        'path': proxy['path'],
+        'headers': {
+            "Host": proxy['host']
+        }
+        # 'acceptProxyProtocol': False,
+    }
+
+
+def add_grpc_stream(ss: dict, proxy: dict):
+    ss['grpcSettings'] = {
+        'serviceName': proxy['path'],  # proxy['path'] is equal toproxy['grpc_service_name']
+        'idle_timeout': 115,  # by default, the health check is not enabled. may solve some "connection drop" issues
+        'health_check_timeout': 20,  # default is 20
+        # 'initial_windows_size': 0,  # 0 means disabled. greater than 65535 means Dynamic Window mechanism will be disabled
+        # 'permit_without_stream': False, # health check performed when there are no sub-connections
+        # 'multiMode': false, # experimental
+    }
+
+
+def add_httpupgrade_stream(ss: dict, proxy: dict):
+    ss['httpupgradeSettings'] = {
+        'path': proxy['path'],
+        'host': proxy['host'],
+        # 'acceptProxyProtocol': '', for inbounds only
+    }
+
+
+def add_kcp_stream(ss: dict, proxy: dict):
+    # TODO: fix server side configs first
+    ss['kcpSettings'] = {}
+    return
+    ss['kcpSettings'] = {
+        'seed': proxy['path'],
+        # 'mtu': 1350, # optional, default value is written
+        # 'tti': 50, # optional, default value is written
+        # 'uplinkCapacity': 5, # optional, default value is written
+        # 'downlinkCapacity': 20, # optional, default value is written
+        # 'congestion':False, # optional, default value is written
+        # 'readBufferSize': 2,# optional, default value is written
+        # 'writeBufferSize':2 # optional, default value is written
+        # 'header': { # must be same as server (hiddify doesn't use yet)
+        #     'type': 'none'  # choices: none(default), srtp, utp, wechat-video, dtls, wireguards
+        # }
+    }
+
+
+def add_quic_stream(ss: dict, proxy: dict):
+    # TODO: fix server side configs first
+    ss['quicSettings'] = {}
+    return
+    ss['quicSettings'] = {
+        'security': 'chacha20-poly1305',
+        'key': proxy['path'],
+        'header': {
+            'type': 'none'
+        }
+    }
+
+
+def add_reality_stream(ss: dict, proxy: dict):
+    ss['realitySettings'] = {
+        'serverName': proxy['sni'],
+        'fingerprint': proxy['fingerprint'],
+        'shortId': proxy['reality_short_id'],
+        'publicKey': proxy['reality_pbk'],
+        'show': False,
+    }
+
+
+def add_tls_fragmentation_stream_settings(base: dict, proxy: dict):
+    '''Adds tls fragment in the outbounds if tls fragmentation is enabled'''
+    if base['streamSettings']['security'] in ['tls', 'reality']:
+        if proxy.get('tls_fragment_enable'):
+            base['streamSettings']['sockopt'] = {
+                'dialerProxy': 'fragment',
+                'tcpKeepAliveIdle': 100,
+                'tcpNoDelay': True,  # recommended to be enabled with "tcpMptcp": true.
+                "mark": 255
+                # 'tcpFastOpen': True, # the system default setting be used.
+                # 'tcpKeepAliveInterval': 0, # 0 means default GO lang settings, -1 means not enable
+                # 'tcpcongestion': bbr, # Not configuring means using the system default value
+                # 'tcpMptcp': True, # need to be enabled in both server and client configuration (not supported by panel yet)
+            }
+
+# endregion
+
+
+def add_multiplex(base: dict, proxy: dict):
+    if proxy.get('mux_enable') != "xray":
+        return
+
+    concurrency = proxy['mux_max_connections']
+    if concurrency and concurrency > 0:
+        base['mux']['enabled'] = True
+        base['mux']['concurrency'] = concurrency
+        base['mux']['xudpConcurrency'] = concurrency
+        base['mux']['xudpProxyUDP443'] = 'reject'
+
+
+def add_tls_tricks_to_dict(d: dict, proxy: dict):
+    if proxy.get('tls_fragment_enable'):
+        if g.user_agent.get('is_shadowrocket'):
+            d['fragment'] = f'1,{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]}'
+        else:
+            d['fragment'] = f'{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]},tlshello'
+
+    if proxy.get("tls_mixed_case"):
+        d['mc'] = 1
+    if proxy.get("tls_padding_enable"):
+        d['padsize'] = proxy["tls_padding_length"]
+
+
+def add_mux_to_dict(d: dict, proxy):
+    if not is_muxable_agent(proxy):
+        return
+
+    # according to github.com/hiddify/ray2sing/
+    d['muxtype'] = proxy["mux_protocol"]
+    d['muxmaxc'] = proxy["mux_max_connections"]
+    d['mux'] = proxy['mux_min_streams']
+    d['muxsmax'] = proxy["mux_max_streams"]
+    d['muxpad'] = proxy["mux_padding_enable"]
+
+    if proxy.get('mux_brutal_enable'):
+        d['muxup'] = proxy["mux_brutal_up_mbps"]
+        d['muxdown'] = proxy["mux_brutal_down_mbps"]
+
+
+def add_tls_tricks_to_link(proxy: dict) -> str:
+    out = {}
+    add_tls_tricks_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)
+
+
+def add_mux_to_link(proxy: dict) -> str:
+    out = {}
+    add_mux_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)

hiddifypanel/hutils/random.py

@@ -48,3 +48,7 @@ def get_random_unused_port():
     while __is_in_used_port(port):
         port = random.randint(11000, 60000)
     return port
+
+
+def random_case(string):
+    return ''.join(random.choice((str.upper, str.lower))(c) for c in string)

hiddifypanel/hutils/utils.py

@@ -31,7 +31,10 @@ def get_latest_release_version(repo_name):
         if location_header:
             version = re.search(r"/([^/]+)/?$", location_header)
             if version:
-                return version.group(1).replace('v', '')
+                ver = version.group(1).replace('v', '')
+                if ver == "latest":
+                    return get_latest_release_version(repo_name.replace("-", ""))
+                return ver
     except Exception as e:
         return f'{e}'
 

hiddifypanel/models/__init__.py

@@ -1,10 +1,10 @@
 from .role import Role, AccountType
 from .child import Child, ChildMode
-from .config_enum import ConfigCategory, ConfigEnum, Lang, ApplyMode
+from .config_enum import ConfigCategory, ConfigEnum, Lang, ApplyMode, PanelMode, LogLevel
 from .config import StrConfig, BoolConfig, get_hconfigs, hconfig, set_hconfig, add_or_update_config, bulk_register_configs, get_hconfigs_childs
 
 # from .parent_domain import ParentDomain
-from .domain import Domain, DomainType, ShowDomain, get_domain, get_current_proxy_domains, get_panel_domains, get_proxy_domains, get_proxy_domains_db, get_hdomains, hdomain, add_or_update_domain, bulk_register_domains
+from .domain import Domain, DomainType, ShowDomain, get_domain, get_current_proxy_domains, get_panel_domains, get_proxy_domains, get_proxy_domains_db, get_hdomains, hdomain, add_or_update_domain, bulk_register_domains, get_panel_link
 from .proxy import Proxy, ProxyL3, ProxyCDN, ProxyProto, ProxyTransport
 from .user import User, UserMode, UserDetail, ONE_GIG
 from .admin import AdminUser, AdminMode

hiddifypanel/models/admin.py

@@ -2,13 +2,12 @@ from enum import auto
 import uuid
 from flask import g
 from hiddifypanel.models.usage import DailyUsage
-from hiddifypanel.models.utils import fill_username, fill_password
-from sqlalchemy import event
+from sqlalchemy import event, Column, Integer, Enum, Boolean, ForeignKey
 from strenum import StrEnum
 from apiflask import abort
 from flask_babel import gettext as __
 from flask_babel import lazy_gettext as _
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 from hiddifypanel.models.role import Role
 from hiddifypanel.models.base_account import BaseAccount
 
@@ -30,15 +29,15 @@ class AdminUser(BaseAccount):
     This is a model class for a user in a database that includes columns for their ID, UUID, name, online status,
     account expiration date, usage limit, package days, mode, start date, current usage, last reset time, and comment.
     """
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    mode = db.Column(db.Enum(AdminMode), default=AdminMode.agent, nullable=False)
-    can_add_admin = db.Column(db.Boolean, default=False, nullable=False)
-    max_users = db.Column(db.Integer, default=100, nullable=False)
-    max_active_users = db.Column(db.Integer, default=100, nullable=False)
-    users = db.relationship('User', backref='admin')
-    usages = db.relationship('DailyUsage', backref='admin')
-    parent_admin_id = db.Column(db.Integer, db.ForeignKey('admin_user.id'), default=1)
-    parent_admin = db.relationship('AdminUser', remote_side=[id], backref='sub_admins')
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    mode = Column(Enum(AdminMode), default=AdminMode.agent, nullable=False)
+    can_add_admin = Column(Boolean, default=False, nullable=False)
+    max_users = Column(Integer, default=100, nullable=False)
+    max_active_users = Column(Integer, default=100, nullable=False)
+    users = db.relationship('User', backref='admin')  # type: ignore
+    usages = db.relationship('DailyUsage', backref='admin')  # type: ignore
+    parent_admin_id = Column(Integer, ForeignKey('admin_user.id'), default=1)
+    parent_admin = db.relationship('AdminUser', remote_side=[id], backref='sub_admins')  # type: ignore
 
     @property
     def role(self) -> Role | None:
@@ -51,15 +50,28 @@ class AdminUser(BaseAccount):
                 return Role.agent
         return None
 
+    @staticmethod
+    def form_schema(schema):
+        return schema.dump(AdminUser())
+
+    def to_schema(self):
+        admin_dict = self.to_dict()
+        from hiddifypanel.panel.commercial.restapi.v2.admin.admin_user_api import AdminSchema
+        return AdminSchema().load(admin_dict)
+
     def get_id(self) -> str | None:
         return f'admin_{self.id}'
 
-    def to_dict(self, convert_date=True) -> dict:
+    def to_dict(self, convert_date=True, dump_id=False) -> dict:
         base = super().to_dict()
+        if dump_id:
+            base['id'] = self.id
+        from hiddifypanel.models import hconfig, ConfigEnum
         return {**base,
                 'mode': self.mode,
                 'can_add_admin': self.can_add_admin,
                 'parent_admin_uuid': self.parent_admin.uuid if self.parent_admin else None,
+                'lang': hconfig(ConfigEnum.admin_lang)
                 }
 
     @classmethod
@@ -87,7 +99,7 @@ class AdminUser(BaseAccount):
             dbuser.parent_admin_id = parent_admin.id  # type: ignore
 
         dbuser.mode = data.get('mode', AdminMode.agent)
-        dbuser.can_add_admin = data.get('can_add_admin')
+        dbuser.can_add_admin = data.get('can_add_admin') or False
         if commit:
             db.session.commit()
         return dbuser
@@ -143,7 +155,8 @@ class AdminUser(BaseAccount):
         if not admin:
             db.session.add(AdminUser(id=1, uuid=str(uuid.uuid4()), name="Owner", mode=AdminMode.super_admin, comment=""))
             db.session.commit()
-            db.engine.execute("update admin_user set id=1 where name='Owner'")
+
+            db_execute("update admin_user set id=1 where name='Owner'")
             admin = AdminUser.by_id(1)
 
         return admin
@@ -161,5 +174,6 @@ class AdminUser(BaseAccount):
 
 @event.listens_for(AdminUser, "before_insert")
 def before_insert(mapper, connection, target):
-    fill_username(target)
-    fill_password(target)
+    from hiddifypanel import hutils
+    hutils.model.gen_username(target)
+    hutils.model.gen_password(target)

hiddifypanel/models/base_account.py

@@ -2,13 +2,13 @@ import datetime
 import uuid
 from hiddifypanel.models.role import Role
 from sqlalchemy import Column, String, BigInteger, Enum
-from sqlalchemy_serializer import SerializerMixin
+
 from flask_login import UserMixin as FlaskLoginUserMixin
 from hiddifypanel.models import Lang
 from hiddifypanel.database import db
 
 
-class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: ignore
+class BaseAccount(db.Model, FlaskLoginUserMixin):  # type: ignore
     __abstract__ = True
     uuid = Column(String(36), default=lambda: str(uuid.uuid4()), nullable=False, unique=True, index=True)
     name = Column(String(512), nullable=False, default='')
@@ -61,12 +61,12 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
     def add_or_update(cls, commit: bool = True, **data):
         from hiddifypanel import hutils
         db_account = cls.by_uuid(data['uuid'], create=True)
-        db_account.name = data.get('name') or ''
+        db_account.name = data.get('name', '')
         db_account.comment = data.get('comment', '')
         db_account.telegram_id = hutils.convert.to_int(data.get('telegram_id'))
         db_account.lang = data.get('lang')
         if commit:
-            db.session.commit()
+            db.session.commit()  # type: ignore
         return db_account
 
     @classmethod
@@ -74,9 +74,9 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
         for u in accounts:
             cls.add_or_update(commit=False, **u)
         if remove:
-            dd = {u['uuid']: 1 for u in accounts}
+            dd = {str(u['uuid']): 1 for u in accounts}
             for d in cls.query.all():
                 if d.uuid not in dd:
-                    db.session.delete(d)
+                    db.session.delete(d)  # type: ignore
         if commit:
-            db.session.commit()
+            db.session.commit()  # type: ignore

hiddifypanel/models/child.py

@@ -1,30 +1,34 @@
 from __future__ import annotations
 import uuid
-from sqlalchemy_serializer import SerializerMixin
+
+from sqlalchemy import Column, Integer, String, Enum, text
 from enum import auto
 from strenum import StrEnum
 from flask import g, has_app_context
 
 
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 
 
 class ChildMode(StrEnum):
     virtual = auto()
-    remote = auto()
+    remote = auto()  # it's child
+    parent = auto()
+
+# the child model is node
 
 
-class Child(db.Model, SerializerMixin):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    name = db.Column(db.String(200), nullable=False, unique=True)
-    mode = db.Column(db.Enum(ChildMode), nullable=False, default=ChildMode.virtual)
+class Child(db.Model):  # type: ignore
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(200), nullable=False, unique=False)
+    mode = Column(Enum(ChildMode), nullable=False, default=ChildMode.virtual)
     # ip = db.Column(db.String(200), nullable=False, unique=True)
-    unique_id = db.Column(db.String(200), nullable=False, default=lambda: str(uuid.uuid4()), unique=True)
-    domains = db.relationship('Domain', cascade="all,delete", backref='child')
-    proxies = db.relationship('Proxy', cascade="all,delete", backref='child')
-    boolconfigs = db.relationship('BoolConfig', cascade="all,delete", backref='child')
-    strconfigs = db.relationship('StrConfig', cascade="all,delete", backref='child')
-    dailyusages = db.relationship('DailyUsage', cascade="all,delete", backref='child')
+    unique_id = Column(String(200), nullable=False, default=lambda: str(uuid.uuid4()), unique=True)
+    domains = db.relationship('Domain', cascade="all,delete", backref='child')  # type: ignore
+    proxies = db.relationship('Proxy', cascade="all,delete", backref='child')  # type: ignore
+    boolconfigs = db.relationship('BoolConfig', cascade="all,delete", backref='child')  # type: ignore
+    strconfigs = db.relationship('StrConfig', cascade="all,delete", backref='child')  # type: ignore
+    dailyusages = db.relationship('DailyUsage', cascade="all,delete", backref='child')  # type: ignore
 
     def to_dict(self):
         return {
@@ -55,11 +59,14 @@ class Child(db.Model, SerializerMixin):
             db.session.commit()
 
     @classmethod
-    def by_id(cls, id: int) -> "Child":
+    def by_id(cls, id: int) -> 'Child':
         return Child.query.filter(Child.id == id).first()
 
     @classmethod
-    @property
+    def by_unique_id(cls, unique_id: str) -> 'Child':
+        return Child.query.filter(Child.unique_id == unique_id).first()
+
+    @classmethod
     def current(cls) -> "Child":
         if has_app_context() and hasattr(g, "child"):
             return g.child
@@ -68,6 +75,13 @@ class Child(db.Model, SerializerMixin):
             tmp_uuid = str(uuid.uuid4())
             db.session.add(Child(id=0, unique_id=tmp_uuid, name="Root"))
             db.session.commit()
-            db.engine.execute(f'update child set id=0 where unique_id="{tmp_uuid}"')
+            db_execute(f"update child set id=0 where unique_id='{tmp_uuid}'")
             child = Child.by_id(0)
+            print("child-=======", child)
         return child
+
+    @classmethod
+    @property
+    def node(cls) -> "Child | None":
+        if has_app_context() and hasattr(g, "node"):
+            return g.node