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

hiddifypanel/VERSION

@@ -1 +1 @@
-9.0.0.dev32
+9.0.0.dev33

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='9.0.0.dev32'
+__version__='9.0.0.dev33'
 from datetime import datetime
 __release_date__= datetime.strptime('2024-01-09','%Y-%m-%d')

hiddifypanel/models/__init__.py

@@ -2,10 +2,11 @@ from .role import Role, AccountType
 from .config_enum import ConfigCategory, ConfigEnum, Lang
 from .config import StrConfig, BoolConfig, get_hconfigs, hconfig, set_hconfig, add_or_update_config, bulk_register_configs
 
-from .parent_domain import ParentDomain, add_or_update_parent_domains, bulk_register_parent_domains
+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 .proxy import Proxy, ProxyL3, ProxyCDN, ProxyProto, ProxyTransport, add_or_update_proxy, bulk_register_proxies
+from .proxy import Proxy, ProxyL3, ProxyCDN, ProxyProto, ProxyTransport
 from .user import User, UserMode, remove_user, UserDetail, ONE_GIG
 from .admin import AdminUser, AdminMode
 from .child import Child
-from .usage import DailyUsage, get_daily_usage_stats
+from .usage import DailyUsage
+from .base_account import BaseAccount

hiddifypanel/models/config.py

@@ -36,7 +36,7 @@ class StrConfig(db.Model, SerializerMixin):
 
 
 @cache.cache(ttl=500)
-def hconfig(key: ConfigEnum, child_id=0):
+def hconfig(key: ConfigEnum, child_id: int = 0):
     value = None
     try:
         str_conf = StrConfig.query.filter(StrConfig.key == key, StrConfig.child_id == child_id).first()
@@ -61,7 +61,7 @@ def hconfig(key: ConfigEnum, child_id=0):
     return value
 
 
-def set_hconfig(key: ConfigEnum, value, child_id=0, commit=True):
+def set_hconfig(key: ConfigEnum, value: str | bool, child_id: int = 0, commit: bool = True):
     # hconfig.invalidate(key, child_id)
     # get_hconfigs.invalidate(child_id)
     hconfig.invalidate(key, child_id)
@@ -94,7 +94,7 @@ def set_hconfig(key: ConfigEnum, value, child_id=0, commit=True):
 
 
 @cache.cache(ttl=500)
-def get_hconfigs(child_id=0):
+def get_hconfigs(child_id: int = 0):
     return {**{u.key: u.value for u in BoolConfig.query.filter(BoolConfig.child_id == child_id).all()},
             **{u.key: u.value for u in StrConfig.query.filter(StrConfig.child_id == child_id).all()},
             # ConfigEnum.telegram_fakedomain:hdomain(DomainType.telegram_faketls),
@@ -103,7 +103,7 @@ def get_hconfigs(child_id=0):
             }
 
 
-def add_or_update_config(commit=True, child_id=0, override_unique_id=True, **config):
+def add_or_update_config(commit: bool = True, child_id: int = 0, override_unique_id: bool = True, **config):
     c = config['key']
     ckey = ConfigEnum(c)
     if c == ConfigEnum.unique_id and not override_unique_id:
@@ -115,7 +115,7 @@ def add_or_update_config(commit=True, child_id=0, override_unique_id=True, **con
     set_hconfig(ckey, v, child_id, commit=commit)
 
 
-def bulk_register_configs(hconfigs, commit=True, override_child_id=None, override_unique_id=True):
+def bulk_register_configs(hconfigs, commit: bool = True, override_child_id: int = None, override_unique_id: bool = True):
     from hiddifypanel.panel import hiddify
     for conf in hconfigs:
         # print(conf)

hiddifypanel/models/parent_domain.py

@@ -19,33 +19,33 @@ class ParentDomain(db.Model, SerializerMixin):
                                    backref=backref('parent_domains', lazy='dynamic')
                                    )
 
