hiddifypanel 10.80.0__py3-none-any.whl → 10.80.0.dev8__py3-none-any.whl

hiddifypanel/panel/admin/DomainAdmin.py

@@ -16,7 +16,6 @@ from hiddifypanel.panel import hiddify, custom_widgets
 from .adminlte import AdminLTEModelView
 from hiddifypanel import hutils
 
-from loguru import logger
 from flask import current_app
 # Define a custom field type for the related domains
 
@@ -153,165 +152,132 @@ class DomainAdmin(AdminLTEModelView):
 
     # TODO: refactor this function
     def on_model_change(self, form, model, is_created):
-        # Sanitize domain input
-        model.domain = (model.domain or '').lower().strip()
-        
-        # Basic validation
+        model.domain = (model.domain or '').lower()
         if model.domain == '' and model.mode != DomainType.fake:
             raise ValidationError(_("domain.empty.allowed_for_fake_only"))
+        configs = get_hconfigs()
+        for c in configs:
+            if "domain" in c and c not in [ConfigEnum.decoy_domain, ConfigEnum.reality_fallback_domain] and c.category != 'hidden':
+                if model.domain == configs[c]:
+                    raise ValidationError(_("You have used this domain in: ") + _(f"config.{c}.label"))
+
+        for td in Domain.query.filter(Domain.mode == DomainType.reality, Domain.domain != model.domain).all():
+            # print(td)
+            if td.servernames and (model.domain in td.servernames.split(",")):
+                raise ValidationError(_("You have used this domain in: ") + _(f"config.reality_server_names.label") + td.domain)
+
+        if is_created and Domain.query.filter(Domain.domain == model.domain, Domain.child_id == model.child_id).count() > 1:
+            raise ValidationError(_("You have used this domain in: "))
 
-        self._validate_not_used_before(model,is_created)
         ipv4_list = hutils.network.get_ips(4)
         ipv6_list = hutils.network.get_ips(6)
-        server_ips = [*ipv4_list, *ipv6_list]
 
-        if not server_ips:
+        if not ipv4_list and not ipv6_list:
             raise ValidationError(_("Couldn't find your ip addresses"))
 
-        # Validate domain based on mode
         if "*" in model.domain and model.mode not in [DomainType.cdn, DomainType.auto_cdn_ip]:
             raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-        cloudflare_updated=self._update_cloudflare(model, ipv4_list,ipv6_list)
-        
-        
-        self._validate_domain_ips(model, server_ips)
-
-        # Handle CDN IP settings
-        if model.mode == DomainType.direct and model.cdn_ip:
-            model.cdn_ip = ""
-            raise ValidationError(_("Specifying CDN IP is only valid for CDN mode"))
-            
-        if model.mode == DomainType.fake and not model.cdn_ip:
-            model.cdn_ip = str(server_ips[0])
-            
-        if model.cdn_ip:
-            try:
-                hutils.network.auto_ip_selector.get_clean_ip(str(model.cdn_ip))
-            except Exception:
-                raise ValidationError(_("Error in auto cdn format"))
-                    
-        # Update show domains
-        if len(model.show_domains) == Domain.query.count():
-            model.show_domains = []
-                
-        # Handle mode-specific settings
-        if model.mode == DomainType.old_xtls_direct and not hconfig(ConfigEnum.xtls_enable):
-            set_hconfig(ConfigEnum.xtls_enable, True)
-            hutils.proxy.get_proxies().invalidate_all()
-        elif model.mode == DomainType.reality:
-            self._validate_reality_settings(model, server_ips)
-                
-            # Signal config update if needed
-        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_config, domain_changed=True)
-
-            
-
-    def _update_cloudflare(self, model, ipv4_list,ipv6_list):
+        skip_check = "*" in model.domain or model.domain == ""
         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]
