hiddifypanel 10.10.20__py3-none-any.whl → 10.11.1__py3-none-any.whl

hiddifypanel/models/proxy.py

@@ -1,7 +1,7 @@
-from enum import auto
-
 from sqlalchemy_serializer import SerializerMixin
 from strenum import StrEnum
+from enum import auto
+from sqlalchemy import Column, String, Integer, Boolean, Enum, ForeignKey
 
 from hiddifypanel.database import db
 
@@ -57,15 +57,15 @@ class ProxyL3(StrEnum):
     custom = auto()
 
 
-class Proxy(db.Model, SerializerMixin):
-    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
-    child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
-    name = db.Column(db.String(200), nullable=False, unique=False)
-    enable = db.Column(db.Boolean, nullable=False)
-    proto = db.Column(db.Enum(ProxyProto), nullable=False)
-    l3 = db.Column(db.Enum(ProxyL3), nullable=False)
-    transport = db.Column(db.Enum(ProxyTransport), nullable=False)
-    cdn = db.Column(db.Enum(ProxyCDN), nullable=False)
+class Proxy(db.Model, SerializerMixin):  # type: ignore
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    child_id = Column(Integer, ForeignKey('child.id'), default=0)
+    name = Column(String(200), nullable=False, unique=False)
+    enable = Column(Boolean, nullable=False)
+    proto = Column(Enum(ProxyProto), nullable=False)
+    l3 = Column(Enum(ProxyL3), nullable=False)
+    transport = Column(Enum(ProxyTransport), nullable=False)
+    cdn = Column(Enum(ProxyCDN), nullable=False)
 
     @property
     def enabled(self):
@@ -82,12 +82,15 @@ class Proxy(db.Model, SerializerMixin):
             'child_unique_id': self.child.unique_id if self.child else ''
         }
 
+    def __str__(self):
+        return str(self.to_dict())
+
     @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)
+            db.session.add(dbproxy)  # type: ignore
         dbproxy.enable = proxy['enable']
         dbproxy.name = proxy['name']
         dbproxy.proto = proxy['proto']
@@ -96,7 +99,7 @@ class Proxy(db.Model, SerializerMixin):
         dbproxy.l3 = proxy['l3']
         dbproxy.child_id = child_id
         if commit:
-            db.session.commit()
+            db.session.commit()  # type: ignore
 
     @staticmethod
     def bulk_register(proxies, commit=True, override_child_unique_id=None):
@@ -105,7 +108,4 @@ class Proxy(db.Model, SerializerMixin):
             child_id = hiddify.get_child(unique_id=None)
             Proxy.add_or_update(commit=False, child_id=child_id, **proxy)
         if commit:
-            db.session.commit()
-
-    def __str__(self):
-        return str(self.to_dict())
+            db.session.commit()  # type: ignore

hiddifypanel/models/user.py

@@ -8,7 +8,6 @@ from sqlalchemy import event
 
 from hiddifypanel.database import db
 from hiddifypanel.models import Lang
-from hiddifypanel.models.utils import fill_password, fill_username
 from hiddifypanel.models.base_account import BaseAccount
 from hiddifypanel.models.admin import AdminUser
 
@@ -208,7 +207,7 @@ class User(BaseAccount):
         from hiddifypanel import hutils
         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()
+            admin = AdminUser.by_uuid(data.get('added_by_uuid'), create=True) or AdminUser.current_admin_or_owner()  # type: ignore
             dbuser.added_by = admin.id
         else:
             dbuser.added_by = 1
@@ -233,17 +232,17 @@ class User(BaseAccount):
         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
+        # if not dbuser.ed25519_private_key:
+        #     priv, publ = hutils.crypto.get_ed25519_private_public_pair()
+        #     dbuser.ed25519_private_key = priv
+        #     dbuser.ed25519_public_key = publ
+
         dbuser.wg_pk = data.get('wg_pk', dbuser.wg_pk)
         dbuser.wg_pub = data.get('wg_pub', dbuser.wg_pub)
         dbuser.wg_psk = data.get('wg_psk', dbuser.wg_psk)