-    def to_dict(d):
+    def to_dict(self):
         return {
-            'domain': d.domain,
-            'alias': d.alias,
-            'show_domains': [dd.domain for dd in d.show_domains]
+            'domain': self.domain,
+            'alias': self.alias,
+            'show_domains': [dd.domain for dd in self.show_domains]
         }
 
-
-def add_or_update_parent_domains(commit=True, **parent_domain):
-    dbdomain = ParentDomain.query.filter(ParentDomain.domain == parent_domain['domain']).first()
-    if not dbdomain:
-        dbdomain = ParentDomain(domain=parent_domain['domain'])
-        db.session.add(dbdomain)
-    show_domains = parent_domain.get('show_domains', [])
-    dbdomain.show_domains = Domain.query.filter(Domain.domain.in_(show_domains)).all()
-    dbdomain.alias = parent_domain.get('alias')
-    if commit:
-        db.session.commit()
-
-
-def bulk_register_parent_domains(parent_domains, commit=True, remove=False):
-    for p in parent_domains:
-        add_or_update_parent_domains(commit=False, **p)
-    if remove:
-        dd = {p.domain: 1 for p in parent_domains}
-        for d in ParentDomain.query.all():
-            if d.domain not in dd:
-                db.session.delete(d)
-    if commit:
-        db.session.commit()
+    @staticmethod
+    def add_or_update(commit=True, **parent_domain):
+        dbdomain = ParentDomain.query.filter(ParentDomain.domain == parent_domain['domain']).first()
+        if not dbdomain:
+            dbdomain = ParentDomain(domain=parent_domain['domain'])
+            db.session.add(dbdomain)
+        show_domains = parent_domain.get('show_domains', [])
+        dbdomain.show_domains = Domain.query.filter(Domain.domain.in_(show_domains)).all()
+        dbdomain.alias = parent_domain.get('alias')
+        if commit:
+            db.session.commit()
+
+    @staticmethod
+    def bulk_register(parent_domains, commit=True, remove=False):
+        for p in parent_domains:
+            ParentDomain.add_or_update(commit=False, **p)
+        if remove:
+            dd = {p.domain: 1 for p in parent_domains}
+            for d in ParentDomain.query.all():
+                if d.domain not in dd:
+                    db.session.delete(d)
+        if commit:
+            db.session.commit()

hiddifypanel/models/proxy.py

@@ -62,36 +62,38 @@ class Proxy(db.Model, SerializerMixin):
     transport = db.Column(db.Enum(ProxyTransport), nullable=False)
     cdn = db.Column(db.Enum(ProxyCDN), nullable=False)
 
-    def to_dict(d):
+    def to_dict(self):
         return {
-            'name': d.name,
-            'enable': d.enable,
-            'proto': d.proto,
-            'l3': d.l3,
-            'transport': d.transport,
-            'cdn': d.cdn,
-            'child_unique_id': d.child.unique_id if d.child else ''
+            'name': self.name,
+            'enable': self.enable,
+            'proto': self.proto,
+            'l3': self.l3,
+            'transport': self.transport,
+            'cdn': self.cdn,
+            'child_unique_id': self.child.unique_id if self.child else ''
         }
 