-                if ipv4_list:
-                    hutils.network.cf_api.add_or_update_dns_record(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:
                     hutils.network.cf_api.add_or_update_dns_record(model.domain, str(ipv6_list[0]), "AAAA", proxied=proxied)
-                return True
+
+                skip_check = True
             except Exception as e:
                 raise ValidationError(__("cloudflare.error") + f' {e}')
-        return False
+        # 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: "))
 
-    def _validate_reality_settings(self, model, server_ips):
-        """Validate REALITY protocol settings with proper error handling"""
-        if not hconfig(ConfigEnum.reality_enable):
-            set_hconfig(ConfigEnum.reality_enable, True)
-            hutils.proxy.get_proxies().invalidate_all()
+        dips = hutils.network.get_domain_ips(model.domain)
+        server_ips = [*ipv4_list, *ipv6_list]
+        if model.sub_link_only:
+            if not dips:
+                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
+        elif not skip_check:
+            if not dips:
+                raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
+
+            domain_ip_is_same_as_panel = False
+
+            for mip in server_ips:
+                domain_ip_is_same_as_panel |= mip in dips
+            server_ips_str = ', '.join(list(map(str, server_ips)))
+            dips_str = ', '.join(list(map(str, dips)))
+
+            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='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=server_ips_str, domain_ip=dips_str))  # 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=server_ips_str, domain_ip=dips_str))  # 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:
+            model.cdn_ip = ""
+            raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
 
-        model.servernames = (model.servernames or model.domain).lower().strip()
-        domains_to_check = set()
-        for v in [model.domain, model.servernames]:
-            domains_to_check.update(d.strip() for d in v.split(",") if d.strip())
+        if model.mode == DomainType.fake and not model.cdn_ip:
+            model.cdn_ip = str(server_ips[0])
 
-        for d in domains_to_check:
-            # Check REALITY compatibility
-            if not hutils.network.is_domain_reality_friendly(d):
-                raise ValidationError(_("Domain is not REALITY friendly!") + f' {d}')
+        # if model.mode==DomainType.fake and model.cdn_ip!=myip:
+        #     raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
 
-            try:
-                if not hutils.network.is_in_same_asn(d, server_ips[0]):
-                    domain_ips = hutils.network.get_domain_ips(d)
-                    if domain_ips:
-                        dip = next(iter(domain_ips))
+        # # Update the many-to-many relationship
+        if len(model.show_domains) == Domain.query.count():
+            model.show_domains = []
+        if model.mode == DomainType.old_xtls_direct:
+            if not hconfig(ConfigEnum.xtls_enable):
+                set_hconfig(ConfigEnum.xtls_enable, True)
+                hutils.proxy.get_proxies().invalidate_all()
+        elif model.mode == DomainType.reality:
+            if not hconfig(ConfigEnum.reality_enable):
+                set_hconfig(ConfigEnum.reality_enable, True)
+                hutils.proxy.get_proxies().invalidate_all()
+            model.servernames = (model.servernames or model.domain).lower()
+            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):  # 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, server_ips[0]):
+                        dip = next(iter(dips))
                         server_asn = hutils.network.get_ip_asn(server_ips[0])
-                        domain_asn = hutils.network.get_ip_asn(dip)
-                        msg = _("domain.reality.asn_issue")
-                        if server_asn or domain_asn:
-                            msg += f"<br> Server ASN={server_asn}<br>{d}_ASN={domain_asn}"
+                        domain_asn = hutils.network.get_ip_asn(dip)  # type: ignore
+                        msg = _("domain.reality.asn_issue") + \
+                            (f"<br> Server ASN={server_asn}<br>{d}_ASN={domain_asn}" if server_asn or domain_asn else "")
                         hutils.flask.flash(msg, 'warning')
-            except Exception as e:
-                logger.warning(f"ASN check failed for domain {d}: {str(e)}")
-
-        # Check fallback compatibility
-        for d in model.servernames.split(","):
-            if d.strip() and not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):
-                msg = _("REALITY Fallback domain is not compatible with server names!") + f' {d} != {model.domain}'
-                hutils.flask.flash(msg, 'warning')
 
+            for d in model.servernames.split(","):
+                if not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):
+                    msg = _("REALITY Fallback domain is not compaitble with server names!") + f' {d} != {model.domain}'
+                    hutils.flask.flash(msg, 'warning')
 