-        if not dbuser.wg_pk:
-            from hiddifypanel.panel import hiddify
-            dbuser.wg_pk, dbuser.wg_pub, dbuser.wg_psk = hiddify.get_wg_private_public_psk_pair()
+
+        # if not dbuser.wg_pk:
+        #     dbuser.wg_pk, dbuser.wg_pub, dbuser.wg_psk = hutils.crypto.get_wg_private_public_psk_pair()
 
         mode = data.get('mode', UserMode.no_reset)
         if mode == 'disable':
@@ -270,7 +269,7 @@ class User(BaseAccount):
                 'start_date': hutils.convert.date_to_json(self.start_date)if convert_date else self.start_date,
                 'current_usage_GB': self.current_usage_GB,
                 'last_reset_time': hutils.convert.date_to_json(self.last_reset_time) if convert_date else self.last_reset_time,
-                'added_by_uuid': self.admin.uuid,
+                'added_by_uuid': self.admin.uuid if self.admin else None,
                 'ed25519_private_key': self.ed25519_private_key,
                 'ed25519_public_key': self.ed25519_public_key,
                 'wg_pk': self.wg_pk,
@@ -302,5 +301,8 @@ class User(BaseAccount):
 
 @event.listens_for(User, 'before_insert')
 def on_user_insert(mapper, connection, target):
-    fill_username(target)
-    fill_password(target)
+    from hiddifypanel import hutils
+    hutils.model.gen_username(target)
+    hutils.model.gen_password(target)
+    hutils.model.gen_ed25519_keys(target)
+    hutils.model.gen_wg_keys(target)

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -208,7 +208,7 @@ class AdminstratorAdmin(AdminLTEModelView):
 
         if g.account.mode != AdminMode.super_admin and model.mode == AdminMode.super_admin:
             raise ValidationError("Sub-Admin can not have more power!!!!")
-        if model.mode == AdminMode.agent and model.mode != AdminMode.agent:
+        if g.account.mode == AdminMode.agent and model.mode != AdminMode.agent:
             raise ValidationError("Sub-Admin can not have more power!!!!")
 
     def on_model_delete(self, model):

hiddifypanel/panel/admin/DomainAdmin.py