-
-def add_or_update_proxy(commit=True, child_id=0, **proxy):
-    dbproxy = Proxy.query.filter(Proxy.name == proxy['name']).first()
-    if not dbproxy:
-        dbproxy = Proxy()
-        db.session.add(dbproxy)
-    dbproxy.enable = proxy['enable']
-    dbproxy.name = proxy['name']
-    dbproxy.proto = proxy['proto']
-    dbproxy.transport = proxy['transport']
-    dbproxy.cdn = proxy['cdn']
-    dbproxy.l3 = proxy['l3']
-    dbproxy.child_id = child_id
-    if commit:
-        db.session.commit()
-
-
-def bulk_register_proxies(proxies, commit=True, override_child_id=None):
-    from hiddifypanel.panel import hiddify
-    for proxy in proxies:
-        child_id = override_child_id if override_child_id is not None else hiddify.get_child(proxy.get('child_unique_id', None))
-        add_or_update_proxy(commit=False, child_id=child_id, **proxy)
+    @staticmethod
+    def add_or_update(commit=True, child_id=0, **proxy):
+        dbproxy = Proxy.query.filter(Proxy.name == proxy['name']).first()
+        if not dbproxy:
+            dbproxy = Proxy()
+            db.session.add(dbproxy)
+        dbproxy.enable = proxy['enable']
+        dbproxy.name = proxy['name']
+        dbproxy.proto = proxy['proto']
+        dbproxy.transport = proxy['transport']
+        dbproxy.cdn = proxy['cdn']
+        dbproxy.l3 = proxy['l3']
+        dbproxy.child_id = child_id
+        if commit:
+            db.session.commit()
+
+    @staticmethod
+    def bulk_register(proxies, commit=True, override_child_id=None):
+        from hiddifypanel.panel import hiddify
+        for proxy in proxies:
+            child_id = override_child_id if override_child_id is not None else hiddify.get_child(proxy.get('child_unique_id', None))
+            Proxy.add_or_update(commit=False, child_id=child_id, **proxy)
+        if commit:
+            db.session.commit()

hiddifypanel/models/usage.py

@@ -19,74 +19,74 @@ class DailyUsage(db.Model, SerializerMixin):
     # def __str__(self):
     #     return str([id,date,usage,online,admin_id,child_id])
 
