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

hiddifypanel/models/admin.py

@@ -7,7 +7,7 @@ from strenum import StrEnum
 from apiflask import abort
 from flask_babelex import gettext as __
 from flask_babelex import lazy_gettext as _
-
+from hiddifypanel.models.role import Role
 from hiddifypanel.panel.database import db
 from .base_account import BaseAccount
 
@@ -38,13 +38,58 @@ class AdminUser(BaseAccount):
     usages = db.relationship('DailyUsage', backref='admin')
     parent_admin_id = db.Column(db.Integer, db.ForeignKey('admin_user.id'), default=1)
     parent_admin = db.relationship('AdminUser', remote_side=[id], backref='sub_admins')
-    # These columns are created by BaseAccount
-    # uuid = db.Column(db.String(36), default=lambda: str(uuid_mod.uuid4()), nullable=False, unique=True)
-    # name = db.Column(db.String(512), nullable=False)
-    # username = db.Column(db.String(16), nullable=True, default='')
-    # password = db.Column(db.String(16), nullable=True, default='')
-    # comment = db.Column(db.String(512))
-    # telegram_id = db.Column(db.String(512))
+
+    @property
+    def role(self) -> Role | None:
+        match self.mode:
+            case AdminMode.super_admin:
+                return Role.super_admin
+            case AdminMode.admin:
+                return Role.admin
+            case AdminMode.agent:
+                return Role.agent
+        return None
+
+    def get_id(self) -> str | None:
+        return f'admin_{self.id}'
+
+    def to_dict(self, convert_date=True) -> dict:
+        base = super().to_dict()
+        return {**base,
+                'mode': self.mode,
+                'can_add_admin': self.can_add_admin,
+                'parent_admin_uuid': self.parent_admin.uuid if self.parent_admin else None,
+                }
+
+    @classmethod
+    def by_uuid(cls, uuid: str, create: bool = False):
+        account = AdminUser.query.filter(AdminUser.uuid == uuid).first()
+        if not account and create:
+            dbuser = AdminUser(uuid=uuid, name="unknown", parent_admin_id=AdminUser.current_admin_or_owner().id)
+            db.session.add(dbuser)
+            db.session.commit()
+            account = AdminUser.by_uuid(uuid, False)
+
+        return account
+
+    @classmethod
+    def add_or_update(cls, commit: bool = True, **data):
+
+        dbuser = super().add_or_update(commit=commit, **data)
+
+        if dbuser.id != 1:
+            parent = data.get('parent_admin_uuid')
+            if parent == data['uuid'] or not parent:
+                parent_admin = cls.current_admin_or_owner()
+            else:
+                parent_admin = cls.by_uuid(parent, create=True)
+            dbuser.parent_admin_id = parent_admin.id  # type: ignore
+
+        dbuser.mode = data.get('mode', AdminMode.agent)
+        dbuser.can_add_admin = data.get('can_add_admin') == True
+        if commit:
+            db.session.commit()
+        return dbuser
 
     def recursive_users_query(self):
         from .user import User

hiddifypanel/models/base_account.py

@@ -2,10 +2,10 @@ import datetime
 import uuid as uuid_mod
 from hiddifypanel import hutils
 from hiddifypanel.models.role import Role
-from sqlalchemy import Column, String
+from sqlalchemy import Column, String, BigInteger, Integer
 from sqlalchemy_serializer import SerializerMixin
 from flask_login import UserMixin as FlaskLoginUserMixin
-
+from hiddifypanel.models import Lang
 from hiddifypanel.panel.database import db
 
 
@@ -16,77 +16,31 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
     username = Column(String(100), nullable=True, default='')
     password = Column(String(100), nullable=True, default='')
     comment = Column(String(512), nullable=True, default='')
-    telegram_id = Column(String(512), nullable=True, default='')
+    telegram_id = Column(BigInteger, nullable=True, default='')
+    lang = db.Column(db.Enum(Lang), default=None)
 
     @property
     def role(self) -> Role | None:
-        from hiddifypanel.models.user import User
-        from hiddifypanel.models.admin import AdminUser, AdminMode
-        if isinstance(self, AdminUser):
-            match self.mode:
-                case AdminMode.super_admin:
-                    return Role.super_admin
-                case AdminMode.admin:
-                    return Role.admin
-                case AdminMode.agent:
-                    return Role.agent
-        if isinstance(self, User):
-            return Role.user
+        return None
 
     def get_id(self) -> str | None:
-        """
-        Get the ID of the account. (*only for flask_login)
-        """
-        from hiddifypanel.models.user import User
-        from hiddifypanel.models.admin import AdminUser
-        if isinstance(self, AdminUser):
-            return f'admin_{self.id}'
-        if isinstance(self, User):
-            return f'user_{self.id}'
+        return '{self.__class__.name}_{self.id if self.hasattr("id") else "-"}'
 
     def is_username_unique(self) -> bool:
-        from hiddifypanel.models.user import User
-        from hiddifypanel.models.admin import AdminUser
-
-        model = None
-        if isinstance(self, AdminUser):
-            model = AdminUser.query.filter(AdminUser.username == self.username).first()
-        else:
-            model = User.query.filter(User.username == self.username).first()
-
-        if model and model.id != self.id:
+        cls = self.__class__()
+        model = cls.query.filter(cls.username == self.username, cls.id != self.id).first()
+        if model:
             return False
         return True
 
     def to_dict(self, convert_date=True) -> dict:
-        from hiddifypanel.models.admin import AdminUser
-        if isinstance(self, AdminUser):
-            return {
-                'name': self.name,
-                'comment': self.comment,
-                'uuid': self.uuid,
-                'mode': self.mode,
-                'can_add_admin': self.can_add_admin,
-                'parent_admin_uuid': self.parent_admin.uuid if self.parent_admin else None,
-                'telegram_id': hutils.utils.convert_to_int(self.telegram_id),
-            }
-        else:
-            return {
-                'uuid': self.uuid,
-                'name': self.name,
-                'last_online': hutils.utils.time_to_json(self.last_online) if convert_date else self.last_online,
-                'usage_limit_GB': self.usage_limit_GB,
-                'package_days': self.package_days,
-                'mode': self.mode,
-                'start_date': hutils.utils.date_to_json(self.start_date)if convert_date else self.start_date,
-                'current_usage_GB': self.current_usage_GB,
-                'last_reset_time': hutils.utils.date_to_json(self.last_reset_time) if convert_date else self.last_reset_time,
-                'comment': self.comment,
-                'added_by_uuid': self.admin.uuid,
-                'telegram_id': hutils.utils.convert_to_int(self.telegram_id),
-                'ed25519_private_key': self.ed25519_private_key,
-                'ed25519_public_key': self.ed25519_public_key
-            }
+        return {
+            'name': self.name,
+            'comment': self.comment,
+            'uuid': self.uuid,
+            'telegram_id': self.telegram_id,
+            'lang': self.lang
+        }
 
     @classmethod
     def by_id(cls, id: int):
@@ -94,24 +48,9 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
 
     @classmethod
     def by_uuid(cls, uuid: str, create: bool = False):
-        from hiddifypanel.models.user import User
-        from hiddifypanel.models.admin import AdminUser
-        account = None
-        if cls.__subclasscheck__(User) or cls.__subclasscheck__(AdminUser):
-            account = cls.query.filter(cls.uuid == uuid).first()
-
+        account = cls.query.filter(cls.uuid == uuid).first()
         if not account and create:
-            if cls.__subclasscheck__(User):
-                dbuser = User(uuid=uuid, name="unknown", added_by=AdminUser.current_admin_or_owner().id)
-                db.session.add(dbuser)
-                db.session.commit()
-                account = cls.by_uuid(uuid)
-            elif cls.__subclasscheck__(AdminUser):
-                dbuser = AdminUser(uuid=uuid, name="unknown", parent_admin_id=cls.current_admin_or_owner().id)
-                db.session.add(dbuser)
-                db.session.commit()
-                account = cls.by_uuid(uuid)  # AdminUser.query.filter(AdminUser.uuid == uuid).first()
-
+            raise NotImplementedError
         return account
 
     @classmethod