-    def _validate_not_used_before(self, model,is_created):
-        configs = get_hconfigs()
-        for c in configs:
-            if "domain" in c and c not in [ConfigEnum.decoy_domain, ConfigEnum.reality_fallback_domain] and c.category != 'hidden':
-                if model.domain == configs[c]:
-                    raise ValidationError(_("You have used this domain in: ") + _(f"config.{c}.label"))
-
-        for td in Domain.query.filter(Domain.mode == DomainType.reality, Domain.domain != model.domain).all():
-            # print(td)
-            if td.servernames and (model.domain in td.servernames.split(",")):
-                raise ValidationError(_("You have used this domain in: ") + _(f"config.reality_server_names.label") + td.domain)
+        if (model.cdn_ip):
+            try:
+                hutils.network.auto_ip_selector.get_clean_ip(str(model.cdn_ip))
+            except BaseException:
+                raise ValidationError(_("Error in auto cdn format"))
 
-        if is_created and Domain.query.filter(Domain.domain == model.domain, Domain.child_id == model.child_id).count() > 1:
-            raise ValidationError(_("You have used this domain in: "))
+        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_config, domain_changed=True)
 
-    def _validate_domain_ips(self, model, server_ips):
-        """Validate domain IP resolution and matching"""
-        
-        # Skip validation for wildcard or empty domains
-        if (model.domain.startswith('*') or not model.domain) and model.mode not in [DomainType.direct]:
-            return True
-        if model.mode in [DomainType.fake, DomainType.reality, DomainType.relay]:
-            return True
-        # Resolve domain IPs with timeout
-        try:
-            dips = hutils.network.get_domain_ips(model.domain)
-        except Exception as e:
-            logger.error(f"Error resolving domain {model.domain}: {str(e)}")
-            raise ValidationError(_("Domain cannot be resolved! Please check DNS settings"))
-        
-        # Validate resolution success
-        if not dips:
-            raise ValidationError(_("Domain cannot be resolved! Please check DNS settings"))
-        
-        # Check IP matching based on mode
-        domain_ip_matches_server = any(ip in dips for ip in server_ips)
-        server_ips_str = ', '.join(map(str, server_ips))
-        dips_str = ', '.join(map(str, dips))
-    
-        if not domain_ip_matches_server and model.mode in [DomainType.direct]:
-            raise ValidationError(
-                __("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode",
-                    server_ip=server_ips_str, domain_ip=dips_str))
-                
-        if domain_ip_matches_server and model.mode in [DomainType.cdn, DomainType.relay, DomainType.fake, DomainType.auto_cdn_ip]:
-            raise ValidationError(
-                __("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
-                    server_ip=server_ips_str, domain_ip=dips_str))
-                
-        return True
-    
-        
     # def after_model_change(self,form, model, is_created):
     #     if model.show_domains.count==0:
     #         db.session.bulk_save_objects(ShowDomain(model.id,model.id))

hiddifypanel/panel/admin/QuickSetup.py

@@ -72,7 +72,7 @@ def get_lang_form(empty=False):
             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")), ("ru", _("Russia")),  ("other", "Others")],
+            _("config.country.label"), choices=[("ir", _("Iran")), ("zh", _("China")), ("other", "Others")],
             description=_("config.country.description"),
             default=hconfig(ConfigEnum.country))
         lang_submit = wtf.SubmitField(_('Submit'))
@@ -251,11 +251,11 @@ def validate_domain(form, field):
     if dip is None:
         raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-    myips = hutils.network.get_ips()
-      # Fixed: Changed from get_ip(4) to get_ip(6)
-    if dip not in myips:
+    myip = hutils.network.get_ip(4)
+    myip6 = hutils.network.get_ip(4)
+    if dip and myip != dip and (not myip6 or myip6 != 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=myips, domain_ip=dip, domain=domain))
+                              server_ip=myip, domain_ip=dip, domain=domain))
 
 
 def validate_domain_cdn(form, field):
@@ -266,10 +266,10 @@ def validate_domain_cdn(form, field):
     if dip is None:
         raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-    myips = hutils.network.get_ips()
-    if dip in myips:
+    myip = hutils.network.get_ip(4)
+    if myip == dip:
         raise ValidationError(_("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
-                              server_ip=myips, domain_ip=dip, domain=domain))
+                              server_ip=myip, domain_ip=dip, domain=domain))
 
 
 def admin_link():

hiddifypanel/panel/admin/UserAdmin.py

@@ -27,7 +27,7 @@ from hiddifypanel import hutils
 class UserAdmin(AdminLTEModelView):
     column_default_sort = ('id', False)  # Sort by username in ascending order
 
