hiddifypanel 9.0.0.dev90__py3-none-any.whl → 10.5.0.dev0__py3-none-any.whl

hiddifypanel/panel/admin/Actions.py

@@ -39,22 +39,18 @@ class Actions(FlaskView):
 
     @login_required(roles={Role.super_admin})
     def reset2(self):
-        _ = self.status()
+        res = render_template("result.html",
+                              out_type="info",
+                              out_msg="",
+                              log_file_url=get_log_api_url(),
+                              log_file='restart.log',
+                              show_success=True,
+                              domains=get_domains())
 
         # run restart.sh
         commander(Command.restart_services)
 
-        # flask don't response at all while using time.sleep
-        # import time
-        # time.sleep(1)
-
-        return render_template("result.html",
-                               out_type="info",
-                               out_msg="",
-                               log_file_url=get_log_api_url(),
-                               log_file='restart.log',
-                               show_success=True,
-                               domains=get_domains())
+        return res
 
     @login_required(roles={Role.super_admin})
     @route('reinstall', methods=['POST'])
@@ -65,11 +61,9 @@ class Actions(FlaskView):
     def reinstall2(self, complete_install=True, domain_changed=False):
         if int(hconfig(ConfigEnum.db_version)) < 9:
             return ("Please update your panel before this action.")
-        # if hconfig(ConfigEnum.parent_panel):
-        #     try:
-        #         hiddify_api.sync_child_to_parent()
-        #     except e as Exception:
-        #         hutils.flask.flash(_('can not sync child with parent panel')+" "+e)
+        if hutils.node.is_child():
+            if not hutils.node.child.sync_with_parent():
+                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
 
         domain_changed = request.args.get("domain_changed", str(domain_changed)).lower() == "true"
         complete_install = request.args.get("complete_install", str(complete_install)).lower() == "true"
@@ -114,7 +108,7 @@ class Actions(FlaskView):
 
     @login_required(roles={Role.super_admin})
     def change_reality_keys(self):
-        key = hiddify.generate_x25519_keys()
+        key = hutils.crypto.generate_x25519_keys()
         set_hconfig(ConfigEnum.reality_private_key, key['private_key'])
         set_hconfig(ConfigEnum.reality_public_key, key['public_key'])
         hutils.flask.flash_config_success(restart_mode=ApplyMode.restart, domain_changed=False)
@@ -170,7 +164,7 @@ class Actions(FlaskView):
 
             tcp_ping = hutils.network.is_domain_reality_friendly(d)
             if tcp_ping:
-                dip = hutils.network.get_domain_ip(d)
+                dip = str(hutils.network.get_domain_ip(d))
                 dip_country = (IPCOUNTRY.get(dip) or {}).get('country', {}).get('iso_code', 'unknown')
                 if dip_country == "IR":
                     continue

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -7,7 +7,9 @@ from .adminlte import AdminLTEModelView
 from flask_babel import lazy_gettext as _
 from wtforms.validators import Regexp
 from flask_babel import gettext as __
-from flask import Markup, request  # type: ignore
+from flask import request  # type: ignore
+from markupsafe import Markup
+
 from flask import g
 import datetime
 from wtforms import SelectField
@@ -37,7 +39,7 @@ class SubAdminsField(SelectField):
 
 class AdminstratorAdmin(AdminLTEModelView):
     column_hide_backrefs = False
-    column_list = ["name", 'UserLinks', 'mode', 'can_add_admin', 'max_active_users', 'max_users', 'online_users', 'comment']
+    column_list = ["name", 'UserLinks', 'mode', 'can_add_admin', 'max_active_users', 'max_users', 'online_users', 'comment',]
     form_columns = ["name", 'mode', 'can_add_admin', 'max_active_users', 'max_users', 'comment', "uuid"]
     list_template = 'model/admin_list.html'
     # column_editable_list = ['name']
@@ -208,13 +210,14 @@ 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):
         model.remove()
 
     def get_query_for_parent_admin(self):
