hiddifypanel 9.0.0.dev32__py3-none-any.whl → 9.0.0.dev33__py3-none-any.whl

hiddifypanel/panel/cli.py

@@ -55,34 +55,23 @@ def all_configs():
         # "parent_domains": [hiddify.parent_domain_dict(u) for u in ParentDomain.query.all()],
         "hconfigs": get_hconfigs()
     }
-    # for d in configs['domains']:
-
-    #     # del d['domain']['show_domains']
 
     def_user = None if len(User.query.all()) > 1 else User.query.filter(User.name == 'default').first()
     domains = Domain.query.all()
     sslip_domains = [d.domain for d in domains if "sslip.io" in d.domain]
 
     configs['hconfigs']['first_setup'] = def_user != None and len(sslip_domains) > 0
-
-    # path = f'/{hconfig(ConfigEnum.proxy_path_admin)}/l'
-    path = f'/{hconfig(ConfigEnum.proxy_path_admin)}/{AdminUser.get_super_admin_uuid()}/'
-
     server_ip = hutils.ip.get_ip(4)
-    configs['admin_path'] = path
     owner = AdminUser.get_super_admin()
+
+    configs['admin_path'] = hiddify.get_account_panel_link(owner, server_ip, is_https=False, prefere_path_only=True)
     configs['panel_links'] = []
-    # configs['panel_links'].append(hutils.utils.add_basic_auth_to_url(f'http://{server_ip}{path}', owner.username, owner.password))
-    configs['panel_links'].append(f'http://{server_ip}{path}')
-    # configs['panel_links'].append(hutils.utils.add_basic_auth_to_url(f'https://{server_ip}{path}', owner.username, owner.password))
-    configs['panel_links'].append(f'https://{server_ip}{path}')
+    configs['panel_links'].append(hiddify.get_account_panel_link(owner, server_ip, is_https=False))
+    configs['panel_links'].append(hiddify.get_account_panel_link(owner, server_ip))
     domains = get_panel_domains()
-    # if not any([d for d in domains if 'sslip.io' not in d.domain]):
-    #     configs['panel_links'].append(f"https://{server_ip}{path}")
 
     for d in domains:
-        # configs['panel_links'].append(hutils.utils.add_basic_auth_to_url(f'https://{d.domain}{path}', owner.username, owner.password))
-        configs['panel_links'].append(f'https://{d.domain}{path}')
+        configs['panel_links'].append(hiddify.get_account_panel_link(owner, d.domain))
 
     print(json.dumps(configs, indent=4))
 
@@ -100,34 +89,23 @@ def admin_links():
     server_ip = hutils.ip.get_ip(4)
     owner = AdminUser.get_super_admin()
 
-    proxy_path = hconfig(ConfigEnum.proxy_path_admin)
-    # admin_links = f"Not Secure (do not use it - only if others not work):\n   {hutils.utils.add_basic_auth_to_url(f'http://{server_ip}/{proxy_path}/', owner.username, owner.password)}\n"
-    admin_links = f"Not Secure (do not use it - only if others not work):\n   http://{server_ip}/{proxy_path}/{owner.uuid}/'\n"
+    admin_links = f"Not Secure (do not use it - only if others not work):\n   {hiddify.get_account_panel_link(owner, server_ip,is_https=True)}'\n"
 
     domains = get_panel_domains()
     admin_links += f"Secure:\n"
     if not any([d for d in domains if 'sslip.io' not in d.domain]):
-        # admin_links += f"   (not signed) {hutils.utils.add_basic_auth_to_url(f'https://{server_ip}/{proxy_path}/l', owner.username, owner.password)}\n"
-        admin_links += f"   (not signed) https://{server_ip}/{proxy_path}/{owner.uuid}\n"
+        admin_links += f"   (not signed) {hiddify.get_account_panel_link(owner, server_ip)}\n"
 
-    # domains=[*domains,f'{server_ip}.sslip.io']
     for d in domains:
-        # admin_links += f"   {hutils.utils.add_basic_auth_to_url(f'https://{d.domain}/{proxy_path}/l', owner.username, owner.password)}\n"
-        admin_links += f"   https://{d.domain}/{proxy_path}/{owner.uuid}/\n"
+        admin_links += f"   {hiddify.get_account_panel_link(owner, d.domain)}\n"
 
     print(admin_links)
     return admin_links
 
 
 def admin_path():
