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

hiddifypanel/panel/commercial/restapi/v2/user/apps_api.py

@@ -346,31 +346,25 @@ class AppAPI(MethodView):
 
         if self.platform == Platform.all:
             platform = [Platform.windows, Platform.linux, Platform.mac]
-
-        if isinstance(platform, list):
-            for p in platform:
-                match p:
-                    case Platform.windows:
-                        ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/HiddifyClashDesktop_{version}_x64_en-US.msi'
-                        dto.install.append(self.__get_app_install_dto(AppInstallType.setup, ins_url))
-                    case Platform.linux:
-                        ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/hiddify-clash-desktop_{version}_amd64.AppImage'
-                        dto.install.append(self.__get_app_install_dto(AppInstallType.appimage, ins_url))
-                    case Platform.mac:
-                        ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/HiddifyClashDesktop_{version}x64.dmg'
-                        dto.install.append(self.__get_app_install_dto(AppInstallType.dmg, ins_url))
-        else:
-            match platform:
+        
+        def get_link(p):
+            match p:
                 case Platform.windows:
-                    ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/HiddifyClashDesktop_{version}_x64_en-US.msi'
+                    ins_url = latest_url.split('releases/')[0] + f'releases/download/v{version}/HiddifyClashDesktop_{version}_x64_en-US.msi'
                     dto.install.append(self.__get_app_install_dto(AppInstallType.setup, ins_url))
                 case Platform.linux:
-                    ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/hiddify-clash-desktop_{version}_amd64.AppImage'
+                    ins_url = latest_url.split('releases/')[0] + f'releases/download/v{version}/hiddify-clash-desktop_{version}_amd64.AppImage'
                     dto.install.append(self.__get_app_install_dto(AppInstallType.appimage, ins_url))
                 case Platform.mac:
-                    ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/HiddifyClashDesktop_{version}x64.dmg'
+                    ins_url = latest_url.split('releases/')[0] + f'releases/download/v{version}/HiddifyClashDesktop_{version}_x64.dmg'
                     dto.install.append(self.__get_app_install_dto(AppInstallType.dmg, ins_url))
 
+        if isinstance(platform, list):
+            for p in platform:
+                get_link(p)
+        else:
+            get_link(platform)
+
         return dto
 
     def __get_hiddify_next_app_dto(self):
@@ -402,17 +396,17 @@ class AppAPI(MethodView):
             ins_url = ''
             match install_type:
                 case AppInstallType.apk:
-                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/hiddify-android-universal.apk'
+                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/Hiddify-Android-universal.apk'
                 case AppInstallType.google_play:
                     ins_url = 'https://play.google.com/store/apps/details?id=app.hiddify.com'
                 case AppInstallType.setup:
-                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/hiddify-windows-x64-setup.zip'
+                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/Hiddify-Windows-Setup-x64.exe'
                 case AppInstallType.portable:
-                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/hiddify-windows-x64-portable.zip'
+                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/Hiddify-Windows-Portable-x64.zip'
                 case AppInstallType.appimage:
-                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/hiddify-linux-x64.zip'
+                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/Hiddify-Linux-x64.AppImage'
                 case AppInstallType.dmg:
-                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/hiddify-macos-universal.zip'
+                    ins_url = f'{self.hiddify_github_repo}/hiddify-next/releases/latest/download/Hiddify-MacOS.dmg'
 
             install_dto = self.__get_app_install_dto(install_type, ins_url)
             install_dtos.append(install_dto)

hiddifypanel/panel/commercial/restapi/v2/user/configs_api.py

@@ -3,13 +3,10 @@ from flask import g, request
 from flask import current_app as app
 from flask.views import MethodView
 from hiddifypanel.auth import login_required
-from hiddifypanel.models.config import hconfig
-from hiddifypanel.models.config_enum import ConfigEnum
-from hiddifypanel.models.role import Role
+from hiddifypanel.models import Proxy, Role, ConfigEnum, hconfig
 from apiflask import Schema
 from apiflask.fields import String
 from hiddifypanel.panel.user.user import get_common_data
