hiddifypanel 10.30.6.dev0__py3-none-any.whl → 10.30.8.dev0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.30.6.dev0
+10.30.8.dev0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.30.6.dev0'
+__version__='10.30.8.dev0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-07-05','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-07-10','%Y-%m-%d')

hiddifypanel/auth.py

@@ -98,8 +98,24 @@ def login_user(user: AdminUser | User, remember=False, duration=None, force=Fals
 
 
 def login_required(roles: set[Role] | None = None, node_auth: bool = False):
+
+    def decorator(func):
+        from flask import has_app_context, current_app
+        # Conditionally apply x if has_app_context() is true
+        if has_app_context():
+            func = current_app.doc(security='Hiddify-API-Key')(func)
+
+        # Always apply y
+        func = login_required2(roles, node_auth)(func)
+        return func
+    return decorator
+
+
+def login_required2(roles: set[Role] | None = None, node_auth: bool = False):
     '''When both roles and node_auth is set, means authentication can be done by either uuid or unique_id'''
+
     def wrapper(fn):
+
         @wraps(fn)
         def decorated_view(*args, **kwargs):
             # print('xxxx', current_account)

hiddifypanel/base.py

@@ -37,7 +37,7 @@ def init_logger(app, cli):
 
 def create_app(*args, cli=False, **config):
 
-    app = APIFlask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True, version='2.0.0', title="Hiddify API",
+    app = APIFlask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True, version='2.2.0', title="Hiddify API",
                    openapi_blueprint_url_prefix="/<proxy_path>/api", docs_ui='elements', json_errors=False, enable_openapi=not cli)
     # app = Flask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True)
 
@@ -72,6 +72,13 @@ def create_app(*args, cli=False, **config):
         app.config['SESSION_REDIS'] = redis_client
         app.config['SESSION_PERMANENT'] = True
         app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=10)
+        app.security_schemes = {  # equals to use config SECURITY_SCHEMES
+            'Hiddify-API-Key': {
+                'type': 'apiKey',
+                'in': 'header',
+                'name': 'Hiddify-API-Key',
+            }
+        }
         Session(app)
 
         app.jinja_env.line_statement_prefix = '%'

hiddifypanel/drivers/singbox_api.py

@@ -4,6 +4,7 @@ from .abstract_driver import DriverABS
 from flask import current_app
 import json
 from collections import defaultdict
+from hiddifypanel.cache import cache
 
 
 class SingboxApi(DriverABS):
@@ -18,6 +19,7 @@ class SingboxApi(DriverABS):
             json_data = json.load(f)
             return {u.split("@")[0]: 1 for u in json_data['experimental']['v2ray_api']['stats']['users']}
 
+    @cache.cache(ttl=300)
     def get_inbound_tags(self):
         try:
             xray_client = self.get_singbox_client()

hiddifypanel/drivers/ssh_liberty_bridge_api.py

@@ -29,11 +29,21 @@ class SSHLibertyBridgeApi(DriverABS):
 
     def remove_client(self, user):
         redis_client = self.get_ssh_redis_client()
+        if user.ed25519_public_key is None:
+            members = redis_client.smembers(USERS_SET)
+            for member in members:
+                if member.startswith(user.uuid):
+                    redis_client.srem(USERS_SET, member)
+
         redis_client.srem(USERS_SET, f'{user.uuid}::{user.ed25519_public_key}')
         redis_client.hdel(USERS_USAGE, f'{user.uuid}')
         redis_client.save()
 
     def get_all_usage(self, users):
+        redis_client = self.get_ssh_redis_client()
+        allusage = redis_client.hgetall(USERS_USAGE)
+        redis_client.delete(USERS_USAGE)
+        return {u: int(allusage.get(u.uuid) or 0) for u in users}
         return {u: self.get_usage_imp(u.uuid) for u in users}
 
     def get_usage_imp(self, client_uuid: str, reset: bool = True) -> int:

hiddifypanel/drivers/user_driver.py

@@ -33,16 +33,19 @@ def get_enabled_users():
     for driver in enabled_drivers():
         try:
             for u, v in driver.get_enabled_users().items():
+                # print(u, "enabled", v, driver)
                 if not v:
                     continue
                 d[u] += 1
             total += 1
         except Exception as e:
+            print(driver)
             hiddify.error(f'ERROR! {driver.__class__.__name__} has error in get_enabled users')