@@ -120,100 +59,23 @@ class BaseAccount(db.Model, SerializerMixin, FlaskLoginUserMixin):  # type: igno
 
     @classmethod
     def add_or_update(cls, commit: bool = True, **data):
-        from hiddifypanel.models.user import User, UserMode
-        from hiddifypanel.models.admin import AdminUser, AdminMode
-
-        dbuser: AdminUser | User = None  # type: ignore
-        if cls.__subclasscheck__(User):
-            dbuser = User.by_uuid(data['uuid'], create=True)
-
-            if data.get('added_by_uuid'):
-                admin = AdminUser.by_uuid(data.get('added_by_uuid'), create=True)  # type: ignore
-                dbuser.added_by = admin.id  # type: ignore
-            else:
-                dbuser.added_by = 1
-
-            if data.get('expiry_time', ''):
-                last_reset_time = hutils.utils.json_to_date(data.get('last_reset_time', '')) or datetime.date.today()
-
-                expiry_time = hutils.utils.json_to_date(data['expiry_time'])
-                dbuser.start_date = last_reset_time
-                dbuser.package_days = (expiry_time-last_reset_time).days  # type: ignore
-
-            elif 'package_days' in data:
-                dbuser.package_days = data['package_days']
-                if data.get('start_date', ''):
-                    dbuser.start_date = hutils.utils.json_to_date(data['start_date'])
-                else:
-                    dbuser.start_date = None
-            dbuser.current_usage_GB = data['current_usage_GB']
-
-            dbuser.usage_limit_GB = data['usage_limit_GB']
-            dbuser.name = data.get('name') or ''
-            dbuser.comment = data.get('comment', '')
-            dbuser.enable = data.get('enable', True)
-            if data.get('ed25519_private_key', ''):
-                dbuser.ed25519_private_key = data.get('ed25519_private_key', '')
-                dbuser.ed25519_public_key = data.get('ed25519_public_key', '')
-            if not dbuser.ed25519_private_key:
-                from hiddifypanel.panel import hiddify
-                priv, publ = hiddify.get_ed25519_private_public_pair()
-                dbuser.ed25519_private_key = priv
-                dbuser.ed25519_public_key = publ
-
-            mode = data.get('mode', UserMode.no_reset)
-            if mode == 'disable':
-                mode = UserMode.no_reset
-                dbuser.enable = False
-
-            dbuser.mode = mode
-
-            dbuser.telegram_id = data.get('telegram_id') or 0
-
-            dbuser.last_online = hutils.utils.json_to_time(data.get('last_online')) or datetime.datetime.min
-        elif cls.__subclasscheck__(AdminUser):
-            # if not is_valid():return
-            dbuser = cls.by_uuid(data['uuid'])  # type: ignore
-
-            if not dbuser:
-                dbuser = AdminUser(uuid=data['uuid'])
-                # if not is_valid():
-                #     return
-                db.session.add(dbuser)
-            dbuser.name = data['name']
-            if dbuser.id != 1:
-                parent = data.get('parent_admin_uuid')
-                if parent == data['uuid'] or not parent:
-                    parent_admin = cls.current_admin_or_owner()
-                else:
-                    parent_admin = cls.by_uuid(parent, create=True)
-                dbuser.parent_admin_id = parent_admin.id  # type: ignore
-
-            dbuser.comment = data.get('comment', '')
-            dbuser.mode = data.get('mode', AdminMode.agent)
-            dbuser.telegram_id = data.get('telegram_id')
-            dbuser.can_add_admin = data.get('can_add_admin') == True
-
-            # dbuser.last_online=user.get('last_online','')
-
+        db_account = cls.by_uuid(data['uuid'], create=True)
+        db_account.name = data.get('name') or ''
+        db_account.comment = data.get('comment', '')
+        db_account.telegram_id = hutils.convert.to_int(data.get('telegram_id'))
+        db_account.lang = data.get('lang')
         if commit:
             db.session.commit()
