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

hiddifypanel/models/domain.py

@@ -1,22 +1,16 @@
 from enum import auto
-from typing import List
-
-from urllib.parse import urlparse
-
+from typing import Dict, List
 from flask import request
-
 from flask_babel import lazy_gettext as _
 from sqlalchemy.orm import backref
-from urllib.parse import urlparse
 from strenum import StrEnum
+from sqlalchemy_serializer import SerializerMixin
 
-from hiddifypanel.database import db
 
+from hiddifypanel.database import db
 from hiddifypanel.models.config import hconfig
 from .child import Child
 from hiddifypanel.models.config_enum import ConfigEnum
-from sqlalchemy.orm import backref
-from sqlalchemy_serializer import SerializerMixin
 
 
 class DomainType(StrEnum):
@@ -69,11 +63,11 @@ class Domain(db.Model, SerializerMixin):
             'mode': self.mode,
             'alias': self.alias,
             'sub_link_only': self.sub_link_only,
-            'child_unique_id': self.child.unique_id if self.child else '',
+            'child_unique_id': self.child.unique_id if self.child else '',  # type: ignore
             'cdn_ip': self.cdn_ip,
             'servernames': self.servernames,
             'grpc': self.grpc,
-            'show_domains': [dd.domain for dd in self.show_domains],
+            'show_domains': [dd.domain for dd in self.show_domains],  # type: ignore
         }
         if dump_child_id:
             data['child_id'] = self.child_id
@@ -124,110 +118,80 @@ class Domain(db.Model, SerializerMixin):
         # TODO: check validity of the range of the port
         return int(hconfig(ConfigEnum.reality_port, self.child_id)) + self.port_index
 