+        # WHAT IS THIS?
         admin_user_id = self.get_pk_value()
         sub_admins_ids = set(recursive_sub_admins_ids(AdminUser.query.get(admin_user_id)))
         return AdminUser.query.filter(AdminUser.id.in_(sub_admins_ids)).with_entities(AdminUser.id, AdminUser.name)
@@ -236,3 +239,11 @@ class AdminstratorAdmin(AdminLTEModelView):
             del form.max_users
             del form.max_active_users
             del form.can_add_admin
+
+    def after_model_change(self, form, model, is_created):
+        if hutils.node.is_parent():
+            hutils.node.parent.send_sync_req_to_childs()
+
+    def after_model_delete(self, model):
+        if hutils.node.is_parent():
+            hutils.node.parent.send_sync_req_to_childs()

hiddifypanel/panel/admin/Dashboard.py

@@ -18,9 +18,9 @@ class Dashboard(FlaskView):
 
     @login_required(roles={Role.super_admin, Role.admin, Role.agent})
     def index(self):
-
         if hconfig(ConfigEnum.first_setup):
             return redirect(hurl_for("admin.QuickSetup:index"))
+
         if hiddifypanel.__release_date__ + datetime.timedelta(days=20) < datetime.datetime.now():
             hutils.flask.flash(_('This version of hiddify panel is outdated. Please update it from admin area.'), "danger")  # type: ignore
         bot = None
@@ -34,20 +34,15 @@ class Dashboard(FlaskView):
         user_query = User.query
         if admin_id:
             user_query = user_query.filter(User.added_by == admin_id)
-        if hconfig(ConfigEnum.is_parent):
+        if hutils.node.is_parent():
             childs = Child.query.filter(Child.id != 0).all()
             for c in childs:
                 c.is_active = False
                 for d in c.domains:
-                    if d.mode == DomainType.fake:
-                        continue
-                    remote = hiddify.get_account_panel_link(g.account, d.domain, child_id=c.id)
-                    d.is_active = hutils.network.check_connection_to_remote(remote)
+                    d.is_active = hutils.node.parent.is_child_domain_active(c, d)
                     if d.is_active:
                         c.is_active = True
 
-            # return render_template('parent_dash.html',childs=childs,bot=bot)
-    # try:
         def_user = None if len(User.query.all()) > 1 else User.query.filter(User.name == 'default').first()
         domains = get_panel_domains()
         sslip_domains = [d.domain for d in domains if "sslip.io" in d.domain]
@@ -56,13 +51,13 @@ class Dashboard(FlaskView):
             quick_setup = hurl_for("admin.QuickSetup:index")
             hutils.flask.flash((_('It seems that you have not setup the system completely. <a class="btn btn-success" href="%(quick_setup)s">Click here</a> to complete setup.',
                                   quick_setup=quick_setup)), 'warning')  # type: ignore