-    proxy_path = hconfig(ConfigEnum.proxy_path_admin)
-    admin = AdminUser.query.filter(AdminUser.mode == AdminMode.super_admin).first()
-    if not admin:
-        db.session.add(AdminUser(mode=AdminMode.super_admin))
-        db.session.commit()
-        admin = AdminUser.query.filter(AdminUser.mode == AdminMode.super_admin).first()
-
-    print(f"/{proxy_path}/admin/")
+    admin = AdminUser.get_super_admin()
+    print(hiddify.get_account_panel_link(owner, server_ip, prefere_path_only=True))
 
 
 def hysteria_domain_port():

hiddifypanel/panel/commercial/ParentDomainAdmin.py

@@ -64,7 +64,7 @@ class ParentDomainAdmin(AdminLTEModelView):
     form_columns = ['domain', "alias", 'show_domains']
 
     def _domain_admin_link(view, context, model, name):
-        admin_link = f'https://{model.domain}{hiddify.get_admin_path()}'
+        admin_link = hiddify.get_account_panel_link(g.account,model.domain)
         return Markup(f'<div class="btn-group"><a href="{admin_link}" class="btn btn-xs btn-secondary">' + _("admin link") +
                       f'</a><a href="{admin_link}" class="btn btn-xs btn-info ltr" target="_blank">{model.domain}</a></div>')
 

hiddifypanel/panel/commercial/restapi/v2/admin/server_status_api.py

@@ -3,10 +3,10 @@ from flask import g
 from flask.views import MethodView
 from apiflask.fields import Dict
 from apiflask import Schema
+from hiddifypanel.models.usage import DailyUsage
 from hiddifypanel.panel.auth import login_required
-from hiddifypanel.models.role import Role
+from hiddifypanel.models import Role, DailyUsage
 from hiddifypanel.panel import hiddify
-from hiddifypanel.models import get_daily_usage_stats
 
 
 class ServerStatus(Schema):
@@ -17,13 +17,13 @@ class ServerStatus(Schema):
 class AdminServerStatusApi(MethodView):
     decorators = [login_required({Role.super_admin, Role.admin, Role.agent})]
 
-    @app.output(ServerStatus)
+    @app.output(ServerStatus)  # type: ignore
     def get(self):
         dto = ServerStatus()
