hiddifypanel 9.0.0.dev60__py3-none-any.whl → 9.0.0.dev61__py3-none-any.whl

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

@@ -4,6 +4,7 @@ from apiflask import Schema
 from apiflask.fields import Integer, String, Float, URL, Enum
 from flask import g, request
 from flask import current_app as app
+from hiddifypanel import hutils
 from hiddifypanel.panel.auth import login_required
 import hiddifypanel.panel.auth as auth
 from flask_babelex import gettext as _
@@ -55,11 +56,11 @@ class InfoAPI(MethodView):
         dto.profile_remaining_days = g.account.remaining_days()
         dto.profile_reset_days = g.account.days_to_reset()
         dto.telegram_bot_url = f"https://t.me/{c['bot'].username}?start={g.account.uuid}" if c['bot'] else ""
-        dto.telegram_id = c['user'].telegram_id or 0
+        dto.telegram_id = c['user'].telegram_id
 
         dto.doh = f"https://{request.host}/{g.proxy_path}/dns/dns-query"
         dto.lang = (c['user'].lang) or Lang(hconfig(ConfigEnum.lang))
-        dto.brand_icon_url = "" if hconfig(ConfigEnum.branding_title) else hiddify.static_url_for(filename="images/hiddify.png")
+        dto.brand_icon_url = "" if hconfig(ConfigEnum.branding_title) else hutils.flask.static_url_for(filename="images/hiddify.png")
         # with force_locale("fa"):
         dto.admin_message_html = hconfig(ConfigEnum.branding_freetext) or _("Join our Hiddify Telegram channel to get the latest updates on Hiddify.")
         if not hconfig(ConfigEnum.branding_freetext) and auth.admin_session_is_exist():
@@ -69,16 +70,11 @@ class InfoAPI(MethodView):
         return dto
 
     @app.input(UserInfoChangableSchema, arg_name='data')
-    def patch(self, data):
-        if data['telegram_id']:
-            try:
-                tg_id = int(data['telegram_id'])
-            except:
-                return {'message': 'The telegram id field is invalid'}
-
+    def patch(self, data: UserInfoChangableSchema):
+        if data['telegram_id'] and hutils.convert.is_int(data['telegram_id']):
             user = User.by_uuid(g.account.uuid)
-            if user.telegram_id != tg_id:
-                user.telegram_id = tg_id
+            if user.telegram_id != data['telegram_id']:
+                user.telegram_id = data['telegram_id']
                 db.session.commit()
 
         if data['language']:

hiddifypanel/panel/commercial/telegrambot/admin.py

@@ -1,3 +1,4 @@
+from hiddifypanel.panel import hiddify
 from . import bot
 
 from telebot import types

hiddifypanel/panel/common.py

@@ -6,11 +6,10 @@ from flask import g, send_from_directory, session
 from flask_babelex import gettext as _
 import hiddifypanel
 from hiddifypanel.models import *
-from hiddifypanel.panel import hiddify, github_issue_generator
-from sys import version as python_version
-from platform import platform
-import hiddifypanel.hutils as hutils
+from hiddifypanel.panel import hiddify
+from hiddifypanel import hutils
 import hiddifypanel.panel.auth as auth
+from hiddifypanel.panel.auth import current_account
 from apiflask import APIFlask, HTTPError, abort
 
 
@@ -48,7 +47,7 @@ def init_app(app: APIFlask):
         trace = traceback.format_exc()
 
         # Create github issue link
-        issue_link = generate_github_issue_link_for_500_error(e, trace)
+        issue_link = hutils.github_issue.generate_github_issue_link_for_500_error(e, trace)
 
         return render_template('500.html', error=e, trace=trace, has_update=has_update, last_version=last_version, issue_link=issue_link), 500
 
@@ -61,7 +60,7 @@ def init_app(app: APIFlask):
             trace = traceback.format_exc()
 
             # Create github issue link
-            issue_link = generate_github_issue_link_for_500_error(e, trace)
+            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__:
@@ -75,16 +74,6 @@ def init_app(app: APIFlask):
 
         return render_template('error.html', error=e), e.status_code
 