@@ -199,9 +199,10 @@ class DomainAdmin(AdminLTEModelView):
                 raise ValidationError(
                     __("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode", server_ip=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
 
-            # if domain_ip_is_same_as_panel and model.mode in [DomainType.cdn, DomainType.relay, DomainType.fake, DomainType.auto_cdn_ip]:
-            #     # hutils.flask.flash(__(f"In CDN mode, Domain IP={dip} should be different to your ip={', '.join(list(map(str, ipv4_list)))}"), 'warning')
-            #     raise ValidationError(__("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s", server_ip=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
+            if domain_ip_is_same_as_panel and model.mode in [DomainType.cdn, DomainType.relay, DomainType.fake, DomainType.auto_cdn_ip]:
+                #     # hutils.flask.flash(__(f"In CDN mode, Domain IP={dip} should be different to your ip={', '.join(list(map(str, ipv4_list)))}"), 'warning')
+                raise ValidationError(__("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
+                                      server_ip=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
 
             # if model.mode in [DomainType.ss_faketls, DomainType.telegram_faketls]:
             #     if len(Domain.query.filter(Domain.mode==model.mode and Domain.id!=model.id).all())>0:
@@ -217,43 +218,28 @@ class DomainAdmin(AdminLTEModelView):
         # if model.mode==DomainType.fake and model.cdn_ip!=myip:
         #     raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
 
-        # work_with_ids = form.work_with.data
-        # print(work_with_ids)
         # # Update the many-to-many relationship
         if len(model.show_domains) == Domain.query.count():
             model.show_domains = []
-        # if model.alias and not g.is_commercial:
-            #     model.alias= "@hiddify "+model.alias
-        # model.work_with = self.session.query(Domain).filter(
-        #     Domain.id.in_(work_with_ids)).all()
 
         if model.mode == DomainType.reality:
-            model.servernames = (model.domain).lower()
-            if not hutils.network.is_domain_reality_friendly(model.domain):
-                # hutils.flask.flash(_("Domain is not REALITY friendly!")+" "+d,'error')
-                # return render_template('config.html', form=form)
-                raise ValidationError(_("Domain is not REALITY friendly!") + " " + model.domain)
-
-                hiddify.debug_flash_if_not_in_the_same_asn(model.domain)
-        if False:
             model.servernames = (model.servernames or model.domain).lower()
-
-            for v in [model.domain, model.servernames]:
-
+            for v in set([model.domain, model.servernames]):
                 for d in v.split(","):
                     if not d:
                         continue
-
                     if not hutils.network.is_domain_reality_friendly(d):
-                        # hutils.flask.flash(_("Domain is not REALITY friendly!")+" "+d,'error')
-                        # return render_template('config.html', form=form)
-                        raise ValidationError(_("Domain is not REALITY friendly!") + " " + d)
+                        raise ValidationError(_("Domain is not REALITY friendly!")+f' {d}')
 
-                    hiddify.debug_flash_if_not_in_the_same_asn(d)
+                    if not hutils.network.is_in_same_asn(d, ipv4_list[0]):
+                        server_asn = hutils.network.get_ip_asn_name(ipv4_list[0])
+                        domain_asn = hutils.network.get_ip_asn_name(dip)  # type: ignore
+                    msg = _("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={server_asn}<br>{d}_ASN={domain_asn}" if server_asn or domain_asn else "")
+                    hutils.flask.flash(msg, 'warning')
 
             for d in model.servernames.split(","):
-                if not hiddify.fallback_domain_compatible_with_servernames(model.domain, d):
-                    raise ValidationError(_("REALITY Fallback domain is not compaitble with server names!") + " " + d + " != " + model.domain)
+                if not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):
+                    raise ValidationError(_("REALITY Fallback domain is not compaitble with server names!")+f' {d} != {model.domain}')
 
         if (model.cdn_ip):
             try:

hiddifypanel/panel/admin/ProxyAdmin.py

@@ -35,7 +35,7 @@ class ProxyAdmin(FlaskView):
 
             db.session.commit()
             # print(cat,vs)
-            hiddify.get_available_proxies.invalidate_all()
+            hutils.proxy.get_proxies.invalidate_all()
             hiddify.check_need_reset(old_configs)
             all_proxy_form = get_all_proxy_form(True)
 
@@ -55,7 +55,7 @@ class ProxyAdmin(FlaskView):
 
                 # print(cat,vs)
             db.session.commit()
-            hiddify.get_available_proxies.invalidate_all()
+            hutils.proxy.get_proxies.invalidate_all()
             hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=False)
             # if hconfig(ConfigEnum.parent_panel):
             #     hiddify_api.sync_child_to_parent()
@@ -94,7 +94,7 @@ def get_global_config_form(empty=False):
 
 
 def get_all_proxy_form(empty=False):
-    proxies = hiddify.get_available_proxies(Child.current.id)
+    proxies = hutils.proxy.get_proxies(Child.current.id)
     categories1 = sorted([c for c in {c.cdn: 1 for c in proxies}])
 
     class DynamicForm(FlaskForm):

hiddifypanel/panel/admin/SettingAdmin.py

@@ -122,7 +122,6 @@ class SettingAdmin(FlaskView):
 
 
 def get_config_form():
-
     strconfigs = StrConfig.query.filter(StrConfig.child_id == Child.current.id).all()
     boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current.id).all()
     bool_types = {c.key: 'bool' for c in boolconfigs}
@@ -154,7 +153,8 @@ def get_config_form():
             if c.key in bool_types:
                 field = SwitchField(_(f'config.{c.key}.label'), default=c.value, description=_(f'config.{c.key}.description'))
             elif c.key == ConfigEnum.core_type:
-                field = wtf.SelectField(_(f"config.{c.key}.label"), choices=[("xray", _("Xray")), ("singbox", _("SingBox"))], description=_(f"config.{c.key}.description"), default=hconfig(c.key))
+                field = wtf.SelectField(_(f"config.{c.key}.label"), choices=[("xray", _("Xray")), ("singbox", _(
+                    "SingBox"))], description=_(f"config.{c.key}.description"), default=hconfig(c.key))
             elif c.key == ConfigEnum.warp_mode:
                 field = wtf.SelectField(
                     _(f"config.{c.key}.label"), choices=[("disable", _("Disable")), ("all", _("All")), ("custom", _("Only Blocked and Local websites"))],
@@ -168,7 +168,8 @@ def get_config_form():
                     description=_(f"config.{c.key}.description"),
                     default=hconfig(c.key))
             elif c.key == ConfigEnum.country:
-                field = wtf.SelectField(_(f"config.{c.key}.label"), choices=[("ir", _("Iran")), ("zh", _("China")), ("other", _("Others"))], description=_(f"config.{c.key}.description"), default=hconfig(c.key))
+                field = wtf.SelectField(_(f"config.{c.key}.label"), choices=[("ir", _("Iran")), ("zh", _(
+                    "China")), ("other", _("Others"))], description=_(f"config.{c.key}.description"), default=hconfig(c.key))
             elif c.key == ConfigEnum.package_mode:
                 package_modes = [("release", _("Release")), ("beta", _("Beta"))]
                 if hconfig(c.key) == "develop":
@@ -193,9 +194,14 @@ def get_config_form():
             elif c.key == ConfigEnum.telegram_lib:
                 # if hconfig(ConfigEnum.telegram_lib)=='python':
                 #     continue6
-                libs = [("python", _("lib.telegram.python")), ("tgo", _("lib.telegram.go")),
-                        ("orig", _("lib.telegram.orignal")), ("erlang", _("lib.telegram.erlang"))]
-                field = wtf.SelectField(_("config.telegram_lib.label"), choices=libs, description=_("config.telegram_lib.description"), default=hconfig(ConfigEnum.telegram_lib))
+                libs = [
+                    ("erlang", _("lib.telegram.erlang")),
+                    ("python", _("lib.telegram.python")),
+                    ("tgo", _("lib.telegram.go")),
+                    # ("orig", _("lib.telegram.orignal")),
+                ]
+                field = wtf.SelectField(_("config.telegram_lib.label"), choices=libs, description=_(
+                    "config.telegram_lib.description"), default=hconfig(ConfigEnum.telegram_lib))
             elif c.key == ConfigEnum.mux_protocol:
                 choices = [("smux", 'smux'), ("yamux", "yamux"), ("h2mux", "h2mux")]
                 field = wtf.SelectField(_(f"config.{c.key}.label"), choices=choices, description=_(f"config.{c.key}.description"), default=hconfig(c.key))
@@ -203,11 +209,13 @@ def get_config_form():
             elif c.key == ConfigEnum.warp_sites:
                 validators = [wtf.validators.Length(max=2048)]
                 render_kw = {'class': "ltr", 'maxlength': 2048}
-                field = wtf.TextAreaField(_(f'config.{c.key}.label'), validators, default=c.value, description=_(f'config.{c.key}.description'), render_kw=render_kw)
+                field = wtf.TextAreaField(_(f'config.{c.key}.label'), validators, default=c.value,
+                                          description=_(f'config.{c.key}.description'), render_kw=render_kw)
             elif c.key == ConfigEnum.branding_freetext:
                 validators = [wtf.validators.Length(max=2048)]
                 render_kw = {'class': "ltr", 'maxlength': 2048}
-                field = custom_widgets.CKTextAreaField(_(f'config.{c.key}.label'), validators, default=c.value, description=_(f'config.{c.key}.description'), render_kw=render_kw)
+                field = custom_widgets.CKTextAreaField(_(f'config.{c.key}.label'), validators, default=c.value,
+                                                       description=_(f'config.{c.key}.description'), render_kw=render_kw)
             else:
                 render_kw = {'class': "ltr"}
                 validators = []
@@ -239,11 +247,13 @@ def get_config_form():
                 if c.key == ConfigEnum.telegram_bot_token:
                     validators.append(wtf.validators.Regexp("()|^([0-9]{8,12}:[a-zA-Z0-9_-]{30,40})|$", re.IGNORECASE, _("config.Invalid telegram bot token")))
                 if c.key == ConfigEnum.branding_site:
-                    validators.append(wtf.validators.Regexp("()|(http(s|)://([A-Za-z0-9\\-\\.]+\\.[a-zA-Z]{2,})/?.*)", re.IGNORECASE, _("config.Invalid brand link")))
+                    validators.append(wtf.validators.Regexp(
+                        "()|(http(s|)://([A-Za-z0-9\\-\\.]+\\.[a-zA-Z]{2,})/?.*)", re.IGNORECASE, _("config.Invalid brand link")))
                     # render_kw['required']=""
 
                 if 'secret' in c.key:
-                    validators.append(wtf.validators.Regexp("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$", re.IGNORECASE, _('config.invalid uuid')))
+                    validators.append(wtf.validators.Regexp(
+                        "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$", re.IGNORECASE, _('config.invalid uuid')))
                     render_kw['required'] = ""
 
                 if c.key == ConfigEnum.proxy_path:
@@ -274,7 +284,8 @@ def get_config_form():
                 if c.key == ConfigEnum.reality_public_key and g.account.mode in [AdminMode.super_admin]:
                     extra_info = f" <a href='{hurl_for('admin.Actions:change_reality_keys')}'>{_('Change')}</a>"
 
-                field = wtf.StringField(_(f'config.{c.key}.label'), validators, default=c.value, description=_(f'config.{c.key}.description') + extra_info, render_kw=render_kw)
+                field = wtf.StringField(_(f'config.{c.key}.label'), validators, default=c.value,
+                                        description=_(f'config.{c.key}.description') + extra_info, render_kw=render_kw)
             setattr(CategoryForm, f'{c.key}', field)
 
         multifield = wtf.FormField(CategoryForm, Markup('<i class="fa-solid fa-plus"></i>&nbsp' + _(f'config.{cat}.label')))

hiddifypanel/panel/admin/UserAdmin.py

@@ -271,14 +271,16 @@ class UserAdmin(AdminLTEModelView):
                                   active=g.account.max_active_users, total=g.account.max_users))
         if old_user and old_user.uuid != model.uuid:
             user_driver.remove_client(old_user)