-
-def hdomains(mode):
-    domains = Domain.query.filter(Domain.mode == mode).all()
-    if domains:
-        return [d.domain for d in domains]
-    return []
-
-
-def hdomain(mode):
-    domains = hdomains(mode)
-    if domains:
-        return domains[0]
-    return None
-
-
-def get_hdomains():
-    return {mode: hdomains(mode) for mode in DomainType}
-
-
-def get_domain(domain):
-    return Domain.query.filter(Domain.domain == domain).first()
-
-
-def get_panel_link(child_id: int | None = None) -> Domain | None:
-    if child_id is None:
-        child_id = Child.current().id
-    domains = Domain.query.filter(Domain.mode.in_(
-        [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]),
-        Domain.child_id == child_id
-    ).all()
-    if not domains:
-        return None
-    return domains[0]
-
-
-def get_panel_domains(always_add_ip=False, always_add_all_domains=False) -> List[Domain]:
-    from hiddifypanel import hutils
-    domains = []
-    domains = Domain.query.filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current().id).all()
-    if not len(domains) or always_add_all_domains:
-        domains = Domain.query.filter(Domain.mode.notin_([DomainType.fake, DomainType.reality])).all()
-
-    if len(domains) == 0 and request:
-        domains = [Domain(domain=request.host)]
-    if len(domains) == 0 or always_add_ip:
-        domains += [Domain(domain=hutils.network.get_ip_str(4))]
-    return domains
-
-
-def get_proxy_domains(domain):
-    db_domain = Domain.query.filter(Domain.domain == domain, Domain.child_id == Child.current().id).first()
-    if not db_domain:
-        db_domain = Domain(domain=domain, mode=DomainType.direct, cdn_ip='', show_domains=[])
-    return get_proxy_domains_db(db_domain)
-
-
-def get_proxy_domains_db(db_domain):
-
-    if not db_domain:
-        domain = urlparse(request.base_url).hostname
-        db_domain = Domain(domain=domain, mode=DomainType.direct, show_domains=[])
-        # print("no domain")
-        hutils.flask.flash(_("This domain does not exist in the panel!" + domain))  # type: ignore
-
-    return db_domain.show_domains or Domain.query.all()
-
-
-def get_current_proxy_domains(force_domain=None):
-    domain = force_domain or urlparse(request.base_url).hostname
-    return get_proxy_domains(domain)
-
-
-def add_or_update_domain(commit=True, child_id=0, **domain):
-    dbdomain = Domain.query.filter(Domain.domain == domain['domain']).first()
-    if not dbdomain:
-        dbdomain = Domain(domain=domain['domain'])
-        db.session.add(dbdomain)
-    dbdomain.child_id = child_id
-
-    dbdomain.mode = domain['mode']
-    if (str(domain.get('sub_link_only', False)).lower() == 'true'):
-        dbdomain.mode = DomainType.sub_link_only
-    dbdomain.cdn_ip = domain.get('cdn_ip', '')
-    dbdomain.alias = domain.get('alias', '')
-    dbdomain.grpc = domain.get('grpc', False)
-    dbdomain.servernames = domain.get('servernames', '')
-    show_domains = domain.get('show_domains', [])
-    dbdomain.show_domains = Domain.query.filter(Domain.domain.in_(show_domains)).all()
-    if commit:
-        db.session.commit()
-
-
-def bulk_register_domains(domains, commit=True, remove=False, force_child_unique_id: str | None = None):
-    from hiddifypanel.panel import hiddify
-    child_ids = {}
-    for domain in domains:
-        child_id = hiddify.get_child(unique_id=force_child_unique_id)
-        child_ids[child_id] = 1
-        add_or_update_domain(commit=False, child_id=child_id, **domain)
-    if remove and len(child_ids):
-        dd = {d['domain']: 1 for d in domains}
-        for d in Domain.query.filter(Domain.child_id.in_(child_ids)):
-            if d.domain not in dd:
-                db.session.delete(d)
-
-    if commit:
-        db.session.commit()
+    @classmethod
+    def by_mode(cls, mode: DomainType) -> List['Domain']:
+        domains = Domain.query.filter(Domain.mode == mode).all()
+        if domains:
+            return [d.domain for d in domains]
+        return []
+
+    @classmethod
+    def modes_and_domains(cls) -> Dict[DomainType, List['Domain']]:
+        return {mode: cls.by_mode(mode) for mode in DomainType}
+
+    @classmethod
+    def by_domain(cls, domain: str) -> 'Domain | None':
+        return Domain.query.filter(Domain.domain == domain).first()
+
+    @classmethod
+    def get_panel_link(cls, child_id: int | None = None) -> str | None:
+        if child_id is None:
+            child_id = Child.current().id  # type: ignore
+        domains = Domain.query.filter(Domain.mode.in_(
+            [DomainType.direct, DomainType.cdn, DomainType.worker, DomainType.relay, DomainType.auto_cdn_ip, DomainType.old_xtls_direct, DomainType.sub_link_only]),
+            Domain.child_id == child_id
+        ).all()
+        if not domains:
+            return None
+        return domains[0].domain
+
+    @classmethod
+    def get_domains(cls, always_add_ip=False, always_add_all_domains=False) -> List['Domain']:
+        from hiddifypanel import hutils
+        domains = []
+        domains = Domain.query.filter(Domain.mode == DomainType.sub_link_only, Domain.child_id == Child.current().id).all()
+        if not len(domains) or always_add_all_domains:
+            domains = Domain.query.filter(Domain.mode.notin_([DomainType.fake, DomainType.reality])).all()
+
+        if len(domains) == 0 and request:
+            domains = [Domain(domain=request.host)]  # type: ignore
+        if len(domains) == 0 or always_add_ip:
+            domains += [Domain(domain=hutils.network.get_ip_str(4))]  # type: ignore
+        return domains
+
+    @classmethod
+    def add_or_update(cls, commit=True, child_id=0, **domain):
+        dbdomain = Domain.query.filter(Domain.domain == domain['domain']).first()
+        if not dbdomain:
+            dbdomain = Domain(domain=domain['domain'])  # type: ignore
+            db.session.add(dbdomain)
+        dbdomain.child_id = child_id
+
+        dbdomain.mode = domain['mode']
+        if (str(domain.get('sub_link_only', False)).lower() == 'true'):
+            dbdomain.mode = DomainType.sub_link_only
+        dbdomain.cdn_ip = domain.get('cdn_ip', '')
+        dbdomain.alias = domain.get('alias', '')
+        dbdomain.grpc = domain.get('grpc', False)
+        dbdomain.servernames = domain.get('servernames', '')
+        show_domains = domain.get('show_domains', [])
+        dbdomain.show_domains = Domain.query.filter(Domain.domain.in_(show_domains)).all()
+        if commit:
+            db.session.commit()
+
+    @classmethod
+    def bulk_register(cls, domains, commit=True, remove=False, force_child_unique_id: str | None = None):
+        from hiddifypanel.panel import hiddify
+        child_ids = {}
+        for domain in domains:
+            child_id = hiddify.get_child(unique_id=force_child_unique_id)
+            child_ids[child_id] = 1
+            cls.add_or_update(commit=False, child_id=child_id, **domain)
+        if remove and len(child_ids):
+            dd = {d['domain']: 1 for d in domains}
+            for d in Domain.query.filter(Domain.child_id.in_(child_ids)):
+                if d.domain not in dd:
+                    db.session.delete(d)
+
+        if commit:
+            db.session.commit()