-        return dbuser
+        return db_account
 
     @classmethod
     def bulk_register(cls, accounts: list = [], commit: bool = True, remove: bool = False):
-        from hiddifypanel.models.user import User
-        from hiddifypanel.models.admin import AdminUser
-        if cls.__subclasscheck__(User):
-            for u in accounts:
-                cls.add_or_update(commit=False, **u)
-            if remove:
-                dd = {u['uuid']: 1 for u in accounts}
-                for d in cls.query.all():
-                    if d.uuid not in dd:
-                        db.session.delete(d)
-        elif cls.__subclasscheck__(AdminUser):
-            for u in accounts:
-                cls.add_or_update(commit=False, **u)
+        for u in accounts:
+            cls.add_or_update(commit=False, **u)
+        if remove:
+            dd = {u['uuid']: 1 for u in accounts}
+            for d in cls.query.all():
+                if d.uuid not in dd:
+                    db.session.delete(d)
         if commit:
             db.session.commit()

hiddifypanel/models/config_enum.py

@@ -20,6 +20,7 @@ class ConfigCategory(StrEnum):
     telegram = auto()
     http = auto()
     tls = auto()
+    mux = auto()
     tls_trick = auto()
     ssh = auto()
     ssfaketls = auto()
@@ -81,6 +82,17 @@ class ConfigEnum(StrEnum):
     tls_padding_enable = auto()
     tls_padding_length = auto()
 
+    # mux
+    mux_enable = auto()
+    mux_protocol = auto()
+    mux_max_connections = auto()
+    mux_min_streams = auto()
+    mux_max_streams = auto()
+    mux_padding_enable = auto()
+    mux_brutal_enable = auto()
+    mux_brutal_up_mbps = auto()
+    mux_brutal_down_mbps = auto()
+
     http_ports = auto()
     kcp_ports = auto()
     kcp_enable = auto()
@@ -219,6 +231,16 @@ class ConfigEnum(StrEnum):
             self.tls_padding_enable: {'category': ConfigCategory.tls_trick, 'apply_mode': 'apply', 'type': bool},
             self.tls_padding_length: {'category': ConfigCategory.tls_trick, 'apply_mode': 'apply'},
 
+            # mux
+            self.mux_enable: {'category': ConfigCategory.mux, 'apply_mode': 'apply', 'type': bool},
+            self.mux_protocol: {'category': ConfigCategory.mux, 'apply_mode': 'apply'},
+            self.mux_max_connections: {'category': ConfigCategory.mux, 'apply_mode': 'apply'},
+            self.mux_min_streams: {'category': ConfigCategory.mux, 'apply_mode': 'apply'},
+            self.mux_max_streams: {'category': ConfigCategory.mux, 'apply_mode': 'apply'},
+            self.mux_padding_enable: {'category': ConfigCategory.mux, 'apply_mode': 'apply', 'type': bool},
+            self.mux_brutal_enable: {'category': ConfigCategory.mux, 'apply_mode': 'apply', 'type': bool},
+            self.mux_brutal_up_mbps: {'category': ConfigCategory.mux, 'apply_mode': 'apply'},
+            self.mux_brutal_down_mbps: {'category': ConfigCategory.mux, 'apply_mode': 'apply'},
 
             self.http_ports: {'category': ConfigCategory.http, 'apply_mode': 'apply'},  # http
             self.kcp_ports: {'category': ConfigCategory.hidden, 'apply_mode': 'apply'},
@@ -257,7 +279,7 @@ class ConfigEnum(StrEnum):
             self.tuic_port: {'category': ConfigCategory.hidden, 'apply_mode': 'apply'},
 
             self.hysteria_enable: {'category': ConfigCategory.hidden, 'type': bool, 'apply_mode': 'apply'},
-            self.hysteria_port: {'category': ConfigCategory.hysteria, 'apply_mode': 'apply'},
+            self.hysteria_port: {'category': ConfigCategory.hidden, 'apply_mode': 'apply'},
             self.hysteria_obfs_enable: {'category': ConfigCategory.hysteria, 'type': bool, 'apply_mode': 'apply'},
             self.hysteria_up_mbps: {'category': ConfigCategory.hysteria, 'apply_mode': 'apply'},
             self.hysteria_down_mbps: {'category': ConfigCategory.hysteria, 'apply_mode': 'apply'},