-        dto.stats = {
+        dto.stats = {  # type: ignore
             'system': hiddify.system_stats(),
             'top5': hiddify.top_processes()
         }
         admin_id = request.args.get("admin_id") or g.account.id
-        dto.usage_history = get_daily_usage_stats(admin_id)
+        dto.usage_history = DailyUsage.get_daily_usage_stats(admin_id)  # type: ignore
         return dto

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

@@ -47,8 +47,7 @@ class InfoAPI(MethodView):
         dto = ProfileSchema()
         # user is exist for sure
         dto.profile_title = c['user'].name
-        # dto.profile_url = f"https://{g.account.username}:{g.account.password}@{urlparse(request.base_url).hostname}/{g.proxy_path}/#{g.account.name}"
-        dto.profile_url = f"https://{urlparse(request.base_url).hostname}/{g.proxy_path}/{g.account.uuid}/"
+        dto.profile_url = c['profile_url']
         dto.profile_usage_current = g.account.current_usage_GB
         dto.profile_usage_total = g.account.usage_limit_GB
         dto.profile_remaining_days = g.account.remaining_days()
@@ -59,7 +58,7 @@ class InfoAPI(MethodView):
         dto.admin_message_url = hconfig(ConfigEnum.branding_site)
         dto.brand_title = hconfig(ConfigEnum.branding_title)
         dto.brand_icon_url = ""
-        dto.doh = f"https://{urlparse(request.base_url).hostname}/{g.proxy_path}/dns/dns-query"
+        dto.doh = f"https://{request.host}/{g.proxy_path}/dns/dns-query"
         dto.lang = c['user'].lang
         return dto
 

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

@@ -23,9 +23,8 @@ class ShortAPI(MethodView):
 
     @app.output(ShortSchema)
     def get(self):
-        short, expire_in = hiddify.add_short_link(
-            f'https://{request.host}/{hconfig(ConfigEnum.proxy_path_admin)}/')
-        full_url = f"https://{urlparse(request.base_url).hostname}/{short}"
+        short, expire_in = hiddify.add_short_link(hiddify.get_account_panel_link(g.account, request.host))
+        full_url = f"https://{request.host}/{short}"
         dto = ShortSchema()
         dto.full_url = full_url
         dto.short = short

hiddifypanel/panel/commercial/telegrambot/Usage.py

@@ -52,7 +52,7 @@ def get_usage_msg(uuid, domain=None):
         reset_day = user_data['reset_day']
 
         domain = domain or get_panel_domains()[0]
-        user_link = f"https://{domain.domain}/{hconfig(ConfigEnum.proxy_path_client)}/"
+        user_link = hiddify.get_account_panel_link(user,domain.domain)
         msg = f"""{_('<a href="%(user_link)s"> %(user)s</a>',user_link=user_link ,user=user.name if user.name != "default" else "")}\n\n"""
 
         msg += f"""{_('user.home.usage.title')} {round(user.current_usage_GB, 3)}GB <b>{_('user.home.usage.from')}</b> {user.usage_limit_GB}GB  {_('user.home.usage.monthly') if user.monthly else ''}\n"""

hiddifypanel/panel/commercial/templates/parent_dash.html

@@ -8,7 +8,7 @@
 {% macro admin_btn(child,domain) -%}
 <div class="btn-group">
 
-    <a href="https://{{domain}}/{{hconfig(ConfigEnum.proxy_path_admin,child.id)}}/admin/" class="btn btn-xs btn-{{" success" if child.is_active else "warning" }} orig-link ltr" target="_blank">{{domain}}</a>
+    <a href="{hiddify.get_account_panel_link(g.account,domain,child_id=child.id)}" class="btn btn-xs btn-{{" success" if child.is_active else "warning" }} orig-link ltr" target="_blank">{{domain}}</a>
 </div>
 {%- endmacro -%}
 

hiddifypanel/panel/common.py

@@ -104,10 +104,10 @@ def init_app(app: APIFlask):
             if hasattr(g, 'account') and isinstance(g.account, AdminUser):
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
             # elif 'static' in endpoint:
-            #     values['proxy_path'] = hconfig(ConfigEnum.proxy_path)
+                #     values['proxy_path'] = hconfig(ConfigEnum.proxy_path)
             elif hiddify.is_user_panel_call():
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_client)
-            else:
+            elif g.is_admin:
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
 
         if hiddify.is_api_v1_call(endpoint=endpoint) and 'admin_uuid' not in values:
@@ -184,7 +184,7 @@ def init_app(app: APIFlask):
 
         # validate proxy path
 
-        g.proxy_path = hutils.utils.get_proxy_path_from_url(request.url)
+        # g.proxy_path = hutils.utils.get_proxy_path_from_url(request.url)
         hiddify.proxy_path_validator(g.proxy_path)
 
         # if g.proxy_path != hconfig(ConfigEnum.proxy_path):

hiddifypanel/panel/hiddify.py

@@ -27,15 +27,15 @@ from hiddifypanel.panel.run_commander import commander, Command
 to_gig_d = 1000*1000*1000
 
 
-def add_temporary_access():
-    random_port = random.randint(30000, 50000)
-    # exec_command(
-    #     f'sudo /opt/hiddify-manager/hiddify-panel/temporary_access.sh {random_port} &')
+# def add_temporary_access():
+#     random_port = random.randint(30000, 50000)
+#     # exec_command(
+#     #     f'sudo /opt/hiddify-manager/hiddify-panel/temporary_access.sh {random_port} &')
 
-    # run temporary_access.sh
-    commander(Command.temporary_access, port=random_port)
-    temp_admin_link = f"http://{hutils.ip.get_ip(4)}:{random_port}{get_admin_path()}"
-    g.temp_admin_link = temp_admin_link
+#     # run temporary_access.sh
+#     commander(Command.temporary_access, port=random_port)
+#     temp_admin_link = f"http://{hutils.ip.get_ip(4)}:{random_port}{get_admin_path()}"
+#     g.temp_admin_link = temp_admin_link
 
 
 # with user panel url format we don't really need this function