-        if not model.ed25519_private_key:
-            priv, publ = hiddify.get_ed25519_private_public_pair()
-            model.ed25519_private_key = priv
-            model.ed25519_public_key = publ
-        if not model.wg_pk:
-            model.wg_pk, model.wg_pub, model.wg_psk = hiddify.get_wg_private_public_psk_pair()
-        # model.expiry_time=datetime.date.today()+datetime.timedelta(days=model.expiry_time)
 
+        # generated automatically
+        # if not model.ed25519_private_key:
+        #     priv, publ = hutils.crypto.get_ed25519_private_public_pair()
+        #     model.ed25519_private_key = priv
+        #     model.ed25519_public_key = publ
+        # if not model.wg_pk:
+        #     model.wg_pk, model.wg_pub, model.wg_psk = hutils.crypto.get_wg_private_public_psk_pair()
+
+        # model.expiry_time=datetime.date.today()+datetime.timedelta(days=model.expiry_time)
         # if model.current_usage_GB < model.usage_limit_GB:
         #     xray_api.add_client(model.uuid)
         # else:

hiddifypanel/panel/cf_api.py

@@ -1,6 +1,5 @@
 import CloudFlare
-
-from hiddifypanel.models import *
+from hiddifypanel.models import hconfig, ConfigEnum
 
 
 def add_or_update_domain(domain, ip, dns_type="A", proxied=True):