-
-def get_daily_usage_stats(admin_id=None, child_id=None):
-    from .admin import AdminUser
-    if not admin_id:
-        admin_id = g.account.id
-    sub_admins = AdminUser.query.filter(AdminUser.id == admin_id).first().recursive_sub_admins_ids()
-    # print(sub_admins)
-
-    def filter_daily_usage_admin(query):
-        # print('before',admin_id,query.all())
-        if admin_id:
-            query = query.filter(DailyUsage.admin_id.in_(sub_admins))
-        if child_id:
-            query = query.filter(DailyUsage.child_id == child_id)
-        # print('after',admin_id,query.all())
-        return query
-
-    def filter_user_admin(query):
-        if admin_id:
-            query = query.filter(User.added_by.in_(sub_admins))
-
-        return query
-
-    from .user import User
-    # Today's usage and online count
-    today = date.today()
-    today_stats = filter_daily_usage_admin(db.session.query(
-        func.coalesce(func.sum(DailyUsage.usage), 0),
-        func.coalesce(func.sum(DailyUsage.online), 0)
-    ).filter(DailyUsage.date == today)).first()
-    users_online_today = filter_user_admin(User.query.filter(User.last_online >= today)).count()
-
-    h24 = datetime.datetime.now()-datetime.timedelta(days=1)
-    users_online_h24 = filter_user_admin(User.query.filter(User.last_online >= h24)).count()
-
-    m5 = datetime.datetime.now()-datetime.timedelta(minutes=5)
-    users_online_m5 = filter_user_admin(User.query.filter(User.last_online >= m5)).count()
-
-    # Yesterday's usage and online count
-    yesterday = date.today() - timedelta(days=1)
-    yesterday_stats = filter_daily_usage_admin(db.session.query(
-        func.coalesce(func.sum(DailyUsage.usage), 0),
-        func.coalesce(func.sum(DailyUsage.online), 0)
-    ).filter(DailyUsage.date == yesterday)).first()
-    # users_online_yesterday = User.query.filter(User.last_online >= yesterday, User.last_online < today).count()
-    # Last 30 days' usage and online count
-    last_30_days_start = date.today() - timedelta(days=30)
-    last_30_days_stats = filter_daily_usage_admin(db.session.query(
-        func.coalesce(func.sum(DailyUsage.usage), 0),
-        func.coalesce(func.sum(DailyUsage.online), 0)
-    ).filter(DailyUsage.date >= last_30_days_start)).first()
-    users_online_last_month = filter_user_admin(User.query.filter(User.last_online >= last_30_days_start)).count()
-
-    # Total usage and online count
-    total_stats = filter_daily_usage_admin(db.session.query(
-        func.coalesce(func.sum(DailyUsage.usage), 0),
-        func.coalesce(func.sum(DailyUsage.online), 0)
-    )).first()
-    ten_years_ago = today - timedelta(days=365*10)
-    users_online_last_10_years = filter_user_admin(User.query.filter(User.last_online >= ten_years_ago)).count()
-    total_users = filter_user_admin(User.query).count()
-
-    # Return the usage stats as a dictionary
-    return {
-        "today": {"usage": today_stats[0], "online": users_online_today},
-        "h24": {"usage": 0, "online": users_online_h24},
-        "m5": {"usage": 0, "online": users_online_m5},
-        "yesterday": {"usage": yesterday_stats[0], "online": yesterday_stats[1]},
-        "last_30_days": {"usage": last_30_days_stats[0], "online": users_online_last_month},
-        "total": {"usage": total_stats[0], "online": users_online_last_10_years, "users": total_users}
-    }
+    @staticmethod
+    def get_daily_usage_stats(admin_id=None, child_id=None):
+        from .admin import AdminUser
+        if not admin_id:
+            admin_id = g.account.id
+        sub_admins = AdminUser.query.filter(AdminUser.id == admin_id).first().recursive_sub_admins_ids()
+        # print(sub_admins)
+
+        def filter_daily_usage_admin(query):
+            # print('before',admin_id,query.all())
+            if admin_id:
+                query = query.filter(DailyUsage.admin_id.in_(sub_admins))
+            if child_id:
+                query = query.filter(DailyUsage.child_id == child_id)
+            # print('after',admin_id,query.all())
+            return query
+
+        def filter_user_admin(query):
+            if admin_id:
+                query = query.filter(User.added_by.in_(sub_admins))
+
+            return query
+
+        from .user import User
+        # Today's usage and online count
+        today = date.today()
+        today_stats = filter_daily_usage_admin(db.session.query(
+            func.coalesce(func.sum(DailyUsage.usage), 0),
+            func.coalesce(func.sum(DailyUsage.online), 0)
+        ).filter(DailyUsage.date == today)).first()
+        users_online_today = filter_user_admin(User.query.filter(User.last_online >= today)).count()
+
+        h24 = datetime.datetime.now()-datetime.timedelta(days=1)
+        users_online_h24 = filter_user_admin(User.query.filter(User.last_online >= h24)).count()
+
+        m5 = datetime.datetime.now()-datetime.timedelta(minutes=5)
+        users_online_m5 = filter_user_admin(User.query.filter(User.last_online >= m5)).count()
+
+        # Yesterday's usage and online count
+        yesterday = date.today() - timedelta(days=1)
+        yesterday_stats = filter_daily_usage_admin(db.session.query(
+            func.coalesce(func.sum(DailyUsage.usage), 0),
+            func.coalesce(func.sum(DailyUsage.online), 0)
+        ).filter(DailyUsage.date == yesterday)).first()
+        # users_online_yesterday = User.query.filter(User.last_online >= yesterday, User.last_online < today).count()
+        # Last 30 days' usage and online count
+        last_30_days_start = date.today() - timedelta(days=30)
+        last_30_days_stats = filter_daily_usage_admin(db.session.query(
+            func.coalesce(func.sum(DailyUsage.usage), 0),
+            func.coalesce(func.sum(DailyUsage.online), 0)
+        ).filter(DailyUsage.date >= last_30_days_start)).first()
+        users_online_last_month = filter_user_admin(User.query.filter(User.last_online >= last_30_days_start)).count()
+
+        # Total usage and online count
+        total_stats = filter_daily_usage_admin(db.session.query(
+            func.coalesce(func.sum(DailyUsage.usage), 0),
+            func.coalesce(func.sum(DailyUsage.online), 0)
+        )).first()
+        ten_years_ago = today - timedelta(days=365*10)
+        users_online_last_10_years = filter_user_admin(User.query.filter(User.last_online >= ten_years_ago)).count()
+        total_users = filter_user_admin(User.query).count()
+
+        # Return the usage stats as a dictionary
+        return {
+            "today": {"usage": today_stats[0], "online": users_online_today},
+            "h24": {"usage": 0, "online": users_online_h24},
+            "m5": {"usage": 0, "online": users_online_m5},
+            "yesterday": {"usage": yesterday_stats[0], "online": yesterday_stats[1]},
+            "last_30_days": {"usage": last_30_days_stats[0], "online": users_online_last_month},
+            "total": {"usage": total_stats[0], "online": users_online_last_10_years, "users": total_users}
+        }