-from hiddifypanel.panel.user import link_maker
 from hiddifypanel import hutils
 
 
@@ -26,7 +23,7 @@ class ConfigSchema(Schema):
 class AllConfigsAPI(MethodView):
     decorators = [login_required({Role.user})]
 
-    @app.output(ConfigSchema(many=True))
+    @app.output(ConfigSchema(many=True))  # type: ignore
     def get(self):
         def create_item(name, domain, type, protocol, transport, security, link):
             dto = ConfigSchema()
@@ -62,6 +59,24 @@ class AllConfigsAPI(MethodView):
             )
         )
 
+        # Add Subscription link
+        items.append(
+            create_item(
+                "Subscription link", "ALL", "ALL", "", "", "",
+                # f"{base_url}all.txt?name={c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}&asn={c['asn']}&mode={c['mode']}"
+                f"{base_url}sub/?asn={c['asn']}#{config_name}"
+            )
+        )
+
+        # Add Subscription link base64
+        items.append(
+            create_item(
+                "Subscription link b64", "ALL", "ALL", "", "", "",
+                # f"{base_url}all.txt?name=new_link_{c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}-{c['mode']}&asn={c['asn']}&mode={c['mode']}&base64=True"
+                f"{base_url}sub64/?asn={c['asn']}#{config_name}"
+            )
+        )
+
         # Add Clash Meta
         items.append(
             create_item(
@@ -84,31 +99,13 @@ class AllConfigsAPI(MethodView):
         if hconfig(ConfigEnum.ssh_server_enable):
             items.append(
                 create_item(
-                    "Singbox: SSH", "SSH", "SHH", "", "", "",
+                    "Singbox: SSH", "SSH", "SSH", "", "", "",
                     # f"{base_url}singbox.json?name={c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}&asn={c['asn']}&mode={c['mode']}"
                     f"{base_url}singbox-ssh/?asn={c['asn']}#{config_name}"
                 )
             )
 
-        # Add Subscription link
-        items.append(
-            create_item(
-                "Subscription link", "ALL", "ALL", "", "", "",
-                # f"{base_url}all.txt?name={c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}&asn={c['asn']}&mode={c['mode']}"
-                f"{base_url}sub/?asn={c['asn']}#{config_name}"
-            )
-        )
-
-        # Add Subscription link base64
-        items.append(
-            create_item(
-                "Subscription link b64", "ALL", "ALL", "", "", "",
-                # f"{base_url}all.txt?name=new_link_{c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}-{c['mode']}&asn={c['asn']}&mode={c['mode']}&base64=True"
-                f"{base_url}sub64/?asn={c['asn']}#{config_name}"
-            )
-        )
-
-        for pinfo in link_maker.get_all_validated_proxies(c['domains']):
+        for pinfo in hutils.proxy.get_valid_proxies(c['domains']):
             items.append(
                 create_item(
                     pinfo["name"].replace("_", " "),
@@ -117,7 +114,7 @@ class AllConfigsAPI(MethodView):
                     pinfo['proto'],
                     pinfo['transport'],
                     pinfo['l3'],
-                    f"{link_maker.to_link(pinfo)}"
+                    f"{hutils.proxy.xray.to_link(pinfo)}"
                 )
             )
 

hiddifypanel/panel/commercial/telegrambot/admin.py

@@ -138,8 +138,7 @@ def create_package(call):  # <- passes a CallbackQuery type object to your funct
                 domain = int(splt[4])
                 new_text = _("Please Wait...")
                 bot.edit_message_text(new_text, call.message.chat.id, call.message.message_id, reply_markup=None)
-                DT = (ParentDomain if hconfig(ConfigEnum.is_parent) else Domain)
-                domain = DT.query.filter(DT.id == domain).first()
+                domain = Domain.query.filter(Domain.id == domain).first()
                 from . import Usage
                 admin_id = admin.id
                 admin_name = admin.name

hiddifypanel/panel/common.py

@@ -9,6 +9,7 @@ from hiddifypanel import hutils
 import hiddifypanel.auth as auth
 from hiddifypanel.auth import current_account
 from apiflask import APIFlask, HTTPError, abort
+from hiddifypanel import hutils
 
 
 def init_app(app: APIFlask):
@@ -17,10 +18,13 @@ def init_app(app: APIFlask):
     app.jinja_env.globals['UserMode'] = UserMode
     app.jinja_env.globals['hconfig'] = hconfig
     app.jinja_env.globals['g'] = g
+    app.jinja_env.globals['hutils'] = hutils
+    app.jinja_env.globals['hiddify'] = hiddify
     app.jinja_env.globals['version'] = hiddifypanel.__version__
     app.jinja_env.globals['static_url_for'] = hutils.flask.static_url_for
     app.jinja_env.globals['hurl_for'] = hutils.flask.hurl_for
     app.jinja_env.globals['_gettext'] = lambda x: print("==========", x)
+    app.jinja_env.globals['proxy_stats_url'] = hutils.flask.get_proxy_stats_url
 
     @app.after_request
     def apply_no_robot(response):
@@ -32,6 +36,12 @@ def init_app(app: APIFlask):
 
     @app.errorhandler(Exception)
     def internal_server_error(e):
+        if isinstance(e, Exception):
+            if hutils.flask.is_api_call(request.path):
+                return {
+                    'msg': str(e),
+                }, 500
+
         if hasattr(e, 'code') and e.code == 404:
             return jsonify({
                 'message': 'Not Found',
@@ -66,6 +76,7 @@ def init_app(app: APIFlask):
         # print(request.headers)
         if not request.accept_mimetypes.accept_html:
             return app.error_callback(e)
+        # if it's interval server error
         if e.status_code == 500:
             trace = traceback.format_exc()
 
@@ -79,9 +90,17 @@ def init_app(app: APIFlask):
                 has_update = "dev" not in hiddifypanel.__version__ and f'{last_version}' != hiddifypanel.__version__
 
             return render_template('500.html', error=e, trace=trace, has_update=has_update, last_version=last_version, issue_link=issue_link), 500
+
+        # if it's access denied error
         # if e.status_code in [400,401,403]:
         #     return render_template('access-denied.html',error=e), e.status_code
 
+        # if it's api error
+        if hutils.flask.is_api_call(request.path):
+            return {
+                'msg': e.message,
+            }, e.status_code
+
         return render_template('error.html', error=e), e.status_code
 
     @app.url_defaults
@@ -91,11 +110,11 @@ def init_app(app: APIFlask):
         if 'proxy_path' not in values:
             if force_path := g.get('force_proxy_path'):
                 values['proxy_path'] = force_path
-            elif hutils.flask.is_admin_role(current_account.role):
+            elif hutils.flask.is_admin_role(current_account.role):  # type: ignore
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
             elif hutils.flask.is_user_panel_call():
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_client)
-            elif current_account and hutils.flask.is_admin_role(current_account.role):
+            elif current_account and hutils.flask.is_admin_role(current_account.role):  # type: ignore
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
             else:
                 values['proxy_path'] = g.proxy_path or "A"
@@ -131,12 +150,6 @@ def init_app(app: APIFlask):
         g.child = Child.by_id(g.__child_id) or abort(404, "Child not found")
         g.account = current_account
 
-    @app.before_first_request
-    def first_request():
-        import hiddifypanel.panel.commercial.telegrambot as telegrambot
-        if (not telegrambot.bot) or (not telegrambot.bot.username):  # type: ignore
-            telegrambot.register_bot(set_hook=True)
-
     @app.before_request
     def base_middleware():
         if request.endpoint == 'static' or request.endpoint == "videos":
@@ -172,3 +185,7 @@ def init_app(app: APIFlask):
             return auth_before
 
     app.jinja_env.globals['generate_github_issue_link_for_admin_sidebar'] = hutils.github_issue.generate_github_issue_link_for_admin_sidebar
+    with app.app_context():
+        import hiddifypanel.panel.commercial.telegrambot as telegrambot
+        if (not telegrambot.bot) or (not telegrambot.bot.username):  # type: ignore
+            telegrambot.register_bot(set_hook=True)

hiddifypanel/panel/common_bp/login.py

@@ -42,8 +42,8 @@ class LoginView(FlaskView):
             return redirect(redirect_arg)
         if hutils.flask.is_admin_proxy_path() and g.account.role in {Role.super_admin, Role.admin, Role.agent}:
             return redirect(hurl_for('admin.Dashboard:index'))
-        if g.user_agent['is_browser'] and hutils.flask.is_client_proxy_path():
-            return redirect(hurl_for('client.UserView:index'))
+        # if g.user_agent['is_browser'] and hutils.flask.is_client_proxy_path():
+        #     return redirect(hurl_for('client.UserView:index'))
 
         from hiddifypanel.panel.user import UserView
         return UserView().auto_sub()

hiddifypanel/panel/hiddify.py

@@ -1,23 +1,16 @@
-import glob
 import re
-import json
 import subprocess
 
 from datetime import datetime
 from typing import Tuple
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric import x25519
 from flask import current_app, g
-from wtforms.validators import ValidationError
 from flask_babel import lazy_gettext as _
-from flask_babel import gettext as __
 from datetime import timedelta
 
 from hiddifypanel.cache import cache
 from hiddifypanel.models import *
 from hiddifypanel.database import db
 from hiddifypanel.hutils.utils import *
-from hiddifypanel.Events import domain_changed
 from hiddifypanel import hutils
 from hiddifypanel.panel.run_commander import commander, Command
 import subprocess
@@ -69,70 +62,10 @@ def exec_command(cmd, cwd=None):
         print(e)
 
 
-@cache.cache(ttl=300)
-def get_available_proxies(child_id):
-    proxies = Proxy.query.filter(Proxy.child_id == child_id).all()
-    proxies = [c for c in proxies if 'restls' not in c.transport]
-    # if not hconfig(ConfigEnum.tuic_enable, child_id):
-    #     proxies = [c for c in proxies if c.proto != ProxyProto.tuic]
-    # if not hconfig(ConfigEnum.hysteria_enable, child_id):
-    #     proxies = [c for c in proxies if c.proto != ProxyProto.hysteria2]
-    if not hconfig(ConfigEnum.shadowsocks2022_enable, child_id):
-        proxies = [c for c in proxies if 'shadowsocks' != c.transport]
-
-    if not hconfig(ConfigEnum.ssfaketls_enable, child_id):
-        proxies = [c for c in proxies if 'faketls' != c.transport]
-    if not hconfig(ConfigEnum.v2ray_enable, child_id):
-        proxies = [c for c in proxies if 'v2ray' != c.proto]
-    if not hconfig(ConfigEnum.shadowtls_enable, child_id):
-        proxies = [c for c in proxies if c.transport != 'shadowtls']
-    if not hconfig(ConfigEnum.ssr_enable, child_id):
-        proxies = [c for c in proxies if 'ssr' != c.proto]
-    if not hconfig(ConfigEnum.vmess_enable, child_id):
-        proxies = [c for c in proxies if 'vmess' not in c.proto]
-    if not hconfig(ConfigEnum.httpupgrade_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.httpupgrade not in c.transport]
-    if not hconfig(ConfigEnum.ws_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.WS not in c.transport]
-
-    if not hconfig(ConfigEnum.grpc_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.grpc not in c.transport]
-    if not hconfig(ConfigEnum.kcp_enable, child_id):
-        proxies = [c for c in proxies if 'kcp' not in c.l3]
-
-    if not hconfig(ConfigEnum.http_proxy_enable, child_id):
-        proxies = [c for c in proxies if 'http' != c.l3]
-
-    if not Domain.query.filter(Domain.mode.in_([DomainType.cdn, DomainType.auto_cdn_ip])).first():
-        proxies = [c for c in proxies if c.cdn != "CDN"]
-
-    if not Domain.query.filter(Domain.mode.in_([DomainType.relay])).first():
-        proxies = [c for c in proxies if c.cdn != ProxyCDN.relay]
-
-    if not Domain.query.filter(Domain.mode.in_([DomainType.cdn, DomainType.auto_cdn_ip]), Domain.servernames != "", Domain.servernames != Domain.domain).first():
-        proxies = [c for c in proxies if 'Fake' not in c.cdn]
-    proxies = [c for c in proxies if not ('vless' == c.proto and ProxyTransport.tcp == c.transport and c.cdn == ProxyCDN.direct)]
-    return proxies
-
-
 def quick_apply_users():
-    if hconfig(ConfigEnum.is_parent):
-        return
-    # from hiddifypanel.panel import usage
-    # usage.update_local_usage()
-    # return
-    # for user in User.query.all():
-    #     if user.is_active:
-    #         xray_api.add_client(user.uuid)
-    #     else:
-    #         xray_api.remove_client(user.uuid)
-
-    # exec_command("sudo /opt/hiddify-manager/install.sh apply_users --no-gui")
-
     # run install.sh apply_users
     commander(Command.apply_users)
 
-    # time.sleep(1)
     return {"status": 'success'}
 
 
@@ -164,16 +97,6 @@ def get_html_user_link(model: BaseAccount, domain: Domain):
     return res
 
 
-def validate_domain_exist(form, field):
-    domain = field.data
-    if not domain:
-        return
-    dip = hutils.network.get_domain_ip(domain)
-    if dip is None:
-        raise ValidationError(
-            _("Domain can not be resolved! there is a problem in your domain"))
-
-
 def reinstall_action(complete_install=False, domain_changed=False, do_update=False):
     from hiddifypanel.panel.admin.Actions import Actions
     action = Actions()
@@ -202,11 +125,12 @@ def check_need_reset(old_configs, do=False):
 
 
 def get_child(unique_id):
-    child_id = Child.current.id
+    child_id = Child.current().id
     if unique_id is None or unique_id in ["self", "default", str(hconfig(ConfigEnum.unique_id))]:
         child_id = 0
     else:
         child = Child.query.filter(Child.unique_id == str(unique_id)).first()
+        # TODO: this doesn't work because name and mode fields are nullable
         if not child:
             child = Child(unique_id=str(unique_id))
             db.session.add(child)
@@ -221,7 +145,7 @@ def dump_db_to_dict():
             "users": [u.to_dict() for u in User.query.all()],
             "domains": [u.to_dict() for u in Domain.query.all()],
             "proxies": [u.to_dict() for u in Proxy.query.all()],
-            "parent_domains": [] if not hconfig(ConfigEnum.license) else [u.to_dict() for u in ParentDomain.query.all()],
+            # "parent_domains": [] if not hconfig(ConfigEnum.license) else [u.to_dict() for u in ParentDomain.query.all()],
             'admin_users': [d.to_dict() for d in AdminUser.query.all()],
             "hconfigs": [*[u.to_dict() for u in BoolConfig.query.all()],
                          *[u.to_dict() for u in StrConfig.query.all()]]
@@ -252,7 +176,7 @@ def set_db_from_json(json_data, override_child_unique_id=True, set_users=True, s
     # override root child unique id
     if override_child_unique_id:
         backup_child_unique_id = get_backup_child_unique_id(json_data)
-        replace_backup_child_unique_id(json_data, backup_child_unique_id, Child.current.unique_id)
+        replace_backup_child_unique_id(json_data, backup_child_unique_id, Child.current().unique_id)
 
     # restore childs
     if set_child and 'childs' in json_data:
@@ -296,17 +220,16 @@ def set_db_from_json(json_data, override_child_unique_id=True, set_users=True, s
                 u['added_by_uuid'] = AdminUser.current_admin_or_owner().uuid
 
     if set_admins and 'admin_users' in json_data:
-        AdminUser.bulk_register(json_data['admin_users'], commit=False)
+        AdminUser.bulk_register(json_data['admin_users'], commit=True)
     if set_users and 'users' in json_data:
         User.bulk_register(json_data['users'], commit=False, remove=remove_users)
     if set_domains and 'domains' in json_data:
-        bulk_register_domains(json_data['domains'], commit=False, remove=remove_domains, override_child_unique_id=override_child_unique_id)
-    # if set_domains and 'parent_domains' in json_data:
-    #     ParentDomain.bulk_register(json_data['parent_domains'], commit=False, remove=remove_domains)
+        bulk_register_domains(json_data['domains'], commit=False, remove=remove_domains)
+
     if set_settings and 'hconfigs' in json_data:
-        bulk_register_configs(json_data["hconfigs"], commit=True, override_child_unique_id=override_child_unique_id, override_unique_id=override_unique_id)
+        bulk_register_configs(json_data["hconfigs"], commit=True, override_unique_id=override_unique_id)
         if 'proxies' in json_data:
-            Proxy.bulk_register(json_data['proxies'], commit=False, override_child_unique_id=override_child_unique_id)
+            Proxy.bulk_register(json_data['proxies'], commit=False)
 
     ids_without_parent = get_ids_without_parent({u.id: u.to_dict() for u in AdminUser.query.all()})
     owner = AdminUser.get_super_admin()
@@ -333,93 +256,13 @@ def get_domain_btn_link(domain):
     return res
 
 
-def debug_flash_if_not_in_the_same_asn(domain):
-    from hiddifypanel.hutils.network.auto_ip_selector import IPASN
-    ipv4 = hutils.network.get_ip_str(4)
-    dip = hutils.network.get_domain_ip(domain)
-    try:
-        if IPASN:
-            asn_ipv4 = IPASN.get(ipv4)
-            asn_dip = IPASN.get(dip)
-            # country_ipv4= ipcountry.get(ipv4)
-            # country_dip= ipcountry.get(dip)
-            if asn_ipv4.get('autonomous_system_organization') != asn_dip.get('autonomous_system_organization'):
-                hutils.flask.flash(_("selected domain for REALITY is not in the same ASN. To better use of the protocol, it is better to find a domain in the same ASN.") +
-                                   f"<br> Server ASN={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
-    except BaseException:
-        pass
-
-
-def generate_x25519_keys():
-    priv = x25519.X25519PrivateKey.generate()
-    pub = priv.public_key()
-    priv_bytes = priv.private_bytes(
-        encoding=serialization.Encoding.Raw,
-        format=serialization.PrivateFormat.Raw,
-        encryption_algorithm=serialization.NoEncryption()
-    )
-    pub_bytes = pub.public_bytes(
-        encoding=serialization.Encoding.Raw,
-        format=serialization.PublicFormat.Raw
-    )
-    import base64
-    pub_str = base64.urlsafe_b64encode(pub_bytes).decode()[:-1]
-    priv_str = base64.urlsafe_b64encode(priv_bytes).decode()[:-1]
-
-    return {'private_key': priv_str, 'public_key': pub_str}
-
-
-def get_hostkeys(dojson=False):
-    key_files = glob.glob(current_app.config['HIDDIFY_CONFIG_PATH'] + "/other/ssh/host_key/*_key.pub")
-    host_keys = []
-    for file_name in key_files:
-        with open(file_name, "r") as f:
-            host_key = f.read().strip()
-            host_key = host_key.split()
-            if len(host_key) > 2:
-                host_key = host_key[:2]  # strip the hostname part
-            host_key = " ".join(host_key)
-            host_keys.append(host_key)
-    if dojson:
-        return json.dumps(host_keys)
-    return host_keys
-
-
 def get_ssh_client_version(user):
     return 'SSH-2.0-OpenSSH_7.4p1'
 
 
-def get_ed25519_private_public_pair():
-    from cryptography.hazmat.primitives.asymmetric import ed25519
-    from cryptography.hazmat.primitives import serialization
-    privkey = ed25519.Ed25519PrivateKey.generate()
-    pubkey = privkey.public_key()
-    priv_bytes = privkey.private_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PrivateFormat.OpenSSH,
-        encryption_algorithm=serialization.NoEncryption(),
-    )
-    pub_bytes = pubkey.public_bytes(
-        encoding=serialization.Encoding.OpenSSH,
-        format=serialization.PublicFormat.OpenSSH,
-    )
-    return priv_bytes.decode(), pub_bytes.decode()
-
-
-def get_wg_private_public_psk_pair():
-    try:
-        private_key = subprocess.run(["wg", "genkey"], capture_output=True, text=True, check=True).stdout.strip()
-        public_key = subprocess.run(["wg", "pubkey"], input=private_key, capture_output=True, text=True, check=True).stdout.strip()
-        psk = subprocess.run(["wg", "genpsk"], capture_output=True, text=True, check=True).stdout.strip()
-        return private_key, public_key, psk
-    except subprocess.CalledProcessError as e:
-        print(f"Error: {e}")
-        return None, None, None
-
-
 def get_account_panel_link(account: BaseAccount, host: str, is_https: bool = True, prefere_path_only: bool = False, child_id=None):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
     is_admin = isinstance(account, AdminUser)
     basic_auth = False  # is_admin #because safri does not support it.
 
@@ -441,9 +284,18 @@ def get_account_panel_link(account: BaseAccount, host: str, is_https: bool = Tru
     return link
 
 
-def is_telegram_proxy_enable() -> bool:
-    ok_domains = True if Domain.query.filter(Domain.mode.in_([DomainType.direct, DomainType.relay, DomainType.old_xtls_direct])).first() else False
-    return hconfig(ConfigEnum.telegram_enable) and ok_domains
+def is_telegram_proxy_enable(domains=None) -> bool:
+    if not hconfig(ConfigEnum.telegram_enable):
+        return False
+
+    valid_domain_types = [DomainType.direct, DomainType.relay, DomainType.old_xtls_direct]
+    res = False
+    if domains:
+        res = any(d.mode in valid_domain_types for d in domains)
+    else:
+        res = True if Domain.query.filter(Domain.mode.in_(valid_domain_types)).first() else False
+
+    return res
 
 
 def clone_model(model):
@@ -455,11 +307,8 @@ def clone_model(model):
     for k in table.columns.keys():
         if k == "id":
             continue
-        # if k in table.primary_key:
-        #     continue
         setattr(new_model, f'{k}', getattr(model, k))
 
-    # data.pop('id')
     return new_model
 
 
@@ -484,18 +333,6 @@ def get_backup_child_unique_id(backupdata: dict) -> str:
         return "self"
     return backupdata['childs'][0]['unique_id']
 
-    # for k, v in backupdata.items():
-    #     if k == 'admin_users' or k == 'users':
-    #         continue
-    #     if k == 'childs':
-    #         if len(v) < 1:
-    #             continue
-    #         return v[0]['unique_id']
-    #     else:
-    #         for item in v:
-    #             return item['child_unique_id']
-    # return 'self'
-
 
 def is_hiddify_next_version(major_v: int = 0, minor_v: int = 0, patch_v: int = 0) -> bool:
     '''If the user agent version be equals or higher than parameters returns True'''