hiddifypanel/panel/commercial/ProxyDetailsAdmin.py

@@ -2,7 +2,6 @@ from hiddifypanel.models import *
 from hiddifypanel.panel.admin.adminlte import AdminLTEModelView
 from flask_babel import gettext as __
 from flask_babel import lazy_gettext as _
-from hiddifypanel.panel import hiddify
 from flask import g, redirect, Markup
 from hiddifypanel.hutils.flask import hurl_for, flash
 from hiddifypanel.auth import login_required
@@ -10,8 +9,8 @@ from flask_admin.model.template import EndpointLinkRowAction
 from flask_admin.actions import action
 from flask_admin.contrib.sqla import form, filters as sqla_filters, tools
 # Define a custom field type for the related domains
-
 from flask import current_app
+from hiddifypanel import hutils
 
 
 class ProxyDetailsAdmin(AdminLTEModelView):
@@ -30,7 +29,7 @@ class ProxyDetailsAdmin(AdminLTEModelView):
 
         self.session.commit()
         flash(_('%(count)s records were successfully disabled.', count=count), 'success')
-        hiddify.get_available_proxies.invalidate_all()
+        hutils.proxy.get_proxies.invalidate_all()
 
     @action('enable', 'Enable', 'Are you sure you want to enable selected proxies?')
     def action_enable(self, ids):