hiddifypanel/panel/admin/Actions.py

@@ -107,22 +107,21 @@ class Actions(FlaskView):
             flash((_('Your domains changed. Please do not forget to copy admin links, otherwise you can not access to the panel anymore.')), 'info')
         # flash(f'complete_install={complete_install} domain_changed={domain_changed} ', 'info')
         # return render_template("result.html")
-        hiddify.add_temporary_access()
+        # hiddify.add_temporary_access()
         file = "install.sh" if complete_install else "apply_configs.sh"
         try:
             server_ip = urllib.request.urlopen('https://v4.ident.me/').read().decode('utf8')
         except:
             server_ip = "server_ip"
 
-        admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin)
         admin_links = f"<h5 >{_('Admin Links')}</h5><ul>"
-        username, password = hiddify.current_account_user_pass()
-        admin_links += f"<li><span class='badge badge-danger'>{_('Not Secure')}</span>: <a class='badge ltr share-link' href='http://{username}:{password}@{server_ip}/{admin_proxy_path}/admin/'>http://{username}:{password}@{server_ip}/{admin_proxy_path}/admin/</a></li>"
+
+        admin_links += f"<li><span class='badge badge-danger'>{_('Not Secure')}</span>: <a class='badge ltr share-link' href='{hiddify.get_account_panel_link(g.account, server_ip,is_https=False)}'>{hiddify.get_account_panel_link(g.account, server_ip,is_https=False)}</a></li>"
         domains = get_panel_domains()
         # domains=[*domains,f'{server_ip}.sslip.io']
 
         for d in domains:
-            link = f'https://{username}:{password}@{d}/{admin_proxy_path}/admin/'
+            link = hiddify.get_account_panel_link(g.account, d)
             admin_links += f"<li><a target='_blank' class='badge ltr' href='{link}'>{link}</a></li>"
 
         resp = render_template("result.html",
@@ -169,7 +168,7 @@ class Actions(FlaskView):
         return self.update2()
 
     def update2(self):
-        hiddify.add_temporary_access()
+        # hiddify.add_temporary_access()
         # run update.sh
         commander(Command.update)
 

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -82,19 +82,19 @@ class AdminstratorAdmin(AdminLTEModelView):
 
     def _ul_formatter(view, context, model, name):
 
-        return Markup(" ".join([hiddify.get_user_link(model.uuid, d, 'admin', model.name).replace('/admin/', '/', 1) for d in get_panel_domains()]))
+        return Markup(" ".join([hiddify.get_html_user_link(model, d) for d in get_panel_domains()]))
 
     @property
     def can_create(self):
         return g.account.can_add_admin or g.account.mode == AdminMode.super_admin
 
     def _name_formatter(view, context, model, name):
-        admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin)
-        d = get_panel_domains()[0]
+
+        d = request.host
         if d:
-            # link = f"<a target='_blank' href='https://{model.username}:{model.password}@{d}/{admin_proxy_path}/#{model.name}'>{model.name} <i class='fa-solid fa-arrow-up-right-from-square'></i></a>"
-            href = f'https://{d}/{admin_proxy_path}/{model.uuid}/#{model.name}'
-            link = f"<a target='_blank' class='copy-link' data-copy='{href}' href='{href}'>{model.name} <i class='fa-solid fa-arrow-up-right-from-square'></i></a>"
+
+            href = hiddify.get_account_panel_link(model, d) + f'/#{model.name}'
+            link = f"<a target='_blank' class='share-link' data-copy='{href}' href='{href}'>{model.name} <i class='fa-solid fa-arrow-up-right-from-square'></i></a>"
             if model.parent_admin:
                 return Markup(model.parent_admin.name + "&rlm;&lrm; / &rlm;&lrm;"+link)
             return Markup(link)