-    def generate_github_issue_link(title, issue_body):
-        opts = {
-            "user": 'hiddify',
-            "repo": 'Hiddify-Manager',
-            "title": title,
-            "body": issue_body,
-        }
-        issue_link = str(github_issue_generator.IssueUrl(opts).get_url())
-        return issue_link
-
     # @app.spec_processor
     # def set_default_path_values(spec):
     #     # for path in spec['paths'].values():
@@ -100,7 +89,7 @@ def init_app(app: APIFlask):
     @app.url_defaults
     def add_proxy_path_user(endpoint, values):
         if 'proxy_path' not in values:
-            if hasattr(g, 'account') and isinstance(g.account, AdminUser):
+            if hiddify.is_admin_role(g.account):
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
             # elif 'static' in endpoint:
                 #     values['proxy_path'] = hconfig(ConfigEnum.proxy_path)
@@ -144,7 +133,7 @@ def init_app(app: APIFlask):
     #     if user_agent.is_bot:
     #         abort(400, "invalid")
 
-    #     uuid = hutils.utils.get_uuid_from_url_path(request.path)
+    #     uuid = hutils.auth.get_uuid_from_url_path(request.path)
     #     account = User.by_uuid(uuid) or AdminUser.by_uuid(uuid) or abort(400, 'invalid request2')
 
     #     admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin)
@@ -161,7 +150,7 @@ def init_app(app: APIFlask):
     #     else:
     #         return abort(400, 'invalid request 1')
 
-    #     new_link = hutils.utils.add_basic_auth_to_url(new_link, account.username, account.password)
+    #     new_link = hutils.auth.add_basic_auth_to_url(new_link, account.username, account.password)
 
     #     if user_agent.browser:
     #         return render_template('redirect_to_new_format.html', new_link=new_link)
@@ -171,6 +160,7 @@ def init_app(app: APIFlask):
     #     return redirect(new_link, 302)
     @app.before_request
     def set_default_values():
+        g.account = current_account
         g.user_agent = hiddify.get_user_agent()
 
     @app.before_request
@@ -216,70 +206,4 @@ def init_app(app: APIFlask):
         else:
             g.bot = None
 
-    def github_issue_details():
-        details = {
-            'hiddify_version': f'{hiddifypanel.__version__}',
-            'python_version': f'{python_version}',
-            'os_details': f'{platform()}',
-            'user_agent': request.user_agent
-        }
-        return details
-
-    def generate_github_issue_link_for_500_error(error, traceback, remove_sensetive_data=True, remove_unrelated_traceback_datails=True):
-
-        def remove_sensetive_data_from_github_issue_link(issue_link):
-            if hasattr(g, 'account') and hasattr(g.account, 'uuid') and g.account.uuid:
-                issue_link.replace(f'{g.account.uuid}', '*******************')
-
-            issue_link.replace(request.host, '**********')
-            issue_link.replace(hconfig(ConfigEnum.proxy_path), '**********')
-            issue_link.replace(hconfig(ConfigEnum.proxy_path_admin), '**********')
-            issue_link.replace(hconfig(ConfigEnum.proxy_path_client), '**********')
-
-        def remove_unrelated_traceback_details(stacktrace: str):
-            lines = stacktrace.splitlines()
-            if len(lines) < 1:
-                return ""
-
-            output = ''
-            skip_next_line = False
-            for i, line in enumerate(lines):
-                if i == 0:
-                    output += line + '\n'
-                    continue
-                if skip_next_line == True:
-                    skip_next_line = False
-                    continue
-                if line.strip().startswith('File'):
-                    if 'hiddify' in line.lower():
-                        output += line + '\n'
-                        if len(lines) > i+1:
-                            output += lines[i + 1] + '\n'
-                    skip_next_line = True
-
-            return output
-
-        if remove_unrelated_traceback_datails:
-            traceback = remove_unrelated_traceback_details(traceback)
-
-        issue_details = github_issue_details()
-
-        issue_body = render_template('github_issue_body.j2', issue_details=issue_details, error=error, traceback=traceback)
-
-        # Create github issue link
-        issue_link = generate_github_issue_link(f"Internal server error: {error.name if hasattr(error,'name') and error.name != None and error.name else 'Unknown'}", issue_body)
-
-        if remove_sensetive_data:
-            remove_sensetive_data_from_github_issue_link(issue_link)
-
-        return issue_link
-
-    def generate_github_issue_link_for_admin_sidebar():
-
-        issue_body = render_template('github_issue_body.j2', issue_details=github_issue_details())
-
-        # Create github issue link
-        issue_link = generate_github_issue_link('Please fill the title properly', issue_body)
-        return issue_link
-
-    app.jinja_env.globals['generate_github_issue_link_for_admin_sidebar'] = generate_github_issue_link_for_admin_sidebar
+    app.jinja_env.globals['generate_github_issue_link_for_admin_sidebar'] = hutils.github_issue.generate_github_issue_link_for_admin_sidebar