@@ -39,7 +38,7 @@ class ProxyDetailsAdmin(AdminLTEModelView):
 
         self.session.commit()
         flash(_('%(count)s records were successfully enabled.', count=count), 'success')
-        hiddify.get_available_proxies.invalidate_all()
+        hutils.proxy.get_proxies.invalidate_all()
 
     # list_template = 'model/domain_list.html'
 
@@ -48,13 +47,13 @@ class ProxyDetailsAdmin(AdminLTEModelView):
     def after_model_change(self, form, model, is_created):
         # if hconfig(ConfigEnum.parent_panel):
         #     hiddify_api.sync_child_to_parent()
-        hiddify.get_available_proxies.invalidate_all()
+        hutils.proxy.get_proxies.invalidate_all()
         pass
 
     def after_model_delete(self, model):
         # if hconfig(ConfigEnum.parent_panel):
         #     hiddify_api.sync_child_to_parent()
-        hiddify.get_available_proxies.invalidate_all()
+        hutils.proxy.get_proxies.invalidate_all()
         pass
 
     def is_accessible(self):

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

@@ -357,7 +357,7 @@ class AppAPI(MethodView):
                         ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/hiddify-clash-desktop_{version}_amd64.AppImage'
                         dto.install.append(self.__get_app_install_dto(AppInstallType.appimage, ins_url))
                     case Platform.mac:
-                        ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/HiddifyClashDesktop_{version}x64.dmg'
+                        ins_url = latest_url.split('releases/')[0] + f'releases/download/{version}/HiddifyClashDesktop_{version}_x64.dmg'
                         dto.install.append(self.__get_app_install_dto(AppInstallType.dmg, ins_url))
         else:
             match platform:

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

@@ -3,13 +3,10 @@ from flask import g, request
 from flask import current_app as app
 from flask.views import MethodView
 from hiddifypanel.auth import login_required
-from hiddifypanel.models.config import hconfig
-from hiddifypanel.models.config_enum import ConfigEnum
-from hiddifypanel.models.role import Role
+from hiddifypanel.models import Proxy, Role, ConfigEnum, hconfig
 from apiflask import Schema
 from apiflask.fields import String
 from hiddifypanel.panel.user.user import get_common_data
-from hiddifypanel.panel.user import link_maker
 from hiddifypanel import hutils
 
 
@@ -26,7 +23,7 @@ class ConfigSchema(Schema):
 class AllConfigsAPI(MethodView):
     decorators = [login_required({Role.user})]
 
-    @app.output(ConfigSchema(many=True))
+    @app.output(ConfigSchema(many=True))  # type: ignore
     def get(self):
         def create_item(name, domain, type, protocol, transport, security, link):
             dto = ConfigSchema()