-
+    # print(d, total)
     res = defaultdict(bool)
     for u, v in d.items():
-        res[u] = v >= total  # ignore singbox
+        # res[u] = v >= total  # ignore singbox
+        res[u] = v >= 1
     return res
 
 

hiddifypanel/drivers/wireguard_api.py

@@ -4,40 +4,25 @@ import os
 from .abstract_driver import DriverABS
 from hiddifypanel.models import User, hconfig, ConfigEnum
 from hiddifypanel.panel.run_commander import Command, commander
+import redis
+
+
+USERS_USAGE = "wg:users-usage"
 
 
 class WireguardApi(DriverABS):
+    def get_redis_client(self):
+        if not hasattr(self, 'redis_client'):
+            self.redis_client = redis.from_url('unix:///opt/hiddify-manager/other/redis/run.sock?db=1')
+
+        return self.redis_client
+
     def is_enabled(self) -> bool:
         return hconfig(ConfigEnum.wireguard_enable)
-    
-    WG_LOCAL_USAGE_FILE_PATH = os.path.join('/opt/hiddify-manager/','hiddify-panel','wireguard_usages.json')
-    OLD_WG_LOCAL_USAGE_FILE_PATH = os.path.join('/opt/hiddify-manager/','hiddify-panel','hiddify_usages.json')
 
     def __init__(self) -> None:
         super().__init__()
 
-        if os.path.isfile(WireguardApi.OLD_WG_LOCAL_USAGE_FILE_PATH) and not os.path.isfile(WireguardApi.WG_LOCAL_USAGE_FILE_PATH):
-            os.rename(WireguardApi.OLD_WG_LOCAL_USAGE_FILE_PATH,WireguardApi.WG_LOCAL_USAGE_FILE_PATH)
-
-        if not self.is_usages_file_exists_and_json():
-            self.init_empty_usages_file()
-        # create empty local usage file
-
-    def is_usages_file_exists_and_json(self) -> bool:
-        if os.path.isfile(WireguardApi.WG_LOCAL_USAGE_FILE_PATH):
-            try:
-                # try to load it as a JSON
-                self.__get_local_usage()
-                return True
-            except json.decoder.JSONDecodeError:
-                os.remove(WireguardApi.WG_LOCAL_USAGE_FILE_PATH)
-                return False
-        return False
-    def init_empty_usages_file(self):
-        with open(WireguardApi.WG_LOCAL_USAGE_FILE_PATH, 'w+') as f:
-            json.dump({}, f)
-
-    
     def __get_wg_usages(self) -> dict:
         raw_output = commander(Command.update_wg_usage, run_in_background=False)
         data = {}
@@ -54,11 +39,13 @@ class WireguardApi(DriverABS):
         return data
 
     def __get_local_usage(self) -> dict:
-        with open(WireguardApi.WG_LOCAL_USAGE_FILE_PATH, 'r') as f:
-            data = json.load(f)
-            return data
+        usage_data = self.get_redis_client() .get(USERS_USAGE)
+        if usage_data:
+            return json.loads(usage_data)
+
+        return {}
 
-    def __sync_local_usages(self) -> dict:
+    def __sync_local_usages(self, users) -> dict:
         local_usage = self.__get_local_usage()
         wg_usage = self.__get_wg_usages()
         res = {}
@@ -66,16 +53,18 @@ class WireguardApi(DriverABS):
         for local_wg_pub in local_usage.copy().keys():
             if local_wg_pub not in wg_usage:
                 del local_usage[local_wg_pub]
-
+        uuid_map = {u.wg_pub: u for u in users}
         for wg_pub, wg_usage in wg_usage.items():
+            user = uuid_map.get(wg_pub)
+            uuid = user.uuid if user else None
             if not local_usage.get(wg_pub):
-                local_usage[wg_pub] = wg_usage
+                local_usage[wg_pub] = {"uuid": uuid, "usage": wg_usage}
                 continue
-            res[wg_pub] = self.calculate_reset(local_usage[wg_pub], wg_usage)
-            local_usage[wg_pub] = wg_usage
+            res[wg_pub] = self.calculate_reset(local_usage[wg_pub]['usage'], wg_usage)
+            local_usage[wg_pub] = {"uuid": uuid, "usage": wg_usage}
+
+        self.get_redis_client().set(USERS_USAGE, json.dumps(local_usage))
 