hiddifypanel/models/user.py

@@ -65,7 +65,7 @@ class User(BaseAccount, SerializerMixin):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     last_online = db.Column(db.DateTime, nullable=False, default=datetime.datetime.min)
     # removed
-    expiry_time = db.Column(db.Date, default=datetime.date.today() + relativedelta.relativedelta(months=6))
+    # expiry_time = db.Column(db.Date, default=datetime.date.today() + relativedelta.relativedelta(months=6))
     usage_limit = db.Column(db.BigInteger, default=1000 * ONE_GIG, nullable=False)
     package_days = db.Column(db.Integer, default=90, nullable=False)
     mode = db.Column(db.Enum(UserMode), default=UserMode.no_reset, nullable=False)
@@ -138,15 +138,23 @@ class User(BaseAccount, SerializerMixin):
         # print("start_date",user.start_date, "pack",package_mode_dic.get(user.mode,10000), "total",(datetime.date.today()-user.start_date).days)
         # if user.mode==UserMode.daily:
         #     return 0
-        res = True
         if not self.last_reset_time:
-            res = True
+            return True
         elif not self.start_date or (datetime.date.today() - self.last_reset_time).days == 0:
-            res = False
-        else:
-            res = ((datetime.date.today() - self.start_date).days % package_mode_dic.get(self.mode, 10000)) == 0
+            return False
+        return ((datetime.date.today() - self.start_date).days % package_mode_dic.get(self.mode, 10000)) == 0
+
+    def reset_usage(self, commit: bool = False):
+        '''Resets the user usages'''
+        self.last_reset_time = datetime.date.today()
+        self.current_usage_GB = 0
+
+        # there's no usage of UserDetail yet, but we reset it too
+        # if ud := UserDetail.query.filter(UserDetail.user_id == self.id).first():
+        #    ud.current_usage_GB = 0
 