@@ -108,7 +105,7 @@ class AllConfigsAPI(MethodView):
                 )
             )
 
-        for pinfo in link_maker.get_all_validated_proxies(c['domains']):
+        for pinfo in hutils.proxy.get_valid_proxies(c['domains']):
             items.append(
                 create_item(
                     pinfo["name"].replace("_", " "),
@@ -117,7 +114,7 @@ class AllConfigsAPI(MethodView):
                     pinfo['proto'],
                     pinfo['transport'],
                     pinfo['l3'],
-                    f"{link_maker.to_link(pinfo)}"
+                    f"{hutils.proxy.xray.to_link(pinfo)}"
                 )
             )
 

hiddifypanel/panel/common.py

@@ -9,6 +9,7 @@ from hiddifypanel import hutils
 import hiddifypanel.auth as auth
 from hiddifypanel.auth import current_account
 from apiflask import APIFlask, HTTPError, abort
+from hiddifypanel import hutils
 
 
 def init_app(app: APIFlask):
@@ -21,6 +22,7 @@ def init_app(app: APIFlask):
     app.jinja_env.globals['static_url_for'] = hutils.flask.static_url_for
     app.jinja_env.globals['hurl_for'] = hutils.flask.hurl_for
     app.jinja_env.globals['_gettext'] = lambda x: print("==========", x)
+    app.jinja_env.globals['proxy_stats_url'] = hutils.flask.get_proxy_stats_url
 
     @app.after_request
     def apply_no_robot(response):
@@ -42,7 +44,7 @@ def init_app(app: APIFlask):
             has_update = False
         else:
             has_update = "dev" not in hiddifypanel.__version__ and f'{last_version}' != hiddifypanel.__version__