-    column_sortable_list = ["is_active", "name", "current_usage", 'mode', "remaining_days", "max_ips", "comment", 'last_online', "uuid"]
+    column_sortable_list = ["is_active", "name", "current_usage", 'mode', "remaining_days","max_ips", "comment", 'last_online', "uuid", 'remaining_days']
     column_searchable_list = ["uuid", "name"]
     column_list = ["is_active", "name", "UserLinks", "current_usage", "remaining_days", "comment", 'last_online', 'mode', 'admin', "uuid"]
     column_editable_list = ["comment", "name", "uuid"]
@@ -131,7 +131,7 @@ class UserAdmin(AdminLTEModelView):
         if model.is_active:
             link = '<i class="fa-solid fa-circle-check text-success"></i> '
         elif len(model.devices):
-            link = f'<i class="fa-solid fa-users-slash text-danger" title="{_("Too many Connected IPs")}"></i>'
+            link = '<i class="fa-solid fa-users-slash text-danger" title="{_("Too many Connected IPs")}"></i>'
         else:
             link = '<i class="fa-solid fa-circle-xmark text-danger"></i> '
 
@@ -161,8 +161,8 @@ class UserAdmin(AdminLTEModelView):
 
     def _usage_formatter(view, context, model, name):
         u = round(model.current_usage_GB, 3)