hiddifypanel/panel/common_bp/login.py

@@ -1,4 +1,5 @@
 from flask_classful import FlaskView, route
+from hiddifypanel import hutils
 from hiddifypanel.panel.auth import login_required, current_account, login_user, logout_user, login_by_uuid
 from flask import redirect, request, g, url_for, render_template, flash, jsonify
 from flask import current_app as app
@@ -54,7 +55,7 @@ class LoginView(FlaskView):
             uuid = form.secret_textbox.data.strip()
             if login_by_uuid(uuid, hiddify.is_admin_proxy_path()):
                 return redirect(f'/{g.proxy_path}/')
-        flash(_('config.validation-error'), 'danger')
+        hutils.flask.flash(_('config.validation-error'), 'danger')  # type: ignore
         return render_template('login.html', form=LoginForm())
 
     @route("/l/")
@@ -66,10 +67,10 @@ class LoginView(FlaskView):
 
             loginurl = url_for('common_bp.LoginView:index', next=redirect_arg, user=username)
             if g.user_agent['is_browser'] and request.headers.get('Authorization') or (current_account and len(username) > 0 and current_account.username != username):
-                flash(_('Incorrect Password'), 'error')
+                hutils.flask.flash(_('Incorrect Password'), 'error')  # type: ignore
                 logout_user()
-                g.account = None
-                # flash(request.authorization.username, 'error')
+                g.__account_store = None
+                # hutils.flask.flash(request.authorization.username, 'error')
                 return redirect(loginurl)
 
             return render_template("redirect.html", url=loginurl), 401
@@ -90,13 +91,13 @@ class LoginView(FlaskView):
 
     # def uuid(self, uuid, path=''):
     #     proxy_path = hiddify.get_proxy_path_from_url(request.url)
-    #     g.account = None
+    #     g.__account_store = None
     #     uuid = str(uuid)
     #     if proxy_path == hconfig(ConfigEnum.proxy_path_client):
-    #         g.account = User.by_uuid(uuid)
+    #         g.__account_store = User.by_uuid(uuid)
     #         path = f'client/{path}'
     #     elif proxy_path == hconfig(ConfigEnum.proxy_path_admin):
-    #         g.account = AdminUser.by_uuid(uuid)
+    #         g.__account_store = AdminUser.by_uuid(uuid)
     #     if not g.account:
     #         abort(403)
     #     if not g.user_agent['is_browser'] and proxy_path == hconfig(ConfigEnum.proxy_path_client):