-            if hconfig(ConfigEnum.is_parent):
+            if hutils.node.is_parent():
                 hutils.flask.flash(
                     _("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")  # type: ignore
         elif len(sslip_domains):
             hutils.flask.flash((_('It seems that you are using default domain (%(domain)s) which is not recommended.',
                                domain=sslip_domains[0])), 'warning')  # type: ignore
-            if hconfig(ConfigEnum.is_parent):
+            if hutils.node.is_parent():
                 hutils.flask.flash(
                     _("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")  # type: ignore
         elif def_user:

hiddifypanel/panel/admin/DomainAdmin.py

@@ -3,7 +3,9 @@ from hiddifypanel.auth import login_required, current_account
 
 from hiddifypanel.models import *
 import re
-from flask import Markup, g  # type: ignore
+from flask import g  # type: ignore
+from markupsafe import Markup
+
 from flask_babel import gettext as __
 from flask_babel import lazy_gettext as _
 from hiddifypanel.panel.run_commander import Command, commander
@@ -169,26 +171,25 @@ class DomainAdmin(AdminLTEModelView):
         if hconfig(ConfigEnum.cloudflare) and model.mode != DomainType.fake:
             try:
                 proxied = model.mode in [DomainType.cdn, DomainType.auto_cdn_ip]
-                cf_api.add_or_update_domain(model.domain, ipv4_list[0], "A", proxied=proxied)
+                cf_api.add_or_update_domain(model.domain, str(ipv4_list[0]), "A", proxied=proxied)
                 if ipv6_list:
-                    cf_api.add_or_update_domain(model.domain, ipv6_list[0], "AAAA", proxied=proxied)
+                    cf_api.add_or_update_domain(model.domain, str(ipv6_list[0]), "AAAA", proxied=proxied)
 
                 skip_check = True
             except Exception as e:
-                # raise e
                 raise ValidationError(__("Can not connect to Cloudflare.") + f' {e}')
         # elif model.mode==DomainType.auto_cdn_ip:
-        if model.alias and not model.alias.replace("_", "").isalnum():
-            hutils.flask.flash(__("Using alias with special charachters may cause problem in some clients like FairVPN."), 'warning')
-        #     raise ValidationError(_("You have to add your cloudflare api key to use this feature: "))
+        # if model.alias and not model.alias.replace("_", "").isalnum():
+        #     hutils.flask.flash(__("Using alias with special charachters may cause problem in some clients like FairVPN."), 'warning')
+            # raise ValidationError(_("You have to add your cloudflare api key to use this feature: "))
 
         dip = hutils.network.get_domain_ip(model.domain)
         if model.sub_link_only:
             if dip is None:
-                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
+                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
         elif not skip_check:
             if dip is None:
-                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
+                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
 
             domain_ip_is_same_as_panel = False
             domain_ip_is_same_as_panel |= dip in ipv4_list
@@ -196,65 +197,52 @@ class DomainAdmin(AdminLTEModelView):
                 domain_ip_is_same_as_panel |= ipaddress.ip_address(dip) == ipaddress.ip_address(ipv6)
 
             if model.mode == DomainType.direct and not domain_ip_is_same_as_panel:
-                hutils.flask.flash(
-                    __(f"Domain IP={dip} is not matched with your ip={', '.join(list(map(str, ipv4_list)))} which is required in direct mode"),
-                    category='warning')
-                # raise ValidationError(_("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode", server_ip=myip, domain_ip=dip))
+                # hutils.flask.flash(__(f"Domain IP={dip} is not matched with your ip={', '.join(list(map(str, ipv4_list)))} which is required in direct mode"),category='error')
+                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=myip, domain_ip=dip))
+                #     # 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:
             #         ValidationError(f"another {model.mode} is exist")
+
         model.domain = model.domain.lower()
         if model.mode == DomainType.direct and model.cdn_ip:
             raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
 
         if model.mode == DomainType.fake and not model.cdn_ip:
-            model.cdn_ip = ipv4_list[0]
+            model.cdn_ip = str(ipv4_list[0])
 
         # 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:
@@ -280,19 +268,18 @@ class DomainAdmin(AdminLTEModelView):
         hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=True)
 
     def after_model_delete(self, model):
-        # if hconfig(ConfigEnum.parent_panel):
-        #     hiddify_api.sync_child_to_parent()
-        pass
+        if hutils.node.is_child():
+            if not hutils.node.child.sync_with_parent():
+                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
 
     def after_model_change(self, form, model, is_created):
         if hconfig(ConfigEnum.first_setup):
             set_hconfig(ConfigEnum.first_setup, False)
-        # if hconfig(ConfigEnum.parent_panel):
-        #     hiddify_api.sync_child_to_parent()
         if model.need_valid_ssl:
-            # hiddify.exec_command(f"sudo /opt/hiddify-manager/acme.sh/get_cert.sh {model.domain}")
-            # run get_cert.sh
             commander(Command.get_cert, domain=model.domain)
+        if hutils.node.is_child():
+            if not hutils.node.child.sync_with_parent():
+                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
 
     def is_accessible(self):
         if login_required(roles={Role.super_admin, Role.admin})(lambda: True)() != True:
@@ -310,4 +297,4 @@ class DomainAdmin(AdminLTEModelView):
 
     def get_query(self):
         query = super().get_query()
-        return query.filter(Domain.child_id == Child.current.id)
+        return query.filter(Domain.child_id == Child.current().id)

hiddifypanel/panel/admin/NodeAdmin.py