hiddifypanel/models/domain.py

@@ -1,7 +1,7 @@
 from enum import auto
 from urllib.parse import urlparse
 
-from flask import flash, request
+from flask import request
 from sqlalchemy_serializer import SerializerMixin
 from strenum import StrEnum
 
@@ -162,7 +162,7 @@ def get_proxy_domains_db(db_domain):
         domain = urlparse(request.base_url).hostname
         db_domain = Domain(domain=domain, mode=DomainType.direct, show_domains=[])
         # print("no domain")
-        flash(_("This domain does not exist in the panel!" + domain))
+        hutils.flask.flash(_("This domain does not exist in the panel!" + domain)) #type: ignore
 
     return db_domain.show_domains or Domain.query.all()
 

hiddifypanel/models/parent_domain.py

@@ -1,3 +1,4 @@
+from hiddifypanel.models.domain import Domain
 from sqlalchemy.orm import backref
 from sqlalchemy_serializer import SerializerMixin
 

hiddifypanel/models/user.py

@@ -1,6 +1,6 @@
 import datetime
 from enum import auto
-
+from hiddifypanel.models.role import Role
 from dateutil import relativedelta
 from sqlalchemy_serializer import SerializerMixin
 from strenum import StrEnum
@@ -10,7 +10,8 @@ from hiddifypanel.panel.database import db
 from hiddifypanel.models import Lang
 from hiddifypanel.models.utils import fill_password, fill_username
 from .base_account import BaseAccount
-
+from .admin import AdminUser
+from hiddifypanel import hutils
 ONE_GIG = 1024*1024*1024
 
 
@@ -26,6 +27,7 @@ class UserMode(StrEnum):
     weekly = auto()
     daily = auto()
 