-        with open(WireguardApi.WG_LOCAL_USAGE_FILE_PATH, 'w') as f:
-            json.dump(local_usage, f)
         return res
 
     def calculate_reset(self, last_usage: dict, current_usage: dict) -> dict:
@@ -94,15 +83,16 @@ class WireguardApi(DriverABS):
         if not hconfig(ConfigEnum.wireguard_enable):
             return {}
         usages = self.__get_wg_usages()
-        wg_pubs = set(usages.keys())
-
-        users = User.query.all()
-        enabled = {}
-        for u in users:
-            if u.wg_pub in wg_pubs:
+        new_wg_pubs = set(usages.keys())
+        old_usages = self.__get_local_usage()
+        old_wg_pubs = set(old_usages.keys())
+        enabled = {u['uuid']: 1 for u in old_usages.values()}
+        not_included = new_wg_pubs - old_wg_pubs
+        if not_included:
+            users = User.query.filter(User.wg_pub.in_(not_included).all())
+            for u in users:
                 enabled[u.uuid] = 1
-            else:
-                enabled[u.uuid] = 0
+
         return enabled
 
     def add_client(self, user):
@@ -114,7 +104,7 @@ class WireguardApi(DriverABS):
     def get_all_usage(self, users, reset=True):
         if not hconfig(ConfigEnum.wireguard_enable):
             return {}
-        all_usages = self.__sync_local_usages()
+        all_usages = self.__sync_local_usages(users)
         res = {}
         for u in users:
             if use := all_usages.get(u.wg_pub):

hiddifypanel/drivers/xray_api.py

@@ -2,6 +2,7 @@ import xtlsapi
 from hiddifypanel.models import *
 from .abstract_driver import DriverABS
 from collections import defaultdict
+from hiddifypanel.cache import cache
 
 
 class XrayApi(DriverABS):
@@ -19,7 +20,18 @@ class XrayApi(DriverABS):
             if "user>>>" not in use.name:
                 continue
             uuid = use.name.split(">>>")[1].split("@")[0]
-            res[uuid] = 1
+            try:
+                t = "xtls"
+                protocol = "vless"
+                xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
+                xray_client.remove_client(t, f'{uuid}@hiddify.com')
+                res[uuid] = 0
+            except xtlsapi.xtlsapi.exceptions.EmailAlreadyExists as e:
+                res[uuid] = 1
+            except Exception as e:
+                print(f"error {e}")
+                res[uuid] = 0
+
         return res
 
         # xray_client = self.get_xray_client()
@@ -40,15 +52,16 @@ class XrayApi(DriverABS):
         #         enabled[uuid] = e
         # return enabled
 
+    # @cache.cache(ttl=300)
     def get_inbound_tags(self):
         try:
             xray_client = self.get_xray_client()
-            inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')]
+            inbounds = {inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')}
             print(f"Success in get inbound tags {inbounds}")
         except Exception as e:
             print(f"error in get inbound tags {e}")
-            inbounds = []
-        return list(set(inbounds))
+            inbounds = {}
+        return list(inbounds)
 
     def add_client(self, user):
         uuid = user.uuid
@@ -65,6 +78,7 @@ class XrayApi(DriverABS):
             'v2ray': 'shadowsocks',
             'kcp': 'vless',
             'dispatcher': 'trojan',
+            'reality': 'vless'
         }
 
         def proto(t):

hiddifypanel/hutils/auth.py

@@ -6,7 +6,7 @@ from uuid import UUID
 def is_uuid_valid(uuid: str, version: int = 4) -> bool:
     try:
         uuid_obj = UUID(uuid, version=version)
-    except ValueError:
+    except Exception:
         return False
     return str(uuid_obj) == uuid
 

hiddifypanel/hutils/proxy/xray.py

@@ -82,7 +82,7 @@ def to_link(proxy: dict) -> str | dict:
             return "ShadowTLS is Not Supported for this platform"
             # return f'{baseurl}?plugin=v2ray-plugin&path={proxy["proxy_path"]}&host={proxy["fakedomain"]}&udp-over-tcp=true#{name_link}'
         if proxy['proto'] == 'v2ray':