@@ -4,7 +4,9 @@ from wtforms.validators import Regexp, ValidationError
 from flask_babel import lazy_gettext as _
 from .adminlte import AdminLTEModelView
 from flask_babel import gettext as __
-from flask import Markup, g, request
+from flask import g, request
+from markupsafe import Markup
+
 
 from hiddifypanel.auth import login_required
 from hiddifypanel.panel import hiddify
@@ -40,7 +42,7 @@ class NodeAdmin(AdminLTEModelView):
     def is_accessible(self):
         if login_required(roles={Role.super_admin})(lambda: True)() != True:
             return False
-        if Child.current.id != 0:
+        if Child.current().id != 0:
             return False
         return True
 
@@ -49,7 +51,9 @@ class NodeAdmin(AdminLTEModelView):
             raise ValidationError(_("Remote nodes are not supported yet!"))
 
     def after_model_change(self, form, model, is_created):
+        # deprecated
         set_hconfig(ConfigEnum.is_parent, True)
+        set_hconfig(ConfigEnum.panel_mode, PanelMode.parent)
         if is_created and model.mode == ChildMode.virtual:
             # for k, v in get_hconfigs().items():
             #     set_hconfig(k, v, model.id)

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,10 +55,11 @@ class ProxyAdmin(FlaskView):
 
                 # print(cat,vs)
             db.session.commit()
-            hiddify.get_available_proxies.invalidate_all()
+            hutils.proxy.get_proxies.invalidate_all()
+            if hutils.node.is_child():
+                if not hutils.node.child.sync_with_parent():
+                    hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
             hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=False)
-            # if hconfig(ConfigEnum.parent_panel):
-            #     hiddify_api.sync_child_to_parent()
             global_config_form = get_global_config_form(True)
         else:
             hutils.flask.flash((_('config.validation-error')), 'danger')
@@ -94,7 +95,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/QuickSetup.py

@@ -8,7 +8,6 @@ import wtforms as wtf
 from flask_wtf import FlaskForm
 from flask_bootstrap import SwitchField
 from hiddifypanel.panel import hiddify
-from wtforms.fields import *
 from flask_classful import FlaskView
 from wtforms.validators import ValidationError
 # from gettext import gettext as _
@@ -61,7 +60,7 @@ class QuickSetup(FlaskView):
             Domain.query.filter(Domain.domain == f'{hutils.network.get_ip_str(4)}.sslip.io').delete()
             db.session.add(Domain(domain=quick_form.domain.data.lower(), mode=DomainType.direct))
             set_hconfig(ConfigEnum.block_iran_sites, quick_form.block_iran_sites.data)
-            set_hconfig(ConfigEnum.decoy_domain,quick_form.decoy_domain.data)
+            set_hconfig(ConfigEnum.decoy_domain, quick_form.decoy_domain.data)
             # hiddify.bulk_register_configs([
             #     # {"key": ConfigEnum.telegram_enable, "value": quick_form.enable_telegram.data == True},
             #     # {"key": ConfigEnum.vmess_enable, "value": quick_form.enable_vmess.data == True},
@@ -84,12 +83,16 @@ class QuickSetup(FlaskView):
 
 def get_lang_form(empty=False):
     class LangForm(FlaskForm):