+
     # disable = auto()
 package_mode_dic = {
     UserMode.daily: 1,
@@ -75,16 +77,15 @@ class User(BaseAccount):
     max_ips = db.Column(db.Integer, default=1000, nullable=False)
     details = db.relationship('UserDetail', cascade="all,delete", backref='user',    lazy='dynamic',)
     enable = db.Column(db.Boolean, default=True, nullable=False)
-    lang = db.Column(db.Enum(Lang), default=None)
     ed25519_private_key = db.Column(db.String(500))
     ed25519_public_key = db.Column(db.String(100))
-    # These columns are created by BaseAccount
-    # uuid = db.Column(db.String(36), default=lambda: str(uuid_mod.uuid4()), nullable=False, unique=True)
-    # name = db.Column(db.String(512), nullable=False, default='')
-    # username = db.Column(db.String(16), nullable=True, default='')
-    # password = db.Column(db.String(16), nullable=True, default='')
-    # comment = db.Column(db.String(512))
-    # telegram_id = db.Column(db.String(512))
+
+    @property
+    def role(self) -> Role | None:
+        return Role.user
+
+    def get_id(self) -> str | None:
+        return f'user_{self.id}'
 
     @property
     def current_usage_GB(self):
@@ -176,26 +177,99 @@ class User(BaseAccount):
             res = self.package_days
         return min(res, 10000)
 
-    @staticmethod
-    def from_dict(data):
-        """
-        Returns a new User object created from a dictionary.
-        """
-
-        return User(
-            name=data.get('name', ''),
-            expiry_time=data.get('expiry_time', datetime.date.today() + relativedelta.relativedelta(months=6)),
-            usage_limit_GB=data.get('usage_limit_GB', 1000),
-            package_days=data.get('package_days', 90),
-            mode=UserMode[data.get('mode', 'no_reset')],
-            monthly=data.get('monthly', False),
-            start_date=data.get('start_date', None),
-            current_usage_GB=data.get('current_usage_GB', 0),
-            last_reset_time=data.get('last_reset_time', datetime.date.today()),
-            comment=data.get('comment', None),
-            telegram_id=data.get('telegram_id', None),
-            added_by=data.get('added_by', 1)
-        )
+    @classmethod
+    def by_uuid(cls, uuid: str, create: bool = False):
+        account = User.query.filter(User.uuid == uuid).first()
+        if not account and create:
+            dbuser = User(uuid=uuid, name="unknown", added_by=AdminUser.current_admin_or_owner().id)
+            db.session.add(dbuser)
+            db.session.commit()
+            account = User.by_uuid(uuid, False)
+        return account
+
+    @classmethod
+    def add_or_update(cls, commit: bool = True, **data):
+
+        dbuser = super().add_or_update(commit=commit, **data)
+        if data.get('added_by_uuid'):
+            admin = AdminUser.by_uuid(data.get('added_by_uuid'), create=True) or AdminUser.current_admin_or_owner()
+            dbuser.added_by = admin.id
+        else:
+            dbuser.added_by = 1
+
+        if data.get('expiry_time', ''):
+            last_reset_time = hutils.json.json_to_date(data.get('last_reset_time', '')) or datetime.date.today()
+
+            expiry_time = hutils.json.json_to_date(data['expiry_time'])
+            dbuser.start_date = last_reset_time
+            dbuser.package_days = (expiry_time-last_reset_time).days  # type: ignore
+
+        elif 'package_days' in data:
+            dbuser.package_days = data['package_days']
+            if data.get('start_date', ''):
+                dbuser.start_date = hutils.json.json_to_date(data['start_date'])
+            else:
+                dbuser.start_date = None
+        dbuser.current_usage_GB = data['current_usage_GB']
+
+        dbuser.usage_limit_GB = data['usage_limit_GB']
+        dbuser.enable = data.get('enable', True)
+        if data.get('ed25519_private_key', ''):
+            dbuser.ed25519_private_key = data.get('ed25519_private_key', '')
+            dbuser.ed25519_public_key = data.get('ed25519_public_key', '')
+        if not dbuser.ed25519_private_key:
+            from hiddifypanel.panel import hiddify
+            priv, publ = hiddify.get_ed25519_private_public_pair()
+            dbuser.ed25519_private_key = priv
+            dbuser.ed25519_public_key = publ
+
+        mode = data.get('mode', UserMode.no_reset)
+        if mode == 'disable':
+            mode = UserMode.no_reset
+            dbuser.enable = False
+
+        dbuser.mode = mode
+
+        dbuser.last_online = hutils.json.json_to_time(data.get('last_online')) or datetime.datetime.min
+        if commit:
+            db.session.commit()
+        return dbuser
+
+    def to_dict(self, convert_date=True) -> dict:
+        base = super().to_dict()
+        return {**base,
+                'last_online': hutils.json.time_to_json(self.last_online) if convert_date else self.last_online,
+                'usage_limit_GB': self.usage_limit_GB,
+                'package_days': self.package_days,
+                'mode': self.mode,
+                'start_date': hutils.json.date_to_json(self.start_date)if convert_date else self.start_date,
+                'current_usage_GB': self.current_usage_GB,
+                'last_reset_time': hutils.json.date_to_json(self.last_reset_time) if convert_date else self.last_reset_time,
+                'added_by_uuid': self.admin.uuid,
+                'ed25519_private_key': self.ed25519_private_key,
+                'ed25519_public_key': self.ed25519_public_key
+                }
+
+    # @staticmethod
+    # def from_dict(data):
+    #     """
+    #     Returns a new User object created from a dictionary.
+    #     """
+
+    #     return User(
+    #         name=data.get('name', ''),
+    #         expiry_time=data.get('expiry_time', datetime.date.today() + relativedelta.relativedelta(months=6)),
+    #         usage_limit_GB=data.get('usage_limit_GB', 1000),
+    #         package_days=data.get('package_days', 90),
+    #         mode=UserMode[data.get('mode', 'no_reset')],
+    #         monthly=data.get('monthly', False),
+    #         start_date=data.get('start_date', None),
+    #         current_usage_GB=data.get('current_usage_GB', 0),
+    #         last_reset_time=data.get('last_reset_time', datetime.date.today()),
+    #         comment=data.get('comment', None),
+    #         telegram_id=data.get('telegram_id', None),
+    #         added_by=data.get('added_by', 1)
+    #     )
 
 
 # TODO: refactor this function too
@@ -211,9 +285,7 @@ def remove(user: User, commit=True) -> None:
 
 def remove_user(uuid: str, commit=True):
     dbuser = User.by_uuid(uuid)
-    db.session.delete(dbuser)
-    if commit:
-        db.session.commit()
+    remove(dbuser, commit)
 
 
 @event.listens_for(User, 'before_insert')

hiddifypanel/models/utils.py

@@ -9,18 +9,18 @@ def fill_username(model) -> None:
     minimum_username_length = 10
 
     if len(base_username) < minimum_username_length:
-        base_username += hutils.utils.get_random_string(minimum_username_length-len(base_username), minimum_username_length)
+        base_username += hutils.random.get_random_string(minimum_username_length-len(base_username), minimum_username_length)
 
     if len(base_username) > 100:
         base_username = base_username[0:100]
     model.username = base_username
 
     while not model.is_username_unique():
-        rand_str = hutils.utils.get_random_string(2, 4)
+        rand_str = hutils.random.get_random_string(2, 4)
         model.username += rand_str
 
 
 def fill_password(model) -> None:
     # TODO: hash the password
     if not model.password or len(model.password) < 16:
-        model.password=hutils.utils.get_random_password(length = 16)
+        model.password = hutils.random.get_random_password(length=16)

hiddifypanel/panel/admin/Actions.py

@@ -13,7 +13,6 @@ from hiddifypanel import hutils
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify, usage
 from hiddifypanel.panel.run_commander import commander, Command
-from hiddifypanel.panel.hiddify import flash
 
 
 class Actions(FlaskView):
@@ -99,13 +98,13 @@ class Actions(FlaskView):
         #     try:
         #         hiddify_api.sync_child_to_parent()
         #     except e as Exception:
-        #         flash(_('can not sync child with parent panel')+" "+e)
+        #         hutils.flask.flash(_('can not sync child with parent panel')+" "+e)
 
         domain_changed = request.args.get("domain_changed", str(domain_changed)).lower() == "true"
         complete_install = request.args.get("complete_install", str(complete_install)).lower() == "true"
         if domain_changed:
-            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')
+            hutils.flask.flash((_('Your domains changed. Please do not forget to copy admin links, otherwise you can not access to the panel anymore.')), 'info')
+        # hutils.flask.flash(f'complete_install={complete_install} domain_changed={domain_changed} ', 'info')
         # return render_template("result.html")
         # hiddify.add_temporary_access()
         file = "install.sh" if complete_install else "apply_configs.sh"
@@ -147,7 +146,7 @@ class Actions(FlaskView):
         key = hiddify.generate_x25519_keys()
         set_hconfig(ConfigEnum.reality_private_key, key['private_key'])
         set_hconfig(ConfigEnum.reality_public_key, key['public_key'])
-        hiddify.flash_config_success(restart_mode='apply', domain_changed=False)
+        hutils.flask.flash_config_success(restart_mode='apply', domain_changed=False)
         return redirect(url_for('admin.SettingAdmin:index'))
 
     @login_required(roles={Role.super_admin})
@@ -232,4 +231,4 @@ def get_log_api_url():
 
 
 def get_domains():
-    return [str(d.domain).replace("*", hiddify.get_random_string(3, 6)) for d in get_panel_domains(always_add_all_domains=True, always_add_ip=True)]
+    return [str(d.domain).replace("*", hutils.random.get_random_string(3, 6)) for d in get_panel_domains(always_add_all_domains=True, always_add_ip=True)]

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -168,7 +168,7 @@ class AdminstratorAdmin(AdminLTEModelView):
 
     # @login_required(roles={Role.super_admin, Role.admin})
     def is_accessible(self):
-        if login_required(roles={Role.super_admin, Role.admin})(lambda: True)() != True:
+        if login_required(roles={Role.super_admin, Role.admin, Role.agent})(lambda: True)() != True:
             return False
         return True