@@ -65,12 +65,6 @@ def add_short_link_imp(link: str, period_min: int = 5) -> Tuple[str, datetime]:
     return short_code, datetime.now() + timedelta(minutes=period_min)
 
 
-def get_admin_path():
-    proxy_path = hconfig(ConfigEnum.proxy_path_admin)
-    # admin_secret = g.account.uuid or get_super_admin_secret()
-    return (f"/{proxy_path}/admin/")
-
-
 def exec_command(cmd, cwd=None):
     try:
         subprocess.Popen(cmd.split(" "))  # run in background
@@ -206,13 +200,7 @@ def is_admin_home_call() -> bool:
 
 
 def is_login_call() -> bool:
-    # print(request.blueprint)
     return request.blueprint == 'common_bp'
-    # base_path = f'{request.host}'
-    # requested_url = f'{request.host}{request.path}'
-    # if requested_url == f'{base_path}/{hconfig(ConfigEnum.proxy_path_admin)}/' or requested_url == f'{base_path}/{hconfig(ConfigEnum.proxy_path_client)}/':
-    #     return True
-    # return False
 
 
 def is_admin_role(role: Role):
@@ -372,21 +360,15 @@ def check_connection_for_domain(domain):
     return True
 
 
-def get_user_link(uuid, domain, mode='', username=''):
+def get_html_user_link(model: BaseAccount, domain: Domain):
     is_cdn = domain.mode == DomainType.cdn if type(domain) == Domain else False
     res = ""
-    if mode == "multi":
-        res += "<div class='btn-group'>"
     d = domain.domain
     if "*" in d:
         d = d.replace("*", get_random_string(5, 15))
-    proxy_path = hconfig(ConfigEnum.proxy_path_admin) if mode == 'admin' else hconfig(ConfigEnum.proxy_path_client)
-    # account = AdminUser.query.filter(AdminUser.uuid == uuid).first() if mode == 'admin' else User.query.filter(User.uuid == uuid).first()
-    # link = f"https://{account.username}:{account.password}@{d}/{proxy_path}/admin/#{username}" if mode == 'admin' else f"https://{account.username}:{account.password}@{d}/{proxy_path}/#{username}"
-    link = f"https://{d}/{proxy_path}/{uuid}/#{username}"
 
-    # if mode == 'new':
-    #     link = f"{link}new"
+    link = get_account_panel_link(model, d)+f"#{model.name}"
+
     text = domain.alias or domain.domain
     color_cls = 'info'
 
@@ -395,7 +377,7 @@ def get_user_link(uuid, domain, mode='', username=''):
         color_cls = "success" if auto_cdn else 'warning'
         text = f'<span class="badge badge-secondary" >{"Auto" if auto_cdn else "CDN"}</span> '+text
 
-    res += f"<a target='_blank' data-copy='{link}' href='{link}' class='btn btn-xs btn-{color_cls} ltr copy-link' ><i class='fa-solid fa-arrow-up-right-from-square d-none'></i> {text}</a>"
+    res += f"<a target='_blank' data-copy='{link}' href='{link}' class='btn btn-xs btn-{color_cls} ltr share-link' ><i class='fa-solid fa-arrow-up-right-from-square d-none'></i> {text}</a>"
 
     return res
 