-        admin_lang = wtf.fields.SelectField(_("config.admin_lang.label"), choices=[("en", _("lang.en")), ("fa", _("lang.fa")), ("pt", _(
-            "lang.pt")), ("zh", _("lang.zh")), ("ru", _("lang.ru"))], description=_("config.admin_lang.description"), default=hconfig(ConfigEnum.admin_lang))
-        # lang=wtf.fields.SelectField(_("config.lang.label"),choices=[("en",_("lang.en")),("fa",_("lang.fa"))],description=_("config.lang.description"),default=hconfig(ConfigEnum.lang))
-        country = wtf.fields.SelectField(_("config.country.label"), choices=[("ir", _("Iran")), ("zh", _(
-            "China")), ("other", "Others")], description=_("config.country.description"), default=hconfig(ConfigEnum.country))
-        lang_submit = wtf.fields.SubmitField(_('Submit'))
+        admin_lang = wtf.SelectField(
+            _("config.admin_lang.label"), choices=[("en", _("lang.en")), ("fa", _("lang.fa")), ("pt", _("lang.pt")), ("zh", _("lang.zh")), ("ru", _("lang.ru"))],
+            description=_("config.admin_lang.description"),
+            default=hconfig(ConfigEnum.admin_lang))
+        # lang=wtf.SelectField(_("config.lang.label"),choices=[("en",_("lang.en")),("fa",_("lang.fa"))],description=_("config.lang.description"),default=hconfig(ConfigEnum.lang))
+        country = wtf.SelectField(
+            _("config.country.label"), choices=[("ir", _("Iran")), ("zh", _("China")), ("other", "Others")],
+            description=_("config.country.description"),
+            default=hconfig(ConfigEnum.country))
+        lang_submit = wtf.SubmitField(_('Submit'))
 
     return LangForm(None)if empty else LangForm()
 
@@ -108,13 +111,12 @@ def get_quick_setup_form(empty=False):
     class QuickSetupForm(FlaskForm):
         domain_regex = "^([A-Za-z0-9\\-\\.]+\\.[a-zA-Z]{2,})$"
 
-        domain_validators = [wtf.validators.Regexp(domain_regex, re.IGNORECASE, _("config.Invalid domain")),
-                             validate_domain,
-                             wtf.validators.NoneOf([d.domain.lower() for d in Domain.query.all()], _("config.Domain already used")),
-                             wtf.validators.NoneOf([c.value.lower() for c in StrConfig.query.all() if "fakedomain" in c.key and c.key !=
-                                                   ConfigEnum.decoy_domain], _("config.Domain already used"))
-                             ]
-        domain = wtf.fields.StringField(
+        domain_validators = [
+            wtf.validators.Regexp(domain_regex, re.IGNORECASE, _("config.Invalid domain")),
+            validate_domain,
+            wtf.validators.NoneOf([d.domain.lower() for d in Domain.query.all()], _("config.Domain already used")),
+            wtf.validators.NoneOf([c.value.lower() for c in StrConfig.query.all() if "fakedomain" in c.key and c.key != ConfigEnum.decoy_domain], _("config.Domain already used"))]
+        domain = wtf.StringField(
             _("domain.domain"),
             domain_validators,
             description=_("domain.description"),
@@ -129,9 +131,9 @@ def get_quick_setup_form(empty=False):
         block_iran_sites = SwitchField(_("config.block_iran_sites.label"), description=_(
             "config.block_iran_sites.description"), default=hconfig(ConfigEnum.block_iran_sites))
         # enable_vmess = SwitchField(_("config.vmess_enable.label"), description=_("config.vmess_enable.description"), default=hconfig(ConfigEnum.vmess_enable))
-        decoy_domain = wtf.fields.StringField(_("config.decoy_domain.label"), description=_("config.decoy_domain.description"), default=hconfig(
-            ConfigEnum.decoy_domain), validators=[wtf.validators.Regexp(domain_regex, re.IGNORECASE, _("config.Invalid domain")), hiddify.validate_domain_exist])
-        submit = wtf.fields.SubmitField(_('Submit'))
+        decoy_domain = wtf.StringField(_("config.decoy_domain.label"), description=_("config.decoy_domain.description"), default=hconfig(
+            ConfigEnum.decoy_domain), validators=[wtf.validators.Regexp(domain_regex, re.IGNORECASE, _("config.Invalid domain")), hutils.flask.validate_domain_exist])
+        submit = wtf.SubmitField(_('Submit'))
 
     return QuickSetupForm(None) if empty else QuickSetupForm()
 
@@ -144,8 +146,7 @@ def validate_domain(form, field):
 
     myip = hutils.network.get_ip(4)
     if dip and myip != dip:
-        raise ValidationError(_("Domain (%(domain)s)-> IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode",
-                              server_ip=myip, domain_ip=dip, domain=domain))
+        raise ValidationError(_("Domain (%(domain)s)-> IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode", server_ip=myip, domain_ip=dip, domain=domain))
 
 
 def admin_link():