hiddifypanel/panel/admin/Backup.py

@@ -58,11 +58,11 @@ class Backup(FlaskView):
 
             from flask_babel import refresh
             refresh()
-            return redirect(f'/{hconfig(ConfigEnum.proxy_path_admin)}/admin/actions/reinstall2/', code=302)
-            from . import Actions
-            action = Actions()
-            return action.reinstall(complete_install=True, domain_changed=True)
-            # hiddify.flash_config_success(full_install=True)
+            return redirect(url_for("admin.Actions:reinstall2"))
+            # from . import Actions
+            # action = Actions()
+            # return action.reinstall(complete_install=True, domain_changed=True)
+            # # hiddify.flash_config_success(full_install=True)
         else:
             flash(_('Config file is incorrect'), category='error')
         return render_template('backup.html', restore_form=restore_form)

hiddifypanel/panel/admin/ChildAdmin.py

@@ -51,8 +51,7 @@ class ChildAdmin(AdminLTEModelView):
     form_columns = ['domain', 'show_domains']
 
     def _domain_admin_link(view, context, model, name):
-        username, password = hiddify.current_account_user_pass()
-        admin_link = f'https://{username}:{password}@{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/admin/Dashboard.py

@@ -24,7 +24,7 @@ class Dashboard(FlaskView):
 
     #     return jsonify(dict(
     #         stats={'system': hiddify.system_stats(), 'top5': hiddify.top_processes()},
-    #         usage_history=get_daily_usage_stats(admin_id)
+    #         usage_history=DailyUsage.get_daily_usage_stats(admin_id)
     #     ))
 
     @login_required(roles={Role.super_admin, Role.admin, Role.agent})
@@ -52,7 +52,7 @@ class Dashboard(FlaskView):
                 for d in c.domains:
                     if d.mode == DomainType.fake:
                         continue
-                    remote = f"https://{d.domain}/{hconfig(ConfigEnum.proxy_path_admin,c.id)}/{hconfig(ConfigEnum.admin_secret,c.id)}"
+                    remote = hiddify.get_account_panel_link(g.account, d.domain, child_id=c.id)
                     d.is_active = hiddify.check_connection_to_remote(remote)
                     if d.is_active:
                         c.is_active = True
@@ -74,8 +74,7 @@ class Dashboard(FlaskView):
                 flash(_("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")
         elif def_user:
             d = domains[0]
-            u = def_user.uuid
-            flash((_('It seems that you have not created any users yet. Default user link: %(default_link)s', default_link=hiddify.get_user_link(u, d))), 'secondary')
+            flash((_('It seems that you have not created any users yet. Default user link: %(default_link)s', default_link=hiddify.get_html_user_link(def_user, d))), 'secondary')
         if hiddify.is_ssh_password_authentication_enabled():
             flash(_('ssh.password-login.warning.'), "warning")
 
@@ -83,7 +82,7 @@ class Dashboard(FlaskView):
     #     flash((_('Error!!!')),'info')
 
         stats = {'system': hiddify.system_stats(), 'top5': hiddify.top_processes()}
-        return render_template('index.html', stats=stats, usage_history=get_daily_usage_stats(admin_id, child_id), childs=childs)
+        return render_template('index.html', stats=stats, usage_history=DailyUsage.get_daily_usage_stats(admin_id, child_id), childs=childs)
 
     @login_required(roles={Role.super_admin})
     @route('remove_child', methods=['POST'])

hiddifypanel/panel/admin/DomainAdmin.py

@@ -92,7 +92,7 @@ class DomainAdmin(AdminLTEModelView):
         d = model.domain
         if "*" in d:
             d = d.replace("*", hiddify.get_random_string(5, 15))
-        admin_link = f'https://{d}{hiddify.get_admin_path()}'
+        admin_link = hiddify.get_account_panel_link(g.account, d)
         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/admin/QuickSetup.py

@@ -75,11 +75,6 @@ class QuickSetup(FlaskView):
             ])
 
             db.session.commit()