-        return res
+        if commit:
+            db.session.commit()
 
     def days_to_reset(self):
         """
@@ -190,6 +198,8 @@ class User(BaseAccount, SerializerMixin):
 
     @classmethod
     def by_uuid(cls, uuid: str, create: bool = False) -> 'User':
+        if not isinstance(uuid, str):
+            uuid = str(uuid)
         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)
@@ -213,38 +223,44 @@ class User(BaseAccount, SerializerMixin):
         else:
             dbuser.added_by = 1
 
-        if data.get('expiry_time', ''):
-            last_reset_time = hutils.convert.json_to_date(data.get('last_reset_time', '')) or datetime.date.today()
-
-            expiry_time = hutils.convert.json_to_date(data['expiry_time'])
-            dbuser.start_date = last_reset_time
-            dbuser.package_days = (expiry_time - last_reset_time).days  # type: ignore
+        # if data.get('expiry_time', ''): #v4
+        #     last_reset_time = hutils.convert.json_to_time(data.get('last_reset_time', '')) or datetime.date.today()
 
-        elif 'package_days' in data:
+        #     expiry_time = hutils.convert.json_to_date(data['expiry_time'])
+        #     dbuser.start_date = last_reset_time
+        #     dbuser.package_days = (expiry_time - last_reset_time).days  # type: ignore
+        # el
+        if 'package_days' in data:
             dbuser.package_days = data['package_days']
             if data.get('start_date', ''):
                 dbuser.start_date = hutils.convert.json_to_date(data['start_date'])
             else:
                 dbuser.start_date = None
-        dbuser.current_usage_GB = data.get('current_usage_GB', 0)
 
-        dbuser.usage_limit_GB = data.get('usage_limit_GB', 1000)
+        if (c_GB := data.get('current_usage_GB')) is not None:
+            dbuser.current_usage_GB = c_GB
+        elif (c := data.get('current_usage')) is not None:
+            dbuser.current_usage = c
+        else:
+            dbuser.current_usage = 0
+
+        if (l_GB := data.get('usage_limit_GB')) is not None:
+            dbuser.usage_limit_GB = l_GB
+        elif (l := data.get('usage_limit')) is not None:
+            dbuser.usage_limit = l
+        else:
+            dbuser.usage_limit_GB = 1000
+
         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:
-        #     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:
-        #     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':
             mode = UserMode.no_reset
@@ -271,6 +287,9 @@ class User(BaseAccount, SerializerMixin):
         from hiddifypanel import hutils
         if dump_id:
             base['id'] = self.id
+        if not base.get('lang'):
+            from hiddifypanel.models import hconfig, ConfigEnum
+            base['lang'] = hconfig(ConfigEnum.lang)
         return {**base,
                 'last_online': hutils.convert.time_to_json(self.last_online) if convert_date else self.last_online,
                 'usage_limit_GB': self.usage_limit_GB,
@@ -278,7 +297,8 @@ class User(BaseAccount, SerializerMixin):
                 'mode': self.mode,
                 '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,
+                'last_reset_time': hutils.convert.time_to_json(self.last_reset_time) if convert_date else self.last_reset_time,
+                # 'expiry_time': hutils.convert.date_to_json(self.expiry_time) if convert_date else self.expiry_time,
                 '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,

hiddifypanel/panel/admin/Actions.py

@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-import os
 import urllib.request
-
+import json
 from flask_classful import FlaskView, route
 from flask import render_template, request, redirect, g
 from hiddifypanel.hutils.flask import hurl_for
@@ -62,8 +60,7 @@ class Actions(FlaskView):
         if int(hconfig(ConfigEnum.db_version)) < 9:
             return ("Please update your panel before this action.")
         if hutils.node.is_child():
-            if not hutils.node.child.sync_with_parent():
-                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
+            hutils.node.run_node_op_in_bg(hutils.node.child.sync_with_parent)
 
         domain_changed = request.args.get("domain_changed", str(domain_changed)).lower() == "true"
         complete_install = request.args.get("complete_install", str(complete_install)).lower() == "true"
@@ -81,7 +78,7 @@ class Actions(FlaskView):
         admin_links = f"<h5 >{_('Admin Links')}</h5><ul>"
 
         admin_links += f"<li><span class='badge badge-danger'>{_('Not Secure')}</span>: <a class='badge ltr share-link' href='{hiddify.get_account_panel_link(g.account, server_ip,is_https=False)}'>{hiddify.get_account_panel_link(g.account, server_ip,is_https=False)}</a></li>"
-        domains = get_panel_domains()
+        domains = Domain.get_domains()
         # domains=[*domains,f'{server_ip}.sslip.io']
 
         for d in domains:
@@ -182,12 +179,10 @@ class Actions(FlaskView):
 
     @ login_required(roles={Role.super_admin})
     def update_usage(self):
-
-        import json
-
+        color = 'white' if g.darkmode else 'black'
         return render_template("result.html",
                                out_type="info",
-                               out_msg=f'<pre class="ltr">{json.dumps(usage.update_local_usage(),indent=2)}</pre>',
+                               out_msg=f'<pre class="ltr" style="color:{color};">{json.dumps(usage.update_local_usage(),indent=2)}</pre>',
                                log_file_url=None
                                )
 
@@ -197,4 +192,4 @@ def get_log_api_url():
 
 
 def get_domains():
-    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=False)]
+    return [str(d.domain).replace("*", hutils.random.get_random_string(3, 6)) for d in Domain.get_domains(always_add_all_domains=True, always_add_ip=False)]

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -87,7 +87,7 @@ class AdminstratorAdmin(AdminLTEModelView):
 
     def _ul_formatter(view, context, model, name):
 
-        return Markup(" ".join([hiddify.get_html_user_link(model, d) for d in get_panel_domains()]))
+        return Markup(" ".join([hiddify.get_html_user_link(model, d) for d in Domain.get_domains()]))
 
     @property
     def can_create(self):
@@ -216,12 +216,6 @@ class AdminstratorAdmin(AdminLTEModelView):
     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)
-
     def on_form_prefill(self, form, id=None):
 
         if g.account.mode != AdminMode.super_admin:
@@ -242,8 +236,8 @@ class AdminstratorAdmin(AdminLTEModelView):
 
     def after_model_change(self, form, model, is_created):
         if hutils.node.is_parent():
-            hutils.node.parent.send_sync_req_to_childs()
+            hutils.node.run_node_op_in_bg(hutils.node.parent.request_childs_to_sync)
 
     def after_model_delete(self, model):
         if hutils.node.is_parent():
-            hutils.node.parent.send_sync_req_to_childs()
+            hutils.node.run_node_op_in_bg(hutils.node.parent.request_childs_to_sync)

hiddifypanel/panel/admin/Backup.py

@@ -1,5 +1,4 @@
-#!/usr/bin/env python3
-from flask import render_template, request, jsonify, redirect, g
+from flask import render_template, request, jsonify, g
 from flask_wtf.file import FileField, FileRequired
 from flask_bootstrap import SwitchField
 from flask_babel import gettext as _
@@ -25,12 +24,10 @@ class Backup(FlaskView):
 
     # @route("/backupfile")
     def backupfile(self):
-        response = jsonify(
-            hiddify.dump_db_to_dict()
-        )
-        o = urlparse(request.base_url)
-        domain = o.hostname
-        response.headers.add('Content-disposition', f'attachment; filename=hiddify-{domain}-{datetime.now()}.json')
+        response = jsonify(hiddify.dump_db_to_dict())
+        domain = urlparse(request.base_url).hostname
+        filename = f'hiddify-{domain}-{datetime.now()}.json'
+        response.headers.add('Content-disposition', f'attachment; filename={filename}')
 
         return response
 

hiddifypanel/panel/admin/Dashboard.py

@@ -21,10 +21,9 @@ class Dashboard(FlaskView):
         if hconfig(ConfigEnum.first_setup):
             return redirect(hurl_for("admin.QuickSetup:index"))
 
-        if hiddifypanel.__release_date__ + datetime.timedelta(days=20) < datetime.datetime.now():
+        if hutils.utils.is_panel_outdated():
             hutils.flask.flash(_('This version of hiddify panel is outdated. Please update it from admin area.'), "danger")  # type: ignore
-        bot = None
-        # if hconfig(ConfigEnum.license):
+
         childs = None
         admin_id = request.args.get("admin_id") or g.account.id
         if admin_id not in g.account.recursive_sub_admins_ids():
@@ -44,7 +43,7 @@ class Dashboard(FlaskView):
                         c.is_active = True
 
         def_user = None if len(User.query.all()) > 1 else User.query.filter(User.name == 'default').first()
-        domains = get_panel_domains()
+        domains = Domain.get_domains()
         sslip_domains = [d.domain for d in domains if "sslip.io" in d.domain]
 
         if def_user and sslip_domains:

hiddifypanel/panel/admin/DomainAdmin.py

@@ -12,7 +12,7 @@ from hiddifypanel.panel.run_commander import Command, commander
 from wtforms.validators import Regexp, ValidationError
 
 from hiddifypanel.models import *
-from hiddifypanel.panel import hiddify, cf_api, custom_widgets
+from hiddifypanel.panel import hiddify, custom_widgets
 from .adminlte import AdminLTEModelView
 from hiddifypanel import hutils
 
@@ -110,6 +110,9 @@ class DomainAdmin(AdminLTEModelView):
 
     def _domain_ip(view, context, model, name):
         dip = hutils.network.get_domain_ip(model.domain)
+        # The get_domain_ip function uses the socket library, which relies on the system DNS resolver. So it may sometimes use cached data, which is not desirable
+        if not dip:
+            dip = hutils.network.resolve_domain_with_api(model.domain)
         myip = hutils.network.get_ip(4)
         if myip == dip and model.mode == DomainType.direct:
             badge_type = ''
@@ -144,6 +147,7 @@ class DomainAdmin(AdminLTEModelView):
         # Pre-select the related domains in the checkbox list
         # form.show_domains = [d.id for d in Domain.query.all()]
 
+    # TODO: refactor this function
     def on_model_change(self, form, model, is_created):
         model.domain = model.domain.lower()
 
@@ -171,16 +175,16 @@ class DomainAdmin(AdminLTEModelView):
             raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
         skip_check = "*" in model.domain
-        if hconfig(ConfigEnum.cloudflare) and model.mode != DomainType.fake:
+        if hconfig(ConfigEnum.cloudflare) and model.mode not in [DomainType.fake, DomainType.relay, DomainType.reality]:
             try:
                 proxied = model.mode in [DomainType.cdn, DomainType.auto_cdn_ip]
-                cf_api.add_or_update_domain(model.domain, str(ipv4_list[0]), "A", proxied=proxied)
+                hutils.network.cf_api.add_or_update_dns_record(model.domain, str(ipv4_list[0]), "A", proxied=proxied)
                 if ipv6_list:
-                    cf_api.add_or_update_domain(model.domain, str(ipv6_list[0]), "AAAA", proxied=proxied)
+                    hutils.network.cf_api.add_or_update_dns_record(model.domain, str(ipv6_list[0]), "AAAA", proxied=proxied)
 
                 skip_check = True
             except Exception as e:
-                raise ValidationError(__("Can not connect to Cloudflare.") + f' {e}')
+                raise ValidationError(__("cloudflare.error") + 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')
@@ -233,19 +237,20 @@ class DomainAdmin(AdminLTEModelView):
                 for d in v.split(","):
                     if not d:
                         continue
-                    if not hutils.network.is_domain_reality_friendly(d):
+                    if not hutils.network.is_domain_reality_friendly(d):  # the minimum requirement for the REALITY protocol is to have tls1.3 and h2
                         raise ValidationError(_("Domain is not REALITY friendly!") + f' {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
+                        server_asn = hutils.network.get_ip_asn(ipv4_list[0])
+                        domain_asn = hutils.network.get_ip_asn(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 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}')
+                    msg = _("REALITY Fallback domain is not compaitble with server names!") + f' {d} != {model.domain}'
+                    hutils.flask.flash(msg, 'warning')
 
         if (model.cdn_ip):
             try:
@@ -253,7 +258,7 @@ class DomainAdmin(AdminLTEModelView):
             except BaseException:
                 raise ValidationError(_("Error in auto cdn format"))
 
-        old_db_domain = get_domain(model.domain)
+        old_db_domain = Domain.by_domain(model.domain)
         if is_created or not old_db_domain or old_db_domain.mode != model.mode:
             # return hiddify.reinstall_action(complete_install=False, domain_changed=True)
             hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=True)
@@ -265,15 +270,16 @@ class DomainAdmin(AdminLTEModelView):
     def on_model_delete(self, model):
         if len(Domain.query.all()) <= 1:
             raise ValidationError(f"at least one domain should exist")
-        # ShowDomain.query.filter_by(related_id == model.id).delete()
+        if hconfig(ConfigEnum.cloudflare) and model.mode not in [DomainType.fake, DomainType.reality, DomainType.relay]:
+            if not hutils.network.cf_api.delete_dns_record(model.domain):
+                hutils.flask.flash(_('cf-delete.failed'), 'warning')  # type: ignore
         model.showed_by_domains = []
         # db.session.commit()
         hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=True)
 
     def after_model_delete(self, model):
         if hutils.node.is_child():
-            if not hutils.node.child.sync_with_parent():
-                hutils.flask.flash(_('child.sync-failed'), 'danger')  # type: ignore
+            hutils.node.run_node_op_in_bg(hutils.node.child.sync_with_parent, *[hutils.node.child.SyncFields.domains])
 
     def after_model_change(self, form, model, is_created):
         if hconfig(ConfigEnum.first_setup):
@@ -281,8 +287,7 @@ class DomainAdmin(AdminLTEModelView):
         if model.need_valid_ssl:
             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
+            hutils.node.run_node_op_in_bg(hutils.node.child.sync_with_parent, *[hutils.node.child.SyncFields.domains])
 
     def is_accessible(self):
         if login_required(roles={Role.super_admin, Role.admin})(lambda: True)() != True:

hiddifypanel/panel/admin/ProxyAdmin.py

@@ -36,6 +36,8 @@ class ProxyAdmin(FlaskView):
             db.session.commit()
             # print(cat,vs)
             hutils.proxy.get_proxies.invalidate_all()
+            if hutils.node.is_child():
+                hutils.node.run_node_op_in_bg(hutils.node.child.sync_with_parent, *[hutils.node.child.SyncFields.hconfigs])
             hiddify.check_need_reset(old_configs)
             all_proxy_form = get_all_proxy_form(True)
 
@@ -57,8 +59,7 @@ class ProxyAdmin(FlaskView):
             db.session.commit()
             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.node.run_node_op_in_bg(hutils.node.child.sync_with_parent, *[hutils.node.child.SyncFields.proxies])
             hutils.flask.flash_config_success(restart_mode=ApplyMode.apply, domain_changed=False)
             global_config_form = get_global_config_form(True)
         else:
@@ -66,14 +67,6 @@ class ProxyAdmin(FlaskView):
 
         return render_template('proxy.html', global_config_form=global_config_form, detailed_config_form=all_proxy_form)
 
-        import flask_babel
-
-        # form=HelloForm()
-        # # return render('config.html',form=form)
-        # return render_template('config.html',form=HelloForm())
-        form = get_config_form()
-        return render_template('config.html', form=form)
-
 
 def get_global_config_form(empty=False):
     boolconfigs = BoolConfig.query.all()

hiddifypanel/panel/admin/QuickSetup.py

@@ -150,5 +150,5 @@ def validate_domain(form, field):
 
 
 def admin_link():
-    domains = get_panel_domains()
+    domains = Domain.get_domains()
     return hiddify.get_account_panel_link(g.account, domains[0] if len(domains)else hutils.network.get_ip_str(4))