-            return f'{baseurl}?plugin=v2ray-plugin&mode=websocket&path={proxy["proxy_path"]}&host={proxy["fakedomain"]}&tls&udp-over-tcp=true#{name_link}'
+            return f'{baseurl}?plugin=v2ray-plugin&mode=websocket&path={proxy["proxy_path"]}&host={proxy["sni"]}&tls&udp-over-tcp=true#{name_link}'
 
     if proxy['proto'] == 'tuic':
         baseurl = f'tuic://{proxy["uuid"]}:{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?congestion_control=cubic&udp_relay_mode=native&sni={proxy["sni"]}&alpn=h3'

hiddifypanel/hutils/proxy/xrayjson.py

@@ -8,7 +8,7 @@ from hiddifypanel.models import hconfig, ConfigEnum
 from .xray import is_muxable_agent, OUTBOUND_LEVEL
 
 
-def configs_as_json(domains: list[Domain], user: User, expire_days: int,  remarks: str) -> str:
+def configs_as_json(domains: list[Domain], user: User, expire_days: int, remarks: str) -> str:
     '''Returns xray configs as json'''
     all_configs = []
 
@@ -35,50 +35,48 @@ def configs_as_json(domains: list[Domain], user: User, expire_days: int,  remark
         )
     # endregion
 
-    # region show status (active/disable)
-    active = True
     if not user.is_active:
+        # region show status (active/disable)
         tag = '✖ ' + (hutils.encode.url_encode('بسته شما به پایان رسید') if hconfig(ConfigEnum.lang) == 'fa' else 'Package Ended')
         # add user status
         all_configs.append(
             null_config(tag)
         )
-        active = False
-    # endregion
-
-    if active:
+        # endregion
+    else:
         # TODO: seperate codes to small functions
         # TODO: check what are unsupported protocols in other apps
-        unsupported_protos = []
-        unsupported_transport = []
+        unsupported_protos = {}
+        unsupported_transport = {}
         if g.user_agent.get('is_v2rayng'):
             # TODO: ensure which protocols are not supported in v2rayng
-            unsupported_protos = [ProxyProto.wireguard, ProxyProto.hysteria, ProxyProto.hysteria2, ProxyProto.tuic, ProxyProto.ss, ProxyProto.ssr, ProxyProto.ssh]
+            unsupported_protos = {ProxyProto.wireguard, ProxyProto.hysteria, ProxyProto.hysteria2,
+                                  ProxyProto.tuic, ProxyProto.ss, ProxyProto.ssr, ProxyProto.ssh}
             if not hutils.flask.is_client_version(hutils.flask.ClientVersion.v2ryang, 1, 8, 18):
-                unsupported_transport = [ProxyTransport.httpupgrade]
+                unsupported_transport = {ProxyTransport.httpupgrade}
 
         # 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
         outbounds = []
         for proxy in hutils.proxy.get_valid_proxies(domains):
-            if unsupported_protos and proxy['proto'] in unsupported_protos:
+            if proxy['proto'] in unsupported_protos:
                 continue
-            if unsupported_transport and proxy['transport'] in unsupported_transport:
+            if proxy['transport'] in unsupported_transport:
                 continue
             outbound = to_xray(proxy)
-            if 'msg' not in outbound:
-                outbounds.append(outbound)
+            outbounds.append(outbound)
 
         base_config = json.loads(render_template('base_xray_config.json.j2', remarks=remarks))
         if len(outbounds) > 1:
             for out in outbounds:
-                base_config['remarks'] = out['tag']
-                base_config['outbounds'].insert(0, out)
-                if all_configs:
-                    all_configs.insert(0, copy.deepcopy(base_config))
-                else:
-                    all_configs.append(copy.deepcopy(base_config))
-                del base_config['outbounds'][0]
+                base = copy.deepcopy(base_config)
+                base['remarks'] = out['tag']
+                base['outbounds'].insert(0, out)
+                # if all_configs:
+                #     all_configs.insert(0, copy.deepcopy(base_config))
+                # else:
+                all_configs.append(base)
+
         else:  # single outbound
             base_config['outbounds'].insert(0, outbounds[0])
             all_configs = base_config

hiddifypanel/models/admin.py

@@ -1,5 +1,5 @@
 from enum import auto
-import uuid
+from uuid import uuid4
 from flask import g
 from hiddifypanel.models.usage import DailyUsage
 from sqlalchemy import event, Column, Integer, Enum, Boolean, ForeignKey
@@ -84,6 +84,9 @@ class AdminUser(BaseAccount, SerializerMixin):
             uuid = str(uuid)
         account = AdminUser.query.filter(AdminUser.uuid == uuid).first()
         if not account and create:
+            from hiddifypanel import hutils
+            if not hutils.auth.is_uuid_valid(uuid):
+                uuid = str(uuid4())
             dbuser = AdminUser(uuid=uuid, name="unknown", parent_admin_id=AdminUser.current_admin_or_owner().id)
             db.session.add(dbuser)
             db.session.commit()
@@ -103,11 +106,14 @@ class AdminUser(BaseAccount, SerializerMixin):
             else:
                 parent_admin = cls.by_uuid(parent, create=True)
             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') or False
-        dbuser.max_users = data.get('max_users', 100)
-        dbuser.max_active_users = data.get('max_active_users', 100)
+        if data.get('mode') is not None:
+            dbuser.mode = data.get('mode', AdminMode.agent)
+        if data.get('can_add_admin') is not None:
+            dbuser.can_add_admin = data['can_add_admin']
+        if data.get('max_users') is not None:
+            dbuser.max_users = data['max_users']
+        if data.get('max_active_users') is not None:
+            dbuser.max_active_users = data['max_active_users']
         if commit:
             db.session.commit()
         return dbuser
@@ -158,10 +164,10 @@ class AdminUser(BaseAccount, SerializerMixin):
         return str(self.name)
 
     @staticmethod
-    def get_super_admin():
+    def get_super_admin() -> "AdminUser":
         admin = AdminUser.by_id(1)
         if not admin:
-            db.session.add(AdminUser(id=1, uuid=str(uuid.uuid4()), name="Owner", mode=AdminMode.super_admin, comment=""))
+            db.session.add(AdminUser(id=1, uuid=str(uuid4()), name="Owner", mode=AdminMode.super_admin, comment=""))
             db.session.commit()
 
             db_execute("update admin_user set id=1 where name='Owner'", commit=True)

hiddifypanel/models/base_account.py

@@ -61,13 +61,21 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
         return cls.query.filter(cls.username == username, cls.password == password).first()
 
     @classmethod
-    def add_or_update(cls, commit: bool = True, **data):
-        db_account = cls.by_uuid(data['uuid'], create=True)
-        db_account.name = data.get('name', '')
-        db_account.comment = data.get('comment', '')
+    def add_or_update(cls, commit: bool = True, old_uuid=None, **data):
+        db_account: BaseAccount = cls.by_uuid(old_uuid or data.get('uuid'), create=True)
         from hiddifypanel import hutils
-        db_account.telegram_id = hutils.convert.to_int(data.get('telegram_id'))
-        db_account.lang = data.get('lang')
+        if hutils.auth.is_uuid_valid(data.get('uuid')):
+            db_account.uuid = data['uuid']
+
+        if data.get('name') is not None:
+            db_account.name = data.get('name')
+
+        if data.get('comment') is not None:
+            db_account.comment = data.get('comment')
+        if data.get('telegram_id') is not None:
+            db_account.telegram_id = hutils.convert.to_int(data.get('telegram_id'))
+        if data.get('lang') is not None:
+            db_account.lang = data.get('lang')
         if commit:
             db.session.commit()  # type: ignore
         return db_account

hiddifypanel/models/user.py

@@ -1,5 +1,6 @@
 import datetime
 from enum import auto
+from uuid import uuid4
 from hiddifypanel.models.role import Role
 from dateutil import relativedelta
 
@@ -54,7 +55,8 @@ class UserDetail(db.Model, SerializerMixin):
 
     @property
     def devices(self):
-        return [] if not self.connected_devices else self.connected_devices.split(",")
+        return []
+        # return [] if not self.connected_devices else self.connected_devices.split(",")
 
 
 class User(BaseAccount, SerializerMixin):
@@ -122,13 +124,14 @@ class User(BaseAccount, SerializerMixin):
             is_active = False
         elif self.remaining_days < 0:
             is_active = False
-        elif len(self.devices) > max(3, self.max_ips):
-            is_active = False
+        # elif len(self.devices) > max(3, self.max_ips):
+        #     is_active = False
         return is_active
 
     @property
     def devices(self):
         res = {}
+        return res
         for detail in UserDetail.query.filter(UserDetail.user_id == self.id):
             for device in detail.devices:
                 res[device] = 1
@@ -202,6 +205,10 @@ class User(BaseAccount, SerializerMixin):
             uuid = str(uuid)
         account = User.query.filter(User.uuid == uuid).first()
         if not account and create:
+            from hiddifypanel import hutils
+            if not hutils.auth.is_uuid_valid(uuid):
+                uuid = str(uuid4())
+
             dbuser = User(uuid=uuid, name="unknown", added_by=AdminUser.current_admin_or_owner().id)
             db.session.add(dbuser)
             db.session.commit()
@@ -216,11 +223,11 @@ class User(BaseAccount, SerializerMixin):
     @classmethod
     def add_or_update(cls, commit: bool = True, **data):
         from hiddifypanel import hutils
-        dbuser = super().add_or_update(commit=commit, **data)
+        dbuser: User = 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()  # type: ignore
             dbuser.added_by = admin.id
-        else:
+        elif not dbuser.added_by:
             dbuser.added_by = 1
 
         # if data.get('expiry_time', ''): #v4
@@ -230,45 +237,50 @@ class User(BaseAccount, SerializerMixin):
         #     dbuser.start_date = last_reset_time
         #     dbuser.package_days = (expiry_time - last_reset_time).days  # type: ignore
         # el
-        if 'package_days' in data:
+        if data.get('package_days') is not None:
             dbuser.package_days = data['package_days']
-            if data.get('start_date', ''):
+
+            if data.get('start_date'):
                 dbuser.start_date = hutils.convert.json_to_date(data['start_date'])
-            else:
+            elif 'start_date' in data and data['start_date'] is None:
                 dbuser.start_date = None
 
         if (c_GB := data.get('current_usage_GB')) is not None:
             dbuser.current_usage_GB = c_GB
         elif (c := data.get('current_usage')) is not None:
             dbuser.current_usage = c
-        else:
+        elif dbuser.current_usage is None:
             dbuser.current_usage = 0
 
         if (l_GB := data.get('usage_limit_GB')) is not None:
             dbuser.usage_limit_GB = l_GB
         elif (l := data.get('usage_limit')) is not None:
             dbuser.usage_limit = l
-        else:
+        elif dbuser.usage_limit_GB is None:
             dbuser.usage_limit_GB = 1000
 
-        dbuser.enable = data.get('enable', True)
+        if data.get('enable') is not None:
+            dbuser.enable = data['enable']
 
-        if data.get('ed25519_private_key', ''):
+        if data.get('ed25519_private_key', '') and data.get('ed25519_public_key', ''):
             dbuser.ed25519_private_key = data.get('ed25519_private_key', '')
             dbuser.ed25519_public_key = data.get('ed25519_public_key', '')
-
-        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)
-
-        mode = data.get('mode', UserMode.no_reset)
-        if mode == 'disable':
-            mode = UserMode.no_reset
-            dbuser.enable = False
-
-        dbuser.mode = mode
-
-        dbuser.last_online = hutils.convert.json_to_time(data.get('last_online')) or datetime.datetime.min
+        if data.get('wg_pk') is not None:
+            dbuser.wg_pk = data['wg_pk']
+        if data.get('wg_pub') is not None:
+            dbuser.wg_pub = data['wg_pub']
+        if data.get('wg_psk') is not None:
+            dbuser.wg_psk = data['wg_psk']
+
+        if data.get('mode') is not None or dbuser.mode is None:
+            mode = data.get('mode', UserMode.no_reset)
+            if mode == 'disable':
+                mode = UserMode.no_reset
+                dbuser.enable = False
+            dbuser.mode = mode
+
+        if data.get('last_online') is not None:
+            dbuser.last_online = hutils.convert.json_to_time(data.get('last_online')) or datetime.datetime.min
         if commit:
             db.session.commit()
         return dbuser
@@ -305,6 +317,7 @@ class User(BaseAccount, SerializerMixin):
                 'wg_pk': self.wg_pk,
                 'wg_pub': self.wg_pub,
                 'wg_psk': self.wg_psk,
+                'is_active': self.is_active
                 }
 
     # @staticmethod

hiddifypanel/panel/admin/DomainAdmin.py

@@ -114,7 +114,7 @@ class DomainAdmin(AdminLTEModelView):
         if not dip:
             dip = hutils.network.resolve_domain_with_api(model.domain)
         myip = hutils.network.get_ip(4)
-        if myip == dip and model.mode == DomainType.direct:
+        if myip == dip and model.mode in [DomainType.direct, DomainType.sub_link_only]:
             badge_type = ''
         elif dip and model.mode != DomainType.direct and myip != dip:
             badge_type = 'warning'