-    
+
         if not request.accept_mimetypes.accept_html:
             if has_update:
                 return jsonify({
@@ -91,11 +93,11 @@ def init_app(app: APIFlask):
         if 'proxy_path' not in values:
             if force_path := g.get('force_proxy_path'):
                 values['proxy_path'] = force_path
-            elif hutils.flask.is_admin_role(current_account.role):
+            elif hutils.flask.is_admin_role(current_account.role):  # type: ignore
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
             elif hutils.flask.is_user_panel_call():
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_client)
-            elif current_account and hutils.flask.is_admin_role(current_account.role):
+            elif current_account and hutils.flask.is_admin_role(current_account.role):  # type: ignore
                 values['proxy_path'] = hconfig(ConfigEnum.proxy_path_admin)
             else:
                 values['proxy_path'] = g.proxy_path or "A"

hiddifypanel/panel/hiddify.py

@@ -68,52 +68,6 @@ def exec_command(cmd, cwd=None):
         print(e)
 
 
-@cache.cache(ttl=300)
-def get_available_proxies(child_id):
-    proxies = Proxy.query.filter(Proxy.child_id == child_id).all()
-    proxies = [c for c in proxies if 'restls' not in c.transport]
-    # if not hconfig(ConfigEnum.tuic_enable, child_id):
-    #     proxies = [c for c in proxies if c.proto != ProxyProto.tuic]
-    # if not hconfig(ConfigEnum.hysteria_enable, child_id):
-    #     proxies = [c for c in proxies if c.proto != ProxyProto.hysteria2]
-    if not hconfig(ConfigEnum.shadowsocks2022_enable, child_id):
-        proxies = [c for c in proxies if 'shadowsocks' != c.transport]
-
-    if not hconfig(ConfigEnum.ssfaketls_enable, child_id):
-        proxies = [c for c in proxies if 'faketls' != c.transport]
-    if not hconfig(ConfigEnum.v2ray_enable, child_id):
-        proxies = [c for c in proxies if 'v2ray' != c.proto]
-    if not hconfig(ConfigEnum.shadowtls_enable, child_id):
-        proxies = [c for c in proxies if c.transport != 'shadowtls']
-    if not hconfig(ConfigEnum.ssr_enable, child_id):
-        proxies = [c for c in proxies if 'ssr' != c.proto]
-    if not hconfig(ConfigEnum.vmess_enable, child_id):
-        proxies = [c for c in proxies if 'vmess' not in c.proto]
-    if not hconfig(ConfigEnum.httpupgrade_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.httpupgrade not in c.transport]
-    if not hconfig(ConfigEnum.ws_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.WS not in c.transport]
-
-    if not hconfig(ConfigEnum.grpc_enable, child_id):
-        proxies = [c for c in proxies if ProxyTransport.grpc not in c.transport]
-    if not hconfig(ConfigEnum.kcp_enable, child_id):
-        proxies = [c for c in proxies if 'kcp' not in c.l3]
-
-    if not hconfig(ConfigEnum.http_proxy_enable, child_id):
-        proxies = [c for c in proxies if 'http' != c.l3]
-
-    if not Domain.query.filter(Domain.mode.in_([DomainType.cdn, DomainType.auto_cdn_ip])).first():
-        proxies = [c for c in proxies if c.cdn != "CDN"]
-
-    if not Domain.query.filter(Domain.mode.in_([DomainType.relay])).first():
-        proxies = [c for c in proxies if c.cdn != ProxyCDN.relay]
-
-    if not Domain.query.filter(Domain.mode.in_([DomainType.cdn, DomainType.auto_cdn_ip]), Domain.servernames != "", Domain.servernames != Domain.domain).first():
-        proxies = [c for c in proxies if 'Fake' not in c.cdn]
-    proxies = [c for c in proxies if not ('vless' == c.proto and ProxyTransport.tcp == c.transport and c.cdn == ProxyCDN.direct)]
-    return proxies
-
-
 def quick_apply_users():
     if hconfig(ConfigEnum.is_parent):
         return
@@ -358,54 +312,10 @@ def generate_x25519_keys():
     return {'private_key': priv_str, 'public_key': pub_str}
 
 
-def get_hostkeys(dojson=False):
-    key_files = glob.glob(current_app.config['HIDDIFY_CONFIG_PATH'] + "/other/ssh/host_key/*_key.pub")
-    host_keys = []
-    for file_name in key_files:
-        with open(file_name, "r") as f:
-            host_key = f.read().strip()
-            host_key = host_key.split()
-            if len(host_key) > 2:
-                host_key = host_key[:2]  # strip the hostname part
-            host_key = " ".join(host_key)
-            host_keys.append(host_key)
-    if dojson:
-        return json.dumps(host_keys)
-    return host_keys
-
-
 def get_ssh_client_version(user):
     return 'SSH-2.0-OpenSSH_7.4p1'
 
 
-def get_ed25519_private_public_pair():
-    from cryptography.hazmat.primitives.asymmetric import ed25519
-    from cryptography.hazmat.primitives import serialization
-    privkey = ed25519.Ed25519PrivateKey.generate()
-    pubkey = privkey.public_key()
-    priv_bytes = privkey.private_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PrivateFormat.OpenSSH,
-        encryption_algorithm=serialization.NoEncryption(),
-    )
-    pub_bytes = pubkey.public_bytes(
-        encoding=serialization.Encoding.OpenSSH,
-        format=serialization.PublicFormat.OpenSSH,
-    )
-    return priv_bytes.decode(), pub_bytes.decode()
-
-
-def get_wg_private_public_psk_pair():
-    try:
-        private_key = subprocess.run(["wg", "genkey"], capture_output=True, text=True, check=True).stdout.strip()
-        public_key = subprocess.run(["wg", "pubkey"], input=private_key, capture_output=True, text=True, check=True).stdout.strip()
-        psk = subprocess.run(["wg", "genpsk"], capture_output=True, text=True, check=True).stdout.strip()
-        return private_key, public_key, psk
-    except subprocess.CalledProcessError as e:
-        print(f"Error: {e}")
-        return None, None, None
-
-
 def get_account_panel_link(account: BaseAccount, host: str, is_https: bool = True, prefere_path_only: bool = False, child_id=None):
     if child_id is None:
         child_id = Child.current.id