-        t = max(round(model.usage_limit_GB, 3), 0.001)  # Prevent division by zero
-        rate = min(round(u * 100 / t), 100)  # Cap at 100%
+        t = round(model.usage_limit_GB, 3)
+        rate = round(u * 100 / (t + 0.000001))
         state = "danger" if u >= t else ('warning' if rate > 80 else 'success')
         color = "#ff7e7e" if u >= t else ('#ffc107' if rate > 80 else '#9ee150')
         return Markup(f"""
@@ -225,45 +225,38 @@ class UserAdmin(AdminLTEModelView):
 
     def on_form_prefill(self, form, id=None):
         # print("================",form._obj.start_date)
-        if form._obj is None:
-            return
-
-        if id is None or form._obj.start_date is None or form._obj.current_usage==0:
+        if id is None or form._obj is None or form._obj.start_date is None or form._obj.current_usage==0:
             msg = _("Package not started yet.")
             # form.reset['class']="d-none"
-        if form._obj.start_date is None:
-            if hasattr(form, 'reset_days'):
+            if form._obj.start_date is None:
                 delattr(form, 'reset_days')
+            if form._obj.current_usage==0:
+                delattr(form, 'reset_usage')
+            # delattr(form,'disable_user')
         else:
-            remaining = form._obj.remaining_days
+            remaining = form._obj.remaining_days  # remaining_days(form._obj)
             relative_remaining = hutils.convert.format_timedelta(datetime.timedelta(days=remaining))
             msg = _("Remaining about %(relative)s, exactly %(days)s days", relative=relative_remaining, days=remaining)
             form.reset_days.label.text += f" ({msg})"
+            usr_usage = f" ({_('user.home.usage.title')} {round(form._obj.current_usage_GB,3)}GB)"
+            form.reset_usage.label.text += usr_usage
+            form.reset_usage.data = False
             form.reset_days.data = False
 
-        # Handle reset_usage field
-        if form._obj.current_usage == 0:
-            if hasattr(form, 'reset_usage'):
-                delattr(form, 'reset_usage')
-        else:
-            usr_usage = f" ({_('user.home.usage.title')} {round(form._obj.current_usage_GB,3)}GB)"
-            if hasattr(form, 'reset_usage'):
-                form.reset_usage.label.text += usr_usage
-                form.reset_usage.data = False
-            
-            if hasattr(form, 'usage_limit'):
-                form.usage_limit.label.text += usr_usage
-
-        # Handle package days info
-        if form._obj.start_date and hasattr(form, 'package_days'):
-            started = form._obj.start_date - datetime.date.today()
-            msg = _("Started from %(relative)s", relative=hutils.convert.format_timedelta(started))
-            form.package_days.label.text += f" ({msg})"
-            if started.days <= 0:
-                exact_start = _("Started %(days)s days ago", days=-started.days)
-            else:
-                exact_start = _("Will Start in %(days)s days", days=started.days)
-            form.package_days.description += f" ({exact_start})"
+            form.usage_limit.label.text += usr_usage
+
+            # if form._obj.mode==UserMode.disable:
+            #     delattr(form,'disable_user')
+            # form.disable_user.data=form._obj.mode==UserMode.disable
+            if form._obj.start_date:
+                started = form._obj.start_date - datetime.date.today()
+                msg = _("Started from %(relative)s", relative=hutils.convert.format_timedelta(started))
+                form.package_days.label.text += f" ({msg})"
+                if started.days <= 0:
+                    exact_start = _("Started %(days)s days ago", days=-started.days)
+                else:
+                    exact_start = _("Will Start in %(days)s days", days=started.days)
+                form.package_days.description += f" ({exact_start})"
 
     def get_edit_form(self):
         form = super().get_edit_form()
@@ -274,44 +267,26 @@ class UserAdmin(AdminLTEModelView):
         return form
 
     def on_model_change(self, form, model, is_created):
-        # Validate max_ips
-        try:
-            model.max_ips = max(3, min(int(model.max_ips or 10000), 10000))
-        except (ValueError, TypeError):
-            model.max_ips = 1000
-            
-        # Show donation message
+        model.max_ips = max(3, model.max_ips or 10000)
         if len(User.query.all()) % 4 == 0:
             hutils.flask.flash(('<div id="show-modal-donation"></div>'), ' d-none')
-            
-        # Validate UUID
         if not re.match("^[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}$", model.uuid):
             raise ValidationError('Invalid UUID e.g.,' + str(uuid.uuid4()))
-            
-        # Handle reset flags
         if hasattr(form, 'reset_usage') and form.reset_usage.data:
             model.current_usage_GB = 0
-            
+        # if model.telegram_id and model.telegram_id != '0' and not re.match(r"^[1-9]\d*$", model.telegram_id):
+        #     raise ValidationError('Invalid Telegram ID')
+        # if form.disable_user.data:
+        #     model.mode=UserMode.disable
         if hasattr(form, 'reset_days') and form.reset_days.data:
             model.start_date = None
-            
-        # Validate package days
-        try:
-            model.package_days = min(int(model.package_days), 10000)
-        except (ValueError, TypeError):
-            model.package_days = 10000
-            
-        # Handle user ownership
+        model.package_days = min(model.package_days, 10000)
         old_user = User.by_id(model.id)
         if not model.added_by or model.added_by == 1:
             model.added_by = g.account.id
-            
-        # Validate user limits
         if not g.account.can_have_more_users():
             raise ValidationError(_('You have too much users! You can have only %(active)s active users and %(total)s users',
                                   active=g.account.max_active_users, total=g.account.max_users))
-                                  
-        # Handle UUID changes
         if old_user and old_user.uuid != model.uuid:
             user_driver.remove_client(old_user)
 

hiddifypanel/panel/admin/templates/index.html

@@ -192,12 +192,10 @@
     }
 
     function update_from_json(data) {
-        // Use local variables instead of globals
-        const usage_history = data['usage_history'];
-        const onlines = usage_history['m5']['online'];
-        const total_users = usage_history['total']['users'];
-        const stats = data['stats'];
-        
+        usage_history = data['usage_history']
+        onlines = usage_history['m5']['online']
+        total_users = usage_history['total']['users']
+        stats = data['stats']
         info_box("today", "fa-solid fa-calendar", "Today Usage",
             ((usage_history['today']['usage'] / Math.pow(1024, 3)).toFixed(1)) + " GB",
             usage_history['today']['online'] / Math.max(1, total_users) * 100,

hiddifypanel/panel/admin/templates/model/user_list.html

@@ -121,17 +121,9 @@
                         $(document).Toasts('create', {
                             class: 'bg-danger',
                             position: "{{'topRight' if get_locale()=='fa' else 'topLeft'}}",
-                            title: $('<div>').text(status + " " + error).html(),
-                            body: $('<div>').text(JSON.stringify(jqx)).html(),
-                            autohide: true,
-                            delay: 5000
-                        });
-                        
-                        console.error('API Error:', {
-                            status: status,
-                            error: error,
-                            details: jqx
-                        });
+                            title: status + " " + error,
+                            body: JSON.stringify(jqx)
+                        })
                     },
                     success: function (data) {
                         // dialog.modal('hide');

hiddifypanel/panel/cli.py

@@ -13,7 +13,6 @@ from hiddifypanel.panel import hiddify, usage
 from hiddifypanel.database import db
 from hiddifypanel.panel.init_db import init_db
 
-from loguru import logger
 
 def drop_db():
     """Cleans database"""
@@ -30,12 +29,7 @@ def downgrade():
         os.rename("/opt/hiddify-manager/hiddify-panel/hiddifypanel.db.old", "/opt/hiddify-manager/hiddify-panel/hiddifypanel.db")
 
 
-from celery import shared_task
 def backup():
-    backup_task()
-
-@shared_task(ignore_result=False)
-def backup_task():
     dbdict = hiddify.dump_db_to_dict()
     os.makedirs('backup', exist_ok=True)
     dst = f'backup/{datetime.datetime.now().strftime("%Y_%m_%d__%H_%M_%S")}.json'
@@ -48,12 +42,9 @@ def backup_task():
             register_bot(True)
 
         with open(dst, 'rb') as document:
-            for admin in AdminUser.query.filter(AdminUser.mode == AdminMode.super_admin, AdminUser.telegram_id is not None,AdminUser.telegram_id!=0).all():
+            for admin in AdminUser.query.filter(AdminUser.mode == AdminMode.super_admin, AdminUser.telegram_id is not None).all():
                 caption = ("Backup \n" + admin_links())
-                try:
-                    bot.send_document(admin.telegram_id, document, visible_file_name=dst.replace("backup/", ""), caption=caption[:1000])
-                except Exception as e:
-                    logger.exception(e)
+                bot.send_document(admin.telegram_id, document, visible_file_name=dst.replace("backup/", ""), caption=caption[:min(len(caption), 1000)])
 
 
 def all_configs():

hiddifypanel/panel/commercial/restapi/v1/tgbot.py

@@ -2,7 +2,6 @@ import telebot
 from flask import request
 from apiflask import abort
 from flask_restful import Resource
-import time
 
 from hiddifypanel.models import *
 from hiddifypanel import Events
@@ -12,24 +11,7 @@ logger = telebot.logger
 
 class ExceptionHandler(telebot.ExceptionHandler):
     def handle(self, exception):
-        """Improved error handling for Telegram bot exceptions"""
-        error_msg = str(exception)
-        logger.error(f"Telegram bot error: {error_msg}")
-        
-        try:
-            # Attempt recovery based on error type
-            if "webhook" in error_msg.lower():
-                if hasattr(bot, 'remove_webhook'):
-                    bot.remove_webhook()
-                    logger.info("Removed webhook due to error")
-            elif "connection" in error_msg.lower():
-                # Wait and retry for connection issues
-                time.sleep(5)
-                return True  # Indicates retry
-        except Exception as e:
-            logger.error(f"Error during recovery attempt: {str(e)}")
-        
-        return False  # Don't retry for unknown errors
+        logger.error(exception)
 
 
 bot = telebot.TeleBot("1:2", parse_mode="HTML", threaded=False, exception_handler=ExceptionHandler())

hiddifypanel/panel/commercial/restapi/v2/admin/system_actions.py

@@ -1,5 +1,3 @@
-import asyncio
-import time
 from flask import current_app as app, request
 from flask import g
 from flask.views import MethodView
@@ -18,9 +16,7 @@ class UpdateUserUsageApi(MethodView):
 
     def get(self):
         """System: Update User Usage"""
-        # time.sleep(5)
-        
-        return json.dumps(usage.update_local_usage_not_lock(), indent=2)
+        return json.dumps(usage.update_local_usage(), indent=2)
 
 
 class AllConfigsApi(MethodView):

hiddifypanel/panel/commercial/restapi/v2/admin/user_api.py

@@ -6,8 +6,7 @@ from hiddifypanel.auth import login_required
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
 from hiddifypanel.drivers import user_driver
-
-
+from hiddifypanel.panel import hiddify
 
 from . import has_permission
 from .schema import UserSchema, PostUserSchema, PatchUserSchema, SuccessfulSchema

hiddifypanel/panel/common.py

@@ -65,7 +65,7 @@ def init_app(app: APIFlask):
                             'version': hiddifypanel.__version__,
                             }), 500
 
-        trace = traceback.format_exc()
+        trace = traceback.format_exc(e)
 
         # Create github issue link
         issue_link = hutils.github_issue.generate_github_issue_link_for_500_error(e, trace)