hiddifypanel 10.20.4__py3-none-any.whl → 10.30.0.dev0__py3-none-any.whl

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

@@ -50,60 +50,66 @@ class AllConfigsAPI(MethodView):
             )
         )
 
-        # Add Full Singbox
-        items.append(
-            create_item(
-                "Full Singbox", "ALL", "", "", "", "",
-                # f"{base_url}full-singbox.json?asn={c['asn']}"
-                f"{base_url}singbox/?asn={c['asn']}#{config_name}"
+        if hconfig(ConfigEnum.sub_full_singbox_enable):
+            # Add Full Singbox
+            items.append(
+                create_item(
+                    "Full Singbox", "ALL", "", "", "", "",
+                    # f"{base_url}full-singbox.json?asn={c['asn']}"
+                    f"{base_url}singbox/?asn={c['asn']}#{config_name}"
+                )
             )
-        )
 
-        # Add Full Xray
-        items.append(
-            create_item(
-                "Full Xray", "ALL", "", "", "", "",
-                f"{base_url}xray/#{config_name}"
+        if hconfig(ConfigEnum.sub_full_xray_json_enable):
+            # Add Full Xray
+            items.append(
+                create_item(
+                    "Full Xray", "ALL", "", "", "", "",
+                    f"{base_url}xray/#{config_name}"
+                )
             )
-        )
 
-        # Add Subscription link
-        items.append(
-            create_item(
-                "Subscription link", "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}"
+        if hconfig(ConfigEnum.sub_full_links_enable):
+            # Add Subscription link
+            items.append(
+                create_item(
+                    "Subscription link", "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", "", "", "", "",
-                # 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}"
+        if hconfig(ConfigEnum.sub_full_links_b64_enable):
+            # Add Subscription link base64
+            items.append(
+                create_item(
+                    "Subscription link b64", "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(
-                "Clash Meta", "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']}"
-                f"clash://install-config?url={base_url}clashmeta/?asn={c['asn']}#{config_name}"
+        if hconfig(ConfigEnum.sub_full_clash_meta_enable):
+            # Add Clash Meta
+            items.append(
+                create_item(
+                    "Clash Meta", "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']}"
+                    f"clash://install-config?url={base_url}clashmeta/?asn={c['asn']}#{config_name}"
+                )
             )
-        )
 
-        # Add Clash
-        items.append(
-            create_item(
-                "Clash", "ALL", "Except VLess", "", "", "",
-                # 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']}"
-                f"clash://install-config?url={base_url}clash/?asn={c['asn']}#{config_name}"
+        if hconfig(ConfigEnum.sub_full_clash_enable):
+            # Add Clash
+            items.append(
+                create_item(
+                    "Clash", "ALL", "Except VLess", "", "", "",
+                    # 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']}"
+                    f"clash://install-config?url={base_url}clash/?asn={c['asn']}#{config_name}"
+                )
             )
-        )
 
         # Add Singbox: SSh
-        if hconfig(ConfigEnum.ssh_server_enable):
+        if hconfig(ConfigEnum.sub_singbox_ssh_enable) and hconfig(ConfigEnum.ssh_server_enable):
             items.append(
                 create_item(
                     "Singbox: SSH", "SSH", "", "", "", "",

hiddifypanel/panel/commercial/telegrambot/Usage.py

@@ -57,7 +57,7 @@ def get_usage_msg(uuid, domain=None):
         expire_rel = user_data['expire_rel']
         reset_day = user_data['reset_day']
 
-        domain = domain or get_panel_domains()[0]
+        domain = domain or Domain.get_domains()[0]
         user_link = hiddify.get_account_panel_link(user, domain.domain)
         with force_locale(user.lang or hconfig(ConfigEnum.lang)):
             msg = f"""{_('<a href="%(user_link)s"> %(user)s</a>',user_link=user_link ,user=user.name if user.name != "default" else "")}\n\n"""

hiddifypanel/panel/commercial/telegrambot/admin.py

@@ -102,7 +102,7 @@ def admin_keyboard_domain(old_action):
         )
     return types.InlineKeyboardMarkup(keyboard=[
         [keyboard(d)]
-        for d in get_panel_domains()
+        for d in Domain.get_domains()
     ]
     )
 

hiddifypanel/panel/commercial/telegrambot/information.py

@@ -16,7 +16,7 @@ def prepare_me_info(user):
                  "Your hiddify information is\n" +
                  "UUID: {}\n".format(user.uuid) +
                  "Last online date: {}\n".format(user.last_online) +
-                 "Expire time: {}\n".format(user.expiry_time) +
+                 "Expire time: {}\n".format(user.remaining_days) +
                  "Usage class: {}\n".format(user.mode)
                  )
 

hiddifypanel/panel/common.py

@@ -46,12 +46,8 @@ def init_app(app: APIFlask):
             return jsonify({
                 'message': 'Not Found',
             }), 404
-        # print(request.headers)
-        last_version = hiddify.get_latest_release_version('hiddify-panel')  # TODO: add dev update check
-        if "T" in hiddifypanel.__version__:
-            has_update = False
-        else:
-            has_update = "dev" not in hiddifypanel.__version__ and f'{last_version}' != hiddifypanel.__version__
+
+        has_update = hutils.utils.is_panel_outdated()
 
         if not request.accept_mimetypes.accept_html:
             if has_update:
@@ -68,6 +64,7 @@ def init_app(app: APIFlask):
 
         # Create github issue link
         issue_link = hutils.github_issue.generate_github_issue_link_for_500_error(e, trace)
+        last_version = hiddify.get_latest_release_version('hiddifypanel')
 
         return render_template('500.html', error=e, trace=trace, has_update=has_update, last_version=last_version, issue_link=issue_link), 500
 
@@ -83,11 +80,8 @@ def init_app(app: APIFlask):
             # Create github issue link
             issue_link = hutils.github_issue.generate_github_issue_link_for_500_error(e, trace)
 
-            last_version = hiddify.get_latest_release_version('hiddify-panel')  # TODO: add dev update check
-            if "T" in hiddifypanel.__version__:
-                has_update = False
-            else:
-                has_update = "dev" not in hiddifypanel.__version__ and f'{last_version}' != hiddifypanel.__version__
+            has_update = hutils.utils.is_panel_outdated()
+            last_version = hiddify.get_latest_release_version('hiddifypanel')
 
             return render_template('500.html', error=e, trace=trace, has_update=has_update, last_version=last_version, issue_link=issue_link), 500
 

hiddifypanel/panel/hiddify.py

@@ -82,7 +82,9 @@ def get_html_user_link(model: BaseAccount, domain: Domain):
     if "*" in d:
         d = d.replace("*", hutils.random.get_random_string(5, 15))
 
-    link = f'{get_account_panel_link(model, d)}#{hutils.encode.unicode_slug(model.name)}'
+    # for showing child/node link (we send child_id to get_account_panel_link to get domain proxy path correctly)
+    d_child_id = domain.child_id
+    link = f'{get_account_panel_link(model, d,child_id=d_child_id)}#{hutils.encode.unicode_slug(model.name)}'
 
     text = domain.alias or domain.domain
     color_cls = 'info'
@@ -224,7 +226,7 @@ def set_db_from_json(json_data, override_child_unique_id=True, set_users=True, s
     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)
+        Domain.bulk_register(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_unique_id=override_unique_id)
@@ -274,9 +276,11 @@ def get_account_panel_link(account: BaseAccount, host: str, is_https: bool = Tru
         link += str(host)
     proxy_path = hconfig(ConfigEnum.proxy_path_admin if is_admin else ConfigEnum.proxy_path_client, child_id)
     link += f'/{proxy_path}/'
-    if child_id != 0:
-        child = Child.by_id(child_id)
-        link += f"{child.id}/"
+
+    # if child_id != 0:
+    #     child = Child.by_id(child_id)
+    #     link += f"{child.id}/"
+
     if basic_auth:
         link += "l"
     else:
@@ -332,18 +336,3 @@ def get_backup_child_unique_id(backupdata: dict) -> str:
     if len(backupdata.get('childs', [])) == 0:
         return "self"
     return backupdata['childs'][0]['unique_id']
-
-
-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'''
-    if not g.user_agent.get('hiddify_version'):
-        return False
-    raw_v = g.user_agent['hiddify_version']
-    raw_v_len = len(raw_v)
-    u_major_v = raw_v[0] if raw_v_len > 0 else 0
-    u_minor_v = raw_v[1] if raw_v_len > 1 else 0
-    u_patch_v = raw_v[2] if raw_v_len > 2 else 0
-
-    if u_major_v >= major_v and u_minor_v >= minor_v and u_patch_v >= patch_v:
-        return True
-    return False

hiddifypanel/panel/init_db.py

@@ -17,6 +17,24 @@ from sqlalchemy import text
 MAX_DB_VERSION = 90
 
 
+def _v88(child_id):
+    pass
+
+
+def _v86(child_id):
+    set_hconfig(ConfigEnum.hiddifycli_enable, True)
+
+
+def _v85(child_id):
+    set_hconfig(ConfigEnum.sub_full_singbox_enable, True)
+    set_hconfig(ConfigEnum.sub_singbox_ssh_enable, True)
+    set_hconfig(ConfigEnum.sub_full_xray_json_enable, True)
+    set_hconfig(ConfigEnum.sub_full_links_enable, True)
+    set_hconfig(ConfigEnum.sub_full_links_b64_enable, True)
+    set_hconfig(ConfigEnum.sub_full_clash_enable, True)
+    set_hconfig(ConfigEnum.sub_full_clash_meta_enable, True)
+
+
 def _v84(child_id):
     # the 2022-blake3-chacha20-poly1305 encryption method doesn't support multiuser config
     if hconfig(ConfigEnum.shadowsocks2022_method) == '2022-blake3-chacha20-poly1305':
@@ -246,7 +264,7 @@ def _v41():
 
 def _v38():
     add_config_if_not_exist(ConfigEnum.dns_server, "1.1.1.1")
-    add_config_if_not_exist(ConfigEnum.warp_mode, "all" if hconfig(ConfigEnum.warp_enable) else "none")
+    add_config_if_not_exist(ConfigEnum.warp_mode, "all" if hconfig(ConfigEnum.warp_enable) else "disable")
     add_config_if_not_exist(ConfigEnum.warp_plus_code, '')
 
 
@@ -328,17 +346,17 @@ def _v19():
     add_config_if_not_exist(ConfigEnum.package_mode, "release")
 
 
-def _v17():
-    for u in User.query.all():
-        if u.expiry_time:
-            if not u.package_days:
-                if not u.last_reset_time:
-                    u.package_days = (u.expiry_time - datetime.date.today()).days
-                    u.start_date = datetime.date.today()
-                else:
-                    u.package_days = (u.expiry_time - u.last_reset_time).days
-                    u.start_date = u.last_reset_time
-            u.expiry_time = None
+# def _v17():
+#     for u in User.query.all():
+#         if u.expiry_time:
+#             if not u.package_days:
+#                 if not u.last_reset_time:
+#                     u.package_days = (u.expiry_time - datetime.date.today()).days
+#                     u.start_date = datetime.date.today()
+#                 else:
+#                     u.package_days = (u.expiry_time - u.last_reset_time).days
+#                     u.start_date = u.last_reset_time
+#             u.expiry_time = None
 
 
 def _v1():
@@ -368,7 +386,7 @@ def _v1():
         BoolConfig(key=ConfigEnum.vmess_enable, value=True),
         BoolConfig(key=ConfigEnum.http_proxy_enable, value=True),
         StrConfig(key=ConfigEnum.shared_secret, value=str(uuid.uuid4())),
-        BoolConfig(key=ConfigEnum.telegram_enable, value=True),
+        BoolConfig(key=ConfigEnum.telegram_enable, value=False),
         # StrConfig(key=ConfigEnum.telegram_secret,value=uuid.uuid4().hex),
         StrConfig(key=ConfigEnum.telegram_adtag, value=""),
         StrConfig(key=ConfigEnum.telegram_fakedomain, value=rnd_domains[1]),

hiddifypanel/panel/usage.py

@@ -27,6 +27,22 @@ def add_users_usage_uuid(uuids_bytes: Dict[str, Dict], child_id, sync=False):
     _add_users_usage(dbusers_bytes, child_id, sync)  # type: ignore
 
 
+def _reset_priodic_usage():
+    last_usage_check: int = hconfig(ConfigEnum.last_priodic_usage_check) or 0
+    import time
+    current_time = int(time.time())
+    if current_time - last_usage_check < 60 * 60 * 6:
+        return
+    # reset as soon as possible in the day
+    if datetime.datetime.now().hour > 5 and current_time - last_usage_check < 60 * 60 * 24:
+        return
+
+    for user in User.query.filter(User.mode != UserMode.no_reset).all():
+        if user.user_should_reset():
+            user.reset_usage(commit=False)
+    set_hconfig(ConfigEnum.last_priodic_usage_check, current_time)
+
+
 def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
     '''
     sync: when enabled, it means we have received usages from the parent panel
@@ -42,39 +58,43 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
             daily_usage[adm.id] = DailyUsage(admin_id=adm.id, child_id=child_id)
             db.session.add(daily_usage[adm.id])
         daily_usage[adm.id].online = User.query.filter(User.added_by == adm.id).filter(func.DATE(User.last_online) == today).count()
-    # db.session.commit()
+
+    _reset_priodic_usage()
+
     userDetails = {p.user_id: p for p in UserDetail.query.filter(UserDetail.child_id == child_id).all()}
     for user, uinfo in users_usage_data.items():
         usage_bytes = uinfo['usage']
         devices = uinfo['devices']
-        # user_active_before=user.is_active
+
+        # UserDetails things
         detail = userDetails.get(user.id)
         if not detail:
             detail = UserDetail(user_id=user.id, child_id=child_id)
-            detail.current_usage_GB = detail.current_usage_GB or 0
             db.session.add(detail)
         detail.connected_devices = devices
         detail.current_usage_GB = detail.current_usage_GB or 0
-        if not user.last_reset_time or user.user_should_reset():
-            user.last_reset_time = datetime.date.today()
-            user.current_usage_GB = 0
-            detail.current_usage_GB = 0
 
+        # Enable the user if isn't already
         if not before_enabled_users[user.uuid] and user.is_active:
             print(f"Enabling disabled client {user.uuid} ")
             user_driver.add_client(user)
             send_bot_message(user)
             have_change = True
+
+        # Check if there's new usage value
         if not isinstance(usage_bytes, int) or usage_bytes == 0:
             res[user.uuid] = "No usage"
         else:
+            # Set new daily usage of the user
             if sync:
                 if daily_usage.get(user.added_by, daily_usage[1]).usage != usage_bytes:
                     daily_usage.get(user.added_by, daily_usage[1]).usage = usage_bytes
             else:
                 daily_usage.get(user.added_by, daily_usage[1]).usage += usage_bytes
+
             in_gig = (usage_bytes) / to_gig_d
-            res[user.uuid] = in_gig
+
+            # Set new current usage of the user
             if sync:
                 if user.current_usage_GB != in_gig:
                     user.current_usage_GB = in_gig
@@ -82,12 +102,18 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
             else:
                 user.current_usage_GB += in_gig
                 detail.current_usage_GB += in_gig
+
+            # Change last online time of the user
             user.last_online = datetime.datetime.now()
             detail.last_online = datetime.datetime.now()
 
+            # Set start date of user to the current datetime if it hasn't been set already
             if user.start_date is None:
                 user.start_date = datetime.date.today()
 
+            res[user.uuid] = in_gig
+
+        # Remove user from drivers(singbox, xray, wireguard etc.) if they're inactive
         if before_enabled_users[user.uuid] and not user.is_active:
             print(f"Removing enabled client {user.uuid} ")
             user_driver.remove_client(user)
@@ -95,13 +121,16 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
             res[user.uuid] = f"{res[user.uuid]} !OUT of USAGE! Client Removed"
 
     db.session.commit()  # type: ignore
+
+    # Apply the changes to the drivers
     if have_change:
         hiddify.quick_apply_users()
 
-    # sync with the parent
+    # Sync the new data with the parent node if the data has not been set by the parent node itself and the current panel is a child panel
     if not sync:
         if hutils.node.is_child():
             hutils.node.child.sync_users_usage_with_parent()
+
     return {"status": 'success', "comments": res}
 
 

hiddifypanel/panel/user/user.py

@@ -18,45 +18,43 @@ from hiddifypanel import hutils
 
 class UserView(FlaskView):
 
-    @route('/useragent/')
-    @login_required(roles={Role.user})
-    def test(self):
-        ua = request.user_agent.string
-        print(ua)
-        return ua
-
     def index(self):
         return self.auto_sub()
 
     def auto_sub(self):
         if g.user_agent['is_browser']:
             return self.new()
-        return self.get_proper_config() or self.all_configs(base64=True)
+        return self.get_proper_config() or self.links_imp(base64=True)
 
     # former /sub/ or /sub (it was auto actually but we named it as /sub/)
     @route('/auto/')
     @route('/auto')
     @login_required(roles={Role.user})
     def force_sub(self):
-        return self.get_proper_config() or self.all_configs(base64=False)
+        return self.get_proper_config() or self.links_imp(base64=False)
 
     # region new endpoints
     @route("/sub/")
     @route("/sub")
     @login_required(roles={Role.user})
     def sub(self):
-        return self.all_configs(base64=False)
+        '''Returns proxy links (not base64 encoded)'''
+        return self.links_imp(base64=False)
 
     @route("/sub64/")
     @route("/sub64")
     @login_required(roles={Role.user})
     def sub64(self):
-        return self.all_configs(base64=True)
+        '''Returns proxy links (base64 encoded)'''
+        return self.links_imp(base64=True)
 
     @route("/xray/")
     @route("/xray")
     @login_required(roles={Role.user})
     def xray(self):
+        '''Returns Xray JSON proxy config'''
+        # if not hconfig(ConfigEnum.sub_full_xray_json_enable):
+        #     return 'The Full Xray subscription is disabled'
         c = get_common_data(g.account.uuid, mode="new")
         configs = hutils.proxy.xrayjson.configs_as_json(c['domains'], c['user'], c['expire_days'], c['profile_title'])
         return add_headers(configs, c, 'application/json')
@@ -65,25 +63,29 @@ class UserView(FlaskView):
     @route("/singbox")
     @login_required(roles={Role.user})
     def singbox_full(self):
-        return self.full_singbox()
+        '''Returns singbox client JSON config'''
+        return self.full_singbox_imp()
 
     @route("/singbox-ssh/")
     @route("/singbox-ssh")
     @login_required(roles={Role.user})
     def singbox_ssh(self):
-        return self.singbox()
+        '''Returns singbox client JSON config (ssh)'''
+        return self.singbox_ssh_imp()
 
     @route("/clash/")
     @route("/clash")
     @login_required(roles={Role.user})
     def clash(self):
-        return self.clash_config(meta_or_normal="normal")
+        '''Returns clash client config'''
+        return self.clash_config_imp(meta_or_normal="normal")
 
     @route("/clashmeta/")
     @route("/clashmeta")
     @login_required(roles={Role.user})
     def clashmeta(self):
-        return self.clash_config(meta_or_normal="meta")
+        '''Returns clash meta client config'''
+        return self.clash_config_imp(meta_or_normal="meta")
     # endregion
 
     @ route('/new/')
@@ -100,26 +102,28 @@ class UserView(FlaskView):
         return render_template('new.html', **c, ua=user_agent)
 
     def get_proper_config(self):
+        '''Returns proper config based on user agent'''
         if g.user_agent['is_browser']:
             return None
+
         ua = request.user_agent.string
         if g.user_agent['is_singbox'] or re.match('^(HiddifyNext|Dart|SFI|SFA)', ua, re.IGNORECASE):
-            return self.full_singbox()
+            return self.full_singbox_imp()
 
         if re.match('^(Clash-verge|Clash-?Meta|Stash|NekoBox|NekoRay|Pharos|hiddify-desktop)', ua, re.IGNORECASE):
-            return self.clash_config(meta_or_normal="meta")
+            return self.clash_config_imp(meta_or_normal="meta")
         if re.match('^(Clash|Stash)', ua, re.IGNORECASE):
-            return self.clash_config(meta_or_normal="normal")
+            return self.clash_config_imp(meta_or_normal="normal")
 
-        if g.user_agent.get('is_v2rayng'):
-            return self.xray()
+        if hconfig(ConfigEnum.sub_full_xray_json_enable):
+            # return the old "Subscription link b64" sub if the "Full Xray" sub is disabled (wanted by user)
+            if g.user_agent.get('is_v2rayng') and hutils.flask.is_client_version(hutils.flask.ClientVersion.v2ryang, 1, 8, 17):
+                return self.xray()
+            elif g.user_agent.get('is_streisand'):
+                return self.xray()
 
-        # if 'HiddifyNext' in ua or 'Dart' in ua:
-        #     return self.clash_config(meta_or_normal="meta")
-
-        # if any([p in ua for p in ['FoXray', 'HiddifyNG','Fair%20VPN' ,'v2rayNG', 'SagerNet']]):
-        if re.match('^(Hiddify|FoXray|Fair|v2rayNG|SagerNet|Shadowrocket|V2Box|Loon|Liberty)', ua, re.IGNORECASE):
-            return self.all_configs(base64=True)
+        if re.match('^(Hiddify|FoXray|Fair|v2rayNG|SagerNet|Shadowrocket|V2Box|Loon|Liberty|Streisand)', ua, re.IGNORECASE):
+            return self.links_imp(base64=True)
 
     @route('/clash/<meta_or_normal>/proxies.yml')
     @route('/clash/proxies.yml')
@@ -176,8 +180,12 @@ class UserView(FlaskView):
     @ route('/clash/<typ>.yml', methods=["GET", "HEAD"])
     @ route('/clash/<meta_or_normal>/<typ>.yml', methods=["GET", "HEAD"])
     @login_required(roles={Role.user})
-    def clash_config(self, meta_or_normal="normal", typ="all.yml"):
+    def clash_config_imp(self, meta_or_normal="normal", typ="all.yml"):
         mode = request.args.get("mode")
+        if meta_or_normal == 'meta' and not hconfig(ConfigEnum.sub_full_clash_meta_enable):
+            return 'The Clash meta subscription is disabled'
+        elif meta_or_normal == 'normal' and not hconfig(ConfigEnum.sub_full_clash_enable):
+            return 'The Clash subscription is disabled'
 
         c = get_common_data(g.account.uuid, mode)
 
@@ -192,7 +200,10 @@ class UserView(FlaskView):
 
     @ route('/full-singbox.json', methods=["GET", "HEAD"])
     @login_required(roles={Role.user})
-    def full_singbox(self):
+    def full_singbox_imp(self):
+        # if not hconfig(ConfigEnum.sub_full_singbox_enable):
+        #     return 'The Full Singbox subscription is disabled'
+
         mode = "new"  # request.args.get("mode")
         c = get_common_data(g.account.uuid, mode)
         # response.content_type = 'text/plain';
@@ -205,9 +216,12 @@ class UserView(FlaskView):
 
     @ route('/singbox.json', methods=["GET", "HEAD"])
     @login_required(roles={Role.user})
-    def singbox(self):
+    def singbox_ssh_imp(self):
         if not hconfig(ConfigEnum.ssh_server_enable):
-            return "SSH server is disable in settings"
+            return "The SSH server is disabled"
+        # elif not hconfig(ConfigEnum.sub_singbox_ssh_enable):
+        #     return "The Singbox: SSH subscription is disabled"
+
         mode = "new"  # request.args.get("mode")
         c = get_common_data(g.account.uuid, mode)
         # response.content_type = 'text/plain';
@@ -221,9 +235,15 @@ class UserView(FlaskView):
 
     @route('/all.txt', methods=["GET", "HEAD"])
     @login_required(roles={Role.user})
-    def all_configs(self, base64=False):
+    def links_imp(self, base64=False):
+        '''Returns subscription links (base64 or not)'''
         mode = "new"  # request.args.get("mode")
         base64 = base64 or request.args.get("base64", "").lower() == "true"
+        # if base64 and not hconfig(ConfigEnum.sub_full_links_b64_enable):
+        #     return 'The Subscription link b64 is disabled'
+        # if not base64 and not hconfig(ConfigEnum.sub_full_links_enable):
+        #     return 'The Subscription link is disabled'
+
         c = get_common_data(g.account.uuid, mode)
         # response.content_type = 'text/plain';
         if request.method == 'HEAD':
@@ -346,7 +366,7 @@ def get_common_data(user_uuid, mode, no_domain=False, filter_domain=None):
         'expire_rel': hutils.convert.format_timedelta(datetime.timedelta(days=expire_days)),
         'reset_day': reset_days,
         'hconfigs': get_hconfigs(),
-        'hdomains': get_hdomains(),
+        'hdomains': Domain.modes_and_domains(),
         'ConfigEnum': ConfigEnum,
         'link_maker': hutils.proxy,
         'domains': domains,

hiddifypanel/templates/admin-layout.html

@@ -85,13 +85,13 @@
           {{ render_nav_item('admin.Dashboard:index', icon('solid','house','nav-icon')+(_("Parent Panel") if hutils.node.is_parent() else _('admin.menu.home')),_use_li=True)}}
 
           {% if hutils.node.is_child() %}
-          {{ render_nav_item(hconfig(ConfigEnum.parent_panel)+"/"+g.account.uuid+"/admin/user/",icon('solid','user-secret','nav-icon')+_('admin.menu.user'),_badge=_('in parent panel') ,_use_li=True) }}
+          {{ render_nav_item(hconfig(ConfigEnum.parent_panel)+"admin/user/",icon('solid','user-secret','nav-icon')+_('admin.menu.user'),_badge=_('in parent panel') ,_use_li=True) }}
           {% else %}
           {{ render_nav_item('flask.user.index_view', icon('solid','user','nav-icon')+_('admin.menu.user'),_use_li=True)}}
           {% endif %}
 
           {% if hutils.node.is_child() %}
-          {{ render_nav_item(hconfig(ConfigEnum.parent_panel)+"/"+g.account.uuid+"/admin/adminuser/",icon('solid','user-secret','nav-icon')+_('Admins'),_badge=_('in parent panel') ,_use_li=True) }}
+          {{ render_nav_item(hconfig(ConfigEnum.parent_panel)+"admin/adminuser/",icon('solid','user-secret','nav-icon')+_('Admins'),_badge=_('in parent panel') ,_use_li=True) }}
           {% else %}
           {{ render_nav_item('flask.adminuser.index_view', icon('solid','user-secret','nav-icon')+_('Admins'),_use_li=True) }}
           {% endif %}