@@ -134,7 +135,7 @@ class LoginView(FlaskView):
             "orientation": "any",
             "icons": [
                 {
-                    "src": hiddify.static_url_for(filename='images/hiddify-dark.png'),
+                    "src": hutils.flask.static_url_for(filename='images/hiddify-dark.png'),
                     "sizes": "512x512",
                     "type": "image/png",
                     "purpose": "maskable any"

hiddifypanel/panel/database.py

@@ -6,7 +6,8 @@ import re
 import os
 
 db = SQLAlchemy()
-db.UUID = UUIDType
+db.UUID = UUIDType  # type: ignore
+
 
 def init_app(app):
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
@@ -14,23 +15,23 @@ def init_app(app):
 
     # db.create_all(app)
     # app.jinja_env.globals['get_locale'] = get_locale
-def init_migration(app):
-    migrate = flask_migrate.Migrate(app,db)
-    if os.path.isdir(migrate.directory):
-        return
-    flask_migrate.init()
-def migrate():
-    try_again = False
-    try:
-        # run flask_migrate.migrate function without its decorator to catch function error in try statement
-        flask_migrate.migrate.__wrapped__()
-    except Exception as err:
-        err_str = str(err)
-        if err_str == 'Target database is not up to date.':
-            flask_migrate.stamp()
-        elif err_str.startswith("Can't locate revision identified by"):
-            rev_id = re.findall(" '(.*)'$",err_str)[0].replace("'","'").strip()
-            flask_migrate.revision(rev_id=rev_id)
-    finally:
-        if try_again:
-            flask_migrate.migrate()
+# def init_migration(app):
+#     migrate = flask_migrate.Migrate(app,db)
+#     if os.path.isdir(migrate.directory):
+#         return
+#     flask_migrate.init()
+# def migrate():
+#     try_again = False
+#     try:
+#         # run flask_migrate.migrate function without its decorator to catch function error in try statement
+#         flask_migrate.migrate.__wrapped__()
+#     except Exception as err:
+#         err_str = str(err)
+#         if err_str == 'Target database is not up to date.':
+#             flask_migrate.stamp()
+#         elif err_str.startswith("Can't locate revision identified by"):
+#             rev_id = re.findall(" '(.*)'$",err_str)[0].replace("'","'").strip()
+#             flask_migrate.revision(rev_id=rev_id)
+#     finally:
+#         if try_again:
+#             flask_migrate.migrate()

hiddifypanel/panel/hiddify.py

@@ -1,18 +1,22 @@
 import glob
+import random
+import socket
+import ssl
+import time
 import uuid
 import user_agents
 import json
 import subprocess
 import psutil
+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, jsonify, request
+from flask import current_app, g, request, Markup  # type: ignore
 from flask_babelex import gettext as __
 from flask_babelex import lazy_gettext as _
 from wtforms.validators import ValidationError
 from apiflask import abort as apiflask_abort
-from apiflask import abort
 
 from datetime import timedelta
 from babel.dates import format_timedelta as babel_format_timedelta
@@ -57,7 +61,7 @@ def add_short_link_imp(link: str, period_min: int = 5) -> Tuple[str, datetime]:
             if link in line:
                 return re.search(pattern, line).group(1), datetime.now() + timedelta(minutes=period_min)
 
-    short_code = get_random_string(6, 10).lower()
+    short_code = hutils.random.get_random_string(6, 10).lower()
     # exec_command(
     #     f'sudo /opt/hiddify-manager/nginx/add2shortlink.sh {link} {short_code} {period_min} &')
 
@@ -172,6 +176,8 @@ def is_login_call() -> bool:
 
 
 def is_admin_role(role: Role):
+    if not role:
+        return False
     if role in {Role.super_admin, Role.admin, Role.agent}:
         return True
     return False
@@ -202,18 +208,18 @@ def proxy_path_validator(proxy_path):
         return
 
     if proxy_path not in [admin_proxy_path, deprecated_path, client_proxy_path]:
-        abort(400, 'invalid request')
+        apiflask_abort(400, 'invalid request')
 
     if is_admin_panel_call() and proxy_path != admin_proxy_path:
-        abort(400, 'invalid request')
+        apiflask_abort(400, 'invalid request')
     if is_user_panel_call() and proxy_path != client_proxy_path:
-        abort(400, 'invalid request')
+        apiflask_abort(400, 'invalid request')
 
     if is_api_call(request.path):
         if is_admin_api_call() and proxy_path != admin_proxy_path:
-            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{admin_proxy_path}/admin>Admin Panel</a>")) if dbg_mode else abort(400, 'invalid request')
+            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{admin_proxy_path}/admin>Admin Panel</a>")) if dbg_mode else apiflask_abort(400, 'invalid request')
         if is_user_api_call() and proxy_path != client_proxy_path:
-            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{client_proxy_path}/admin>User Panel</a>")) if dbg_mode else abort(400, 'invalid request')
+            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{client_proxy_path}/admin>User Panel</a>")) if dbg_mode else apiflask_abort(400, 'invalid request')
 
 
 def asset_url(path) -> str:
@@ -271,17 +277,6 @@ def quick_apply_users():
     return {"status": 'success'}
 
 
-def flash_config_success(restart_mode='', domain_changed=True):
-    if restart_mode:
-        url = url_for('admin.Actions:reinstall', complete_install=restart_mode ==
-                      'reinstall', domain_changed=domain_changed)
-        apply_btn = f"<a href='{url}' class='btn btn-primary form_post'>" + \
-            _("admin.config.apply_configs")+"</a>"
-        flash((_('config.validation-success', link=apply_btn)), 'success')
-    else:
-        flash((_('config.validation-success-no-reset')), 'success')
-
-
 # Importing socket library
 
 # Function to display hostname and
@@ -333,7 +328,7 @@ def get_html_user_link(model: BaseAccount, domain: Domain):
     res = ""
     d = domain.domain
     if "*" in d:
-        d = d.replace("*", get_random_string(5, 15))
+        d = d.replace("*", hutils.random.get_random_string(5, 15))
 
     link = get_account_panel_link(model, d)+f"#{model.name}"
 
@@ -380,7 +375,7 @@ def check_need_reset(old_configs, do=False):
     if old_configs[ConfigEnum.package_mode] != hconfig(ConfigEnum.package_mode):
         return reinstall_action(do_update=True)
     if not (do and restart_mode == 'reinstall'):
-        return flash_config_success(restart_mode=restart_mode, domain_changed=False)
+        return hutils.flask.flash_config_success(restart_mode=restart_mode, domain_changed=False)
 
     return reinstall_action(complete_install=True, domain_changed=domain_changed)
 
@@ -649,9 +644,12 @@ def get_random_domains(count=1, retry=3):
             return random.sample(defdomains, count)
         return get_random_domains(count, retry-1)
 
+# not used
+
 
 def is_domain_support_tls_13(domain):
     context = ssl.create_default_context()
+    port = 433
     with socket.create_connection((domain, port)) as sock:
         with context.wrap_socket(sock, server_hostname=domain) as ssock:
             return ssock.version() == "TLSv1.3"
@@ -694,8 +692,8 @@ def debug_flash_if_not_in_the_same_asn(domain):
             # country_ipv4= ipcountry.get(ipv4)
             # country_dip= ipcountry.get(dip)
             if asn_ipv4.get('autonomous_system_organization') != asn_dip.get('autonomous_system_organization'):
-                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")
+                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:
         pass
 
@@ -789,10 +787,10 @@ def get_ed25519_private_public_pair():
     return priv_bytes.decode(), pub_bytes.decode()
 
 
-def do_base_64(str):
-    import base64
-    resp = base64.b64encode(f'{str}'.encode("utf-8"))
-    return resp.decode()
+# def do_base_64(str):
+#     import base64
+#     resp = base64.b64encode(f'{str}'.encode("utf-8"))
+#     return resp.decode()
 
 
 def get_user_agent():
@@ -855,7 +853,6 @@ def __parse_user_agent(ua):
 
 def is_ssh_password_authentication_enabled():
     if os.path.isfile('/etc/ssh/sshd_config'):
-        content = ''
         with open('/etc/ssh/sshd_config', 'r') as f:
             for line in f.readlines():
                 line = line.strip()

hiddifypanel/panel/importer/xui.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Tuple
 import uuid as uuid_mod
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
-import hiddifypanel.hutils.utils as utils
+from hiddifypanel import hutils
 from hiddifypanel.models.admin import AdminUser
 from hiddifypanel.models.user import User, UserMode
 from hiddifypanel.models.domain import Domain, DomainType
@@ -63,7 +63,7 @@ def __get_users(db, x_ui_inbounds):
 def __create_hiddify_user_from_xui_values(id: str, values: Dict[str, Any]) -> User:
     user = User()
     user.name = values['name']
-    user.uuid = id if utils.is_uuid_valid(id, 4) else uuid_mod.uuid4()
+    user.uuid = id if hutils.auth.is_uuid_valid(id, 4) else uuid_mod.uuid4()
 
     if str(values['expiry_time']) == '0':
         user.expiry_time = datetime.now() + relativedelta(years=10)

hiddifypanel/panel/init_db.py

@@ -12,7 +12,7 @@ from hiddifypanel import Events, hutils
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
 from hiddifypanel.panel.database import db
-from hiddifypanel.panel.hiddify import get_random_domains, get_random_string
+from hiddifypanel.panel.hiddify import get_random_domains
 import hiddifypanel.models.utils as model_utils
 
 MAX_DB_VERSION = 70
@@ -26,7 +26,12 @@ def init_db():
     hconfig.invalidate_all()
     get_hconfigs.invalidate_all()
     db_version = int(hconfig(ConfigEnum.db_version) or 0)
+    if db_version == latest_db_version():
+        return
+    execute("alter table user alter column telegram_id int;")
+    execute("alter table admin_user alter column telegram_id int;")
     add_column(User.lang)
+    add_column(AdminUser.lang)
     add_column(User.username)
     add_column(User.password)
     add_column(AdminUser.username)
@@ -34,8 +39,6 @@ def init_db():
 
     add_column(Domain.extra_params)
 
-    if db_version == latest_db_version():
-        return
     Events.db_prehook.notify()
     if db_version < 52:
         execute(f'update domain set mode="sub_link_only", sub_link_only=false where sub_link_only = true or mode=1  or mode="1"')
@@ -148,6 +151,10 @@ def init_db():
 #     add_config_if_not_exist(ConfigEnum.hysteria_enable, True)
 #     add_config_if_not_exist(ConfigEnum.hysteria_port, random.randint(5000, 20000))
 
+def _v67():
+    pass
+
+
 def _v65():
     add_config_if_not_exist(ConfigEnum.mux_enable, False)
     add_config_if_not_exist(ConfigEnum.mux_protocol, 'smux')
@@ -187,8 +194,8 @@ def _v61():
 
 
 def _v60():
-    add_config_if_not_exist(ConfigEnum.proxy_path_admin, get_random_string())
-    add_config_if_not_exist(ConfigEnum.proxy_path_client, get_random_string())
+    add_config_if_not_exist(ConfigEnum.proxy_path_admin, hutils.random.get_random_string())
+    add_config_if_not_exist(ConfigEnum.proxy_path_client, hutils.random.get_random_string())
 
 
 def _v59():
@@ -354,13 +361,13 @@ def _v20():
 
 
 def _v19():
-    set_hconfig(ConfigEnum.path_trojan, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_vless, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_vmess, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_ss, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_grpc, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_tcp, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_ws, get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_trojan, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_vless, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_vmess, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_ss, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_grpc, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_tcp, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_ws, hutils.random.get_random_string(7, 15))
     add_config_if_not_exist(ConfigEnum.tuic_enable, False)
     add_config_if_not_exist(ConfigEnum.shadowtls_enable, False)
     add_config_if_not_exist(ConfigEnum.shadowtls_fakedomain, "en.wikipedia.org")
@@ -395,7 +402,7 @@ def _v1():
         StrConfig(key=ConfigEnum.tls_ports, value="443"),
         BoolConfig(key=ConfigEnum.first_setup, value=True),
         StrConfig(key=ConfigEnum.decoy_domain, value=hiddify.get_random_decoy_domain()),
-        StrConfig(key=ConfigEnum.proxy_path, value=get_random_string()),
+        StrConfig(key=ConfigEnum.proxy_path, value=hutils.random.get_random_string()),
         BoolConfig(key=ConfigEnum.firewall, value=False),
         BoolConfig(key=ConfigEnum.netdata, value=True),
         StrConfig(key=ConfigEnum.lang, value='en'),

hiddifypanel/panel/usage.py

@@ -19,6 +19,7 @@ def update_local_usage():
 
 
 def add_users_usage_uuid(uuids_bytes, child_id):
+    # WHAT IS THE "keys" function WHY ?????
     users = User.query.filter(User.uuid.in_(keys(uuids_bytes)))
     dbusers_bytes = {u: uuids_bytes.get(u.uuid, 0) for u in users}
     add_users_usage(dbusers_bytes, child_id)
@@ -100,6 +101,6 @@ def send_bot_message(user):
     try:
         msg = Usage.get_usage_msg(user.uuid)
         msg = _("User activated!") if user.is_active else _("Package ended!")+"\n"+msg
-        bot.send_message(user.telegram_id, msg, reply_markup=Usage.user_keyboard(uuid))
+        bot.send_message(user.telegram_id, msg, reply_markup=Usage.user_keyboard(user.uuid))
     except:
         pass