@@ -538,11 +520,11 @@ def set_db_from_json(json_data, override_child_id=None, set_users=True, set_doma
     if set_domains and 'domains' in json_data:
         bulk_register_domains(json_data['domains'], commit=False, remove=remove_domains, override_child_id=override_child_id)
     if set_domains and 'parent_domains' in json_data:
-        bulk_register_parent_domains(json_data['parent_domains'], commit=False, remove=remove_domains)
+        ParentDomain.bulk_register(json_data['parent_domains'], commit=False, remove=remove_domains)
     if set_settings and 'hconfigs' in json_data:
         bulk_register_configs(json_data["hconfigs"], commit=True, override_child_id=override_child_id, override_unique_id=override_unique_id)
         if 'proxies' in json_data:
-            bulk_register_proxies(json_data['proxies'], commit=False, override_child_id=override_child_id)
+            Proxy.bulk_register(json_data['proxies'], commit=False, override_child_id=override_child_id)
 
     ids_without_parent = get_ids_without_parent({u.id: u.to_dict() for u in AdminUser.query.all()})
     owner = AdminUser.get_super_admin()
@@ -846,12 +828,12 @@ def do_base_64(str):
 
 
 def get_user_agent():
-    ua= __parse_user_agent(request.user_agent.string)
+    ua = __parse_user_agent(request.user_agent.string)
 
     if 'is_bot' not in ua:
         __parse_user_agent.invalidate_all()
-        ua= __parse_user_agent(request.user_agent.string)
-        
+        ua = __parse_user_agent(request.user_agent.string)
+
     return ua
 
 
@@ -915,3 +897,19 @@ def get_direct_host_or_ip(prefer_version: int):
     if not direct:
         direct = hutils.ip.get_ip(socket.AF_INET if prefer_version == socket.AF_INET6 else socket.AF_INET6)
     return direct
+
+
+def get_account_panel_link(account: BaseAccount, host: str, is_https: bool = True, prefere_path_only: bool = False, child_id=0):
+    basic_auth = False
+
+    link = ""
+    if basic_auth or not prefere_path_only:
+        link = "https://" if is_https else "http://"
+        if basic_auth:
+            link += f'{account.uuid}@'
+        link += host
+    proxy_path = hconfig(ConfigEnum.proxy_path_admin, child_id) if isinstance(account, AdminUser) else hconfig(ConfigEnum.proxy_path_client, child_id)
+    link += f'/{proxy_path}/'
+    if not basic_auth:
+        link += f'{account.uuid}/'
+    return link

hiddifypanel/panel/user/templates/new.html

@@ -2,8 +2,7 @@
 <html>
   <head>
     <meta charset="UTF-8" />
-    {%set base='https://'+domain+'/'+hconfigs[ConfigEnum.proxy_path_client]+"/"+user.uuid+"/"%}
-    <meta name="apple-itunes-app" content="app-id=6450534064, app-argument=streisand://import/{{base}}">
+    <meta name="apple-itunes-app" content="app-id=6450534064, app-argument=streisand://import/{{profile_url}}">
     
     <link rel="icon" type="image/png" href="../static/new/assets/hiddify-logo-7617d937.png" />
     <link rel="stylesheet" href="node_modules/smartbanner.js/dist/smartbanner.min.css">
@@ -20,7 +19,7 @@
     <script src="node_modules/smartbanner.js/dist/smartbanner.min.js"></script>
     <script>
       window.appVersion = '{{version}}';
-      window.deepLink = "hiddify://import/{{base}}"
+      window.deepLink = "hiddify://import/{{profile_url}}"
     </script>
   </body>
 </html>

hiddifypanel/panel/user/user.py

@@ -27,187 +27,11 @@ class UserView(FlaskView):
 
         return f"<div style='direction:ltr'>https://{urlparse(request.base_url).hostname}/{short}/</a><br><br>"+_("This link will expire in 5 minutes")
 
-    @route('/info/')
-    @route('/info')
-    # TODO: delete this function and use /me/ api instead
-    def info(self):
-        c = get_common_data(g.account.uuid, 'new')
-        data = {
-            'profile_title': c['profile_title'],
-            'profile_url': f"https://{g.account.username}:{g.account.password}{urlparse(request.base_url).hostname}/{g.proxy_path}/#{g.account.name}",
-            'profile_usage_current': g.account.current_usage_GB,
-            'profile_usage_total': g.account.usage_limit_GB,
-            'profile_remaining_days': g.account.remaining_days(),
-            'profile_reset_days': g.account.days_to_reset(),
-            'telegram_bot_url': f"https://t.me/{c['bot'].username}?start={g.account.uuid}" if c['bot'] else "",
-            'admin_message_html': hconfig(ConfigEnum.branding_freetext),
-            'admin_message_url': hconfig(ConfigEnum.branding_site),
-            'brand_title': hconfig(ConfigEnum.branding_title),
-            'brand_icon_url': "",
-            'doh': f"https://{urlparse(request.base_url).hostname}/{g.proxy_path}/dns/dns-query",
-            'def_lang': hconfig(ConfigEnum.lang)
-        }
-
-        return jsonify(data)
-
-    @route('/mtproxies/')
-    @route('/mtproxies')
-    def mtproxies(self):
-        # get domains
-        c = get_common_data(g.account.uuid, 'new')
-        mtproxies = []
-        # TODO: Remove duplicated domains mapped to a same ipv4 and v6
-        for d in c['domains']:
-            if d.mode not in [DomainType.direct, DomainType.relay]:
-                continue
-            hexuuid = hconfig(ConfigEnum.shared_secret, d.child_id).replace('-', '')
-            telegram_faketls_domain_hex = hconfig(ConfigEnum.telegram_fakedomain, d.child_id).encode('utf-8').hex()
-            server_link = f'tg://proxy?server={d.domain}&port=443&secret=ee{hexuuid}{telegram_faketls_domain_hex}'
-            mtproxies.append({'title': d.alias or d.domain, 'link': server_link})
-
-        return jsonify(mtproxies)
-
-    @route('/all-configs/')
-    @route('/all-configs')
-    def configs(self):
-        def create_item(name, type, domain, protocol, transport, security, link):
-            return {
-                'name': name,
-                'domain': domain,
-                'link': link,
-                # 'tags': set(type, protocol, transport, security),
-                'type': type,
-                'protocol': protocol,
-                'transport': transport,
-                'security': security,
-            }
-
-        items = []
-        base_url = f"https://{g.account.username}:{g.account.password}{urlparse(request.base_url).hostname}/{g.proxy_path}/"
-        c = get_common_data(g.account.uuid, 'new')
-
-        # Add Auto
-        items.append(
-            create_item(
-                "Auto", "All", "All", "All", "All", "All",
-                f"{base_url}sub/?asn={c['asn']}")
-        )
-
-        # Add Full Singbox
-        items.append(
-            create_item(
-                "Full Singbox", "All", "All", "All", "All", "All",
-                f"{base_url}full-singbox.json?asn={c['asn']}"
-            )
-        )
-
-        # Add Clash Meta
-        items.append(
-            create_item(
-                "Clash Meta", "All", "All", "All", "All", "All",
-                f"clashmeta://install-config?url={base_url}clash/meta/all.yml&name=mnormal_{c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}-{c['mode']}&asn={c['asn']}&mode={c['mode']}"
-            )
-        )
-
-        # Add Clash
-        items.append(
-            create_item(
-                "Clash", "All", "All", "Except VLess", "All", "All",
-                f"clash://install-config?url={base_url}clash/all.yml&name=new_normal_{c['db_domain'].alias or c['db_domain'].domain}-{c['asn']}-{c['mode']}&asn={c['asn']}&mode={c['mode']}"
-            )
-        )
-
-        # Add Singbox: SSh
-        if hconfig(ConfigEnum.ssh_server_enable):
-            items.append(
-                create_item(
-                    "Singbox: SSH", "SSH", "SSH", "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']}"
-                )
-            )
-
-        # Add Subscription link
-        items.append(
-            create_item(
-                "Subscription link", "All", "All", "All", "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']}"
-            )
-        )
-
-        # Add Subscription link base64
-        items.append(
-            create_item(
-                "Subscription link b64", "All", "All", "All", "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"
-            )
-        )
-
-        for pinfo in link_maker.get_all_validated_proxies(c['domains']):
-            items.append(
-                create_item(
-                    pinfo["name"].replace("_", " "),
-                    f"{'Auto ' if pinfo['dbdomain'].has_auto_ip else ''}{pinfo['mode']}",
-                    pinfo['server'],
-                    pinfo['proto'],
-                    pinfo['transport'],
-                    pinfo['l3'],
-                    f"{link_maker.to_link(pinfo)}"
-                )
-            )
-
-        return jsonify(items)
-
-    # endregion
-
-    @route('/test/')
+    @route('/useragent/')
     @login_required(roles={Role.user})
     def test(self):
         ua = request.user_agent.string
-        if re.match('^Mozilla', ua, re.IGNORECASE):
-            return "Please do not open here"
-        conf = self.get_proper_config()
-
-        import json
-        ua = request.user_agent.string
-        uaa = user_agents.parse(request.user_agent.string)
-        with open('ua.txt', 'a') as f:
-            f.write("\n".join([
-                f'\n{datetime.datetime.now()} '+("Ok" if conf else "ERROR"),
-                ua,
-                f'os={uaa.os.family}-{uaa.os.version}({uaa.os.version_string}) br={uaa.browser.family} v={uaa.browser.version} vs={uaa.browser.version_string}   dev={uaa.device.family}-{uaa.device.brand}-{uaa.device.model}',
-                '\n'
-            ]))
-        if conf:
-            return conf
-        abort(500)
-    # @route('/old')
-    # @route('/old/')
-    # def index(self):
-
-    #     c=get_common_data(g.account_uuid,mode="")
-    #     user_agent =  user_agents.parse(request.user_agent.string)
-
-    #     return render_template('home/index.html',**c,ua=user_agent)
-    # @route('/multi/')
-    # @route('/multi')
-    # def multi(self):
-
-    #     c=get_common_data(g.account_uuid,mode="multi")
-
-    #     user_agent =  user_agents.parse(request.user_agent.string)
-
-    #     return render_template('home/multi.html',**c,ua=user_agent)
-
-    # @route('/')
-    # # @login_required()
-    # # login
-    # def login(self):
-    #     return ""
-    #     # redirect based on authenticated account
-    #     if hiddify.is_admin_proxy_path() and g.account.role in {Role.super_admin, Role.admin, Role.agent}:
-    #         return redirect(url_for('admin.Dashboard:index'))
-    #     elif hiddify.is_client_proxy_path():
-    #         return self.auto_sub()
+        return ua
 
     def index(self):
         return self.auto_sub()
@@ -241,14 +65,6 @@ class UserView(FlaskView):
         if re.match('^(Hiddify|FoXray|Fair|v2rayNG|SagerNet|Shadowrocket|V2Box|Loon|Liberty)', ua, re.IGNORECASE):
             return self.all_configs(base64=True)
 
-    @ route('/auto')
-    @login_required(roles={Role.user})
-    def auto_select(self):
-        c = get_common_data(g.account.uuid, mode="new")
-        user_agent = user_agents.parse(request.user_agent.string)
-        # return render_template('home/handle_smart.html', **c)
-        return render_template('home/auto_page.html', **c, ua=user_agent)
-
     @ route('/new/')
     @ route('/new')
     @login_required(roles={Role.user})
@@ -371,11 +187,6 @@ class UserView(FlaskView):
             # render_template('all_configs.txt', **c, base64=do_base_64)
             resp = link_maker.make_v2ray_configs(**c)
 
-        # res = ""
-        # for line in resp.split("\n"):
-        #     if "vmess://" in line:
-        #         line = "vmess://"+do_base_64(line.replace("vmess://", ""))
-        #     res += line+"\n"
         if base64:
             resp = do_base_64(resp)
         return add_headers(resp, c)
@@ -383,7 +194,7 @@ class UserView(FlaskView):
     @login_required(roles={Role.user})
     @ route("/offline.html")
     def offline():
-        return f"Not Connected <a href='/{hconfig(ConfigEnum.proxy_path_client)}/'>click for reload</a>"
+        return f"Not Connected <a href='{hiddify.get_account_panel_link(g.account, request.host)}'>click for reload</a>"
 
     # backward compatiblity
     @route("/admin/<path:path>")
@@ -509,7 +320,8 @@ def get_common_data(user_uuid, mode, no_domain=False, filter_domain=None):
         "ip_debug": auto_ip_selector.get_real_user_ip_debug(user_ip),
         "asn": asn,
         "country": auto_ip_selector.get_country(user_ip),
-        'has_auto_cdn': has_auto_cdn
+        'has_auto_cdn': has_auto_cdn,
+        'profile_url': hiddify.get_account_panel_link(g.account, domain)
     }
 
 

hiddifypanel/static/css/custom.css

@@ -528,4 +528,9 @@ pre {
 .dark-mode .modal {
   color: white;
 
+}
+
+div#qrcode img {
+  padding: 10px;
+  background-color: white;
 }