-            # hiddify.flash_config_success()
-            # proxy_path = hconfig(ConfigEnum.proxy_path_admin)
-            # uuid=User.query.first().uuid
-            # userlink=f"<a class='btn btn-secondary share-link' target='_blank' href='https://{quick_form.domain.data}/{proxy_path}/{uuid}/'>{_('default user link')}</a>"
-            # flash((_('The default user link is %(link)s. To add or edit more users, please visit users from menu.',link=userlink)),'info')
 
             from . import Actions
             action = Actions.Actions()
@@ -153,7 +148,4 @@ def validate_domain(form, field):
 
 def admin_link():
     domains = get_panel_domains()
-    if len(domains):
-        return "https://"+domains[0].domain+hiddify.get_admin_path()
-    else:
-        return "https://"+hutils.ip.get_ip(4)+hiddify.get_admin_path()
+    return hiddify.get_account_panel_link(g.account, domains[0] if len(domains)else hutils.ip.get_ip(4))

hiddifypanel/panel/admin/UserAdmin.py

@@ -134,15 +134,15 @@ class UserAdmin(AdminLTEModelView):
         else:
             link = '<i class="fa-solid fa-circle-xmark text-danger"></i> '
 
-        client_proxy_path = hconfig(ConfigEnum.proxy_path_client)
-        href = f'https://{request.host}/{client_proxy_path}/{model.uuid}/#{model.name}'
-        link += f"<a target='_blank' class='copy-link' data-copy='{href}' href='{href}'>{model.name} <i class='fa-solid fa-arrow-up-right-from-square'></i></a>"
-        # link += f"<a target='_blank' class='copy-link' href='https://{model.username}:{model.password}@{d}/{client_proxy_path}/#{model.name}'>{model.name} <i class='fa-solid fa-arrow-up-right-from-square'></i></a>"
+        href = hiddify.get_account_panel_link(model, request.host, is_https=True, prefere_path_only=True)+f"#{model.name}"
+
+        link += f"<a target='_blank' class='share-link' data-copy='{href}' href='{href}'>{model.name} <i class='fa-solid fa-arrow-up-right-from-square'></i></a>"
+
         return Markup(extra+link)
 
     def _ul_formatter(view, context, model, name):
         domains = get_panel_domains()
-        return Markup(" ".join([hiddify.get_user_link(model.uuid, d, 'new', model.name) for d in domains]))
+        return Markup(" ".join([hiddify.get_html_user_link(model, d) for d in domains]))
 
     def _uuid_formatter(view, context, model, name):
         return Markup(f"<span>{model.uuid}</span>")

hiddifypanel/panel/admin/templates/parent_dash.html

@@ -1,7 +1,6 @@
 {% 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/admin/templates/result.html

@@ -8,6 +8,7 @@
   {{out_msg|safe}}
 </div>
 
+{#
 %if g.temp_admin_link
 {% macro temp_link() -%}
 <div class="btn-group">
@@ -24,6 +25,7 @@
 
 {{modal('save_emergency',_('This action is not yet finished.'),_("Please copy the emergency link before leaving this page."),temp_link(),show=False)}}
 %endif
+#}
 
 %if g.temp_admin_link
 <div class="callout callout-success">
@@ -145,7 +147,7 @@
     //   //x.contentWindow.scrollTo( 0, 999999 );
   }
   setInterval(refresh, 1000);
-  %if g.temp_admin_link
+  {%if g.temp_admin_link %}
   window.addEventListener('beforeunload', function (e) {
     //   // Cancel the event
     console.log("Finished", finished)
@@ -153,12 +155,12 @@
 
       e.preventDefault(); // If you prevent default behavior in Mozilla Firefox prompt will always be shown
       //   // Chrome requires returnValue to be set
-      $("#save_emergency").modal()
+      //$("#save_emergency").modal()
       e.returnValue = 'Save';
       return "save"
     }
   });
-  % endif
+  {% endif %}
 
   $("#logbtn").on("click", function (event) {
     event.preventDefault()