hiddifypanel 10.30.6.dev0__py3-none-any.whl → 10.30.7.dev0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.30.6.dev0
+10.30.7.dev0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.30.6.dev0'
+__version__='10.30.7.dev0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-07-05','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-07-09','%Y-%m-%d')

hiddifypanel/drivers/singbox_api.py

@@ -4,6 +4,7 @@ from .abstract_driver import DriverABS
 from flask import current_app
 import json
 from collections import defaultdict
+from hiddifypanel.cache import cache
 
 
 class SingboxApi(DriverABS):
@@ -18,6 +19,7 @@ class SingboxApi(DriverABS):
             json_data = json.load(f)
             return {u.split("@")[0]: 1 for u in json_data['experimental']['v2ray_api']['stats']['users']}
 
+    @cache.cache(ttl=300)
     def get_inbound_tags(self):
         try:
             xray_client = self.get_singbox_client()

hiddifypanel/drivers/ssh_liberty_bridge_api.py

@@ -29,6 +29,12 @@ class SSHLibertyBridgeApi(DriverABS):
 
     def remove_client(self, user):
         redis_client = self.get_ssh_redis_client()
+        if user.ed25519_public_key is None:
+            members = redis_client.smembers(USERS_SET)
+            for member in members:
+                if member.startswith(user.uuid):
+                    redis_client.srem(USERS_SET, member)
+
         redis_client.srem(USERS_SET, f'{user.uuid}::{user.ed25519_public_key}')
         redis_client.hdel(USERS_USAGE, f'{user.uuid}')
         redis_client.save()

hiddifypanel/drivers/user_driver.py

@@ -33,16 +33,19 @@ def get_enabled_users():
     for driver in enabled_drivers():
         try:
             for u, v in driver.get_enabled_users().items():
+                # print(u, "enabled", v, driver)
                 if not v:
                     continue
                 d[u] += 1
             total += 1
         except Exception as e:
+            print(driver)
             hiddify.error(f'ERROR! {driver.__class__.__name__} has error in get_enabled users')
-
+    # print(d, total)
     res = defaultdict(bool)
     for u, v in d.items():
-        res[u] = v >= total  # ignore singbox
+        # res[u] = v >= total  # ignore singbox
+        res[u] = v >= 1
     return res
 
 

hiddifypanel/drivers/xray_api.py

@@ -2,6 +2,7 @@ import xtlsapi
 from hiddifypanel.models import *
 from .abstract_driver import DriverABS
 from collections import defaultdict
+from hiddifypanel.cache import cache
 
 
 class XrayApi(DriverABS):
@@ -19,7 +20,18 @@ class XrayApi(DriverABS):
             if "user>>>" not in use.name:
                 continue
             uuid = use.name.split(">>>")[1].split("@")[0]
-            res[uuid] = 1
+            try:
+                t = "xtls"
+                protocol = "vless"
+                xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
+                xray_client.remove_client(t, f'{uuid}@hiddify.com')
+                res[uuid] = 0
+            except xtlsapi.xtlsapi.exceptions.EmailAlreadyExists as e:
+                res[uuid] = 1
+            except Exception as e:
+                print(f"error {e}")
+                res[uuid] = 0
+
         return res
 
         # xray_client = self.get_xray_client()
@@ -40,10 +52,11 @@ class XrayApi(DriverABS):
         #         enabled[uuid] = e
         # return enabled
 
+    # @cache.cache(ttl=300)
     def get_inbound_tags(self):
         try:
             xray_client = self.get_xray_client()
-            inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('inbound')]
+            inbounds = [inb.name.split(">>>")[1] for inb in xray_client.stats_query('')]
             print(f"Success in get inbound tags {inbounds}")
         except Exception as e:
             print(f"error in get inbound tags {e}")
@@ -65,6 +78,7 @@ class XrayApi(DriverABS):
             'v2ray': 'shadowsocks',
             'kcp': 'vless',
             'dispatcher': 'trojan',
+            'reality': 'vless'
         }
 
         def proto(t):

hiddifypanel/hutils/proxy/xray.py

@@ -82,7 +82,7 @@ def to_link(proxy: dict) -> str | dict:
             return "ShadowTLS is Not Supported for this platform"
             # return f'{baseurl}?plugin=v2ray-plugin&path={proxy["proxy_path"]}&host={proxy["fakedomain"]}&udp-over-tcp=true#{name_link}'
         if proxy['proto'] == 'v2ray':
-            return f'{baseurl}?plugin=v2ray-plugin&mode=websocket&path={proxy["proxy_path"]}&host={proxy["fakedomain"]}&tls&udp-over-tcp=true#{name_link}'
+            return f'{baseurl}?plugin=v2ray-plugin&mode=websocket&path={proxy["proxy_path"]}&host={proxy["sni"]}&tls&udp-over-tcp=true#{name_link}'
 
     if proxy['proto'] == 'tuic':
         baseurl = f'tuic://{proxy["uuid"]}:{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?congestion_control=cubic&udp_relay_mode=native&sni={proxy["sni"]}&alpn=h3'

hiddifypanel/hutils/proxy/xrayjson.py

@@ -8,7 +8,7 @@ from hiddifypanel.models import hconfig, ConfigEnum
 from .xray import is_muxable_agent, OUTBOUND_LEVEL
 
 
-def configs_as_json(domains: list[Domain], user: User, expire_days: int,  remarks: str) -> str:
+def configs_as_json(domains: list[Domain], user: User, expire_days: int, remarks: str) -> str:
     '''Returns xray configs as json'''
     all_configs = []
 
@@ -35,50 +35,48 @@ def configs_as_json(domains: list[Domain], user: User, expire_days: int,  remark
         )
     # endregion
 
-    # region show status (active/disable)
-    active = True
     if not user.is_active:
+        # region show status (active/disable)
         tag = '✖ ' + (hutils.encode.url_encode('بسته شما به پایان رسید') if hconfig(ConfigEnum.lang) == 'fa' else 'Package Ended')
         # add user status
         all_configs.append(
             null_config(tag)
         )
-        active = False
-    # endregion
-
-    if active:
+        # endregion
+    else:
         # TODO: seperate codes to small functions
         # TODO: check what are unsupported protocols in other apps
-        unsupported_protos = []
-        unsupported_transport = []
+        unsupported_protos = {}
+        unsupported_transport = {}
         if g.user_agent.get('is_v2rayng'):
             # TODO: ensure which protocols are not supported in v2rayng
-            unsupported_protos = [ProxyProto.wireguard, ProxyProto.hysteria, ProxyProto.hysteria2, ProxyProto.tuic, ProxyProto.ss, ProxyProto.ssr, ProxyProto.ssh]
+            unsupported_protos = {ProxyProto.wireguard, ProxyProto.hysteria, ProxyProto.hysteria2,
+                                  ProxyProto.tuic, ProxyProto.ss, ProxyProto.ssr, ProxyProto.ssh}
             if not hutils.flask.is_client_version(hutils.flask.ClientVersion.v2ryang, 1, 8, 18):
-                unsupported_transport = [ProxyTransport.httpupgrade]
+                unsupported_transport = {ProxyTransport.httpupgrade}
 
         # multiple outbounds needs multiple whole base config not just one with multiple outbounds (at least for v2rayng)
         # https://github.com/2dust/v2rayNG/pull/2827#issue-2127534078
         outbounds = []
         for proxy in hutils.proxy.get_valid_proxies(domains):
-            if unsupported_protos and proxy['proto'] in unsupported_protos:
+            if proxy['proto'] in unsupported_protos:
                 continue
-            if unsupported_transport and proxy['transport'] in unsupported_transport:
+            if proxy['transport'] in unsupported_transport:
                 continue
             outbound = to_xray(proxy)
-            if 'msg' not in outbound:
-                outbounds.append(outbound)
+            outbounds.append(outbound)
 
         base_config = json.loads(render_template('base_xray_config.json.j2', remarks=remarks))
         if len(outbounds) > 1:
             for out in outbounds:
-                base_config['remarks'] = out['tag']
-                base_config['outbounds'].insert(0, out)
-                if all_configs:
-                    all_configs.insert(0, copy.deepcopy(base_config))
-                else:
-                    all_configs.append(copy.deepcopy(base_config))
-                del base_config['outbounds'][0]
+                base = copy.deepcopy(base_config)
+                base['remarks'] = out['tag']
+                base['outbounds'].insert(0, out)
+                # if all_configs:
+                #     all_configs.insert(0, copy.deepcopy(base_config))
+                # else:
+                all_configs.append(base)
+
         else:  # single outbound
             base_config['outbounds'].insert(0, outbounds[0])
             all_configs = base_config

hiddifypanel/panel/admin/DomainAdmin.py

@@ -114,7 +114,7 @@ class DomainAdmin(AdminLTEModelView):
         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:
+        if myip == dip and model.mode in [DomainType.direct, DomainType.sub_link_only]:
             badge_type = ''
         elif dip and model.mode != DomainType.direct and myip != dip:
             badge_type = 'warning'

hiddifypanel/panel/admin/UserAdmin.py

@@ -10,6 +10,7 @@ from wtforms.validators import NumberRange
 from flask_babel import lazy_gettext as _
 from flask import g, request  # type: ignore
 from markupsafe import Markup
+from sqlalchemy import desc
 
 from hiddifypanel.hutils.flask import hurl_for
 from wtforms.validators import Regexp, ValidationError
@@ -148,7 +149,7 @@ class UserAdmin(AdminLTEModelView):
         href = f'{hiddify.get_account_panel_link(model, request.host, is_https=True)}#{hutils.encode.unicode_slug(model.name)}'
 
         link = f"""<a target='_blank' class='share-link btn btn-xs btn-primary' data-copy='{href}' href='{href}'>
-        <i class='fa-solid fa-arrow-up-right-from-square'></i> 
+        <i class='fa-solid fa-arrow-up-right-from-square'></i>
         {_("Current Domain")} </a>"""
 
         domains = [d for d in Domain.get_domains() if d.domain != request.host]
@@ -171,7 +172,7 @@ class UserAdmin(AdminLTEModelView):
         </div>
         """)
 
-    def _expire_formatter(view, context, model, name):
+    def _expire_formatter(view, context, model: User, name):
         remaining = model.remaining_days
 
         diff = datetime.timedelta(days=remaining)
@@ -231,7 +232,8 @@ class UserAdmin(AdminLTEModelView):
             # delattr(form,'disable_user')
         else:
             remaining = form._obj.remaining_days  # remaining_days(form._obj)
-            msg = _("Remaining: ") + hutils.convert.format_timedelta(datetime.timedelta(days=remaining))
+            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
@@ -240,10 +242,18 @@ class UserAdmin(AdminLTEModelView):
 
             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
-        form.package_days.label.text += f" ({msg})"
+            # 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()
@@ -295,7 +305,7 @@ class UserAdmin(AdminLTEModelView):
     def after_model_change(self, form, model, is_created):
         if hconfig(ConfigEnum.first_setup):
             set_hconfig(ConfigEnum.first_setup, False)
-        user = User.query.filter(User.uuid == model.uuid).first()
+        user = User.query.filter(User.uuid == model.uuid).first() or abort(404)
         if user.is_active:
             user_driver.add_client(model)
         else:
@@ -314,6 +324,7 @@ class UserAdmin(AdminLTEModelView):
 
     def get_list(self, page, sort_column, sort_desc, search, filters, page_size=50, *args, **kwargs):
         res = None
+        self._auto_joins = {}
         # print('aaa',args, kwargs)
         if sort_column in ['remaining_days', 'is_active']:
             query = self.get_query()
@@ -365,14 +376,12 @@ class UserAdmin(AdminLTEModelView):
             abort(403)
 
         query = query.filter(User.added_by.in_(admin.recursive_sub_admins_ids()))
-
+        query = query.order_by(desc(User.id))
         return query
 
     # Override get_count_query() to include the filter condition in the count query
     def get_count_query(self):
         # Get the base count query
-        query = self.get_query()
-        from sqlalchemy import func
 
         # query = query.session.query(func.count(User.id))
         query = super().get_count_query()

hiddifypanel/panel/usage.py

@@ -50,6 +50,7 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
     res = {}
     have_change = False
     before_enabled_users = user_driver.get_enabled_users()
+
     daily_usage = {}
     today = datetime.date.today()
     for adm in AdminUser.query.all():
@@ -64,15 +65,14 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
     userDetails = {p.user_id: p for p in UserDetail.query.filter(UserDetail.child_id == child_id).all()}
     for user, uinfo in users_usage_data.items():
         usage_bytes = uinfo['usage']
-        devices = uinfo['devices']
 
         # UserDetails things
         detail = userDetails.get(user.id)
         if not detail:
             detail = UserDetail(user_id=user.id, child_id=child_id)
             db.session.add(detail)
-        detail.connected_devices = devices
-        detail.current_usage_GB = detail.current_usage_GB or 0
+        if uinfo['devices'] != detail.connected_devices:
+            detail.connected_devices = uinfo['devices']
 
         # Enable the user if isn't already
         if not before_enabled_users[user.uuid] and user.is_active:
@@ -86,22 +86,21 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
             res[user.uuid] = "No usage"
         else:
             # Set new daily usage of the user
-            if sync:
-                if daily_usage.get(user.added_by, daily_usage[1]).usage != usage_bytes:
-                    daily_usage.get(user.added_by, daily_usage[1]).usage = usage_bytes
+            if sync and daily_usage.get(user.added_by, daily_usage[1]).usage != usage_bytes:
+                daily_usage.get(user.added_by, daily_usage[1]).usage = usage_bytes
             else:
                 daily_usage.get(user.added_by, daily_usage[1]).usage += usage_bytes
 
-            in_gig = (usage_bytes) / to_gig_d
+            in_bytes = usage_bytes
 
             # Set new current usage of the user
-            if sync:
-                if user.current_usage_GB != in_gig:
-                    user.current_usage_GB = in_gig
+            if sync and user.current_usage != in_bytes:
+                user.current_usage = in_bytes
                 # detail.current_usage_GB = in_gig
             else:
-                user.current_usage_GB += in_gig
-                detail.current_usage_GB += in_gig
+                user.current_usage += in_bytes
+                detail.current_usage = detail.current_usage or 0
+                detail.current_usage += in_bytes
 
             # Change last online time of the user
             user.last_online = datetime.datetime.now()
@@ -111,9 +110,10 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
             if user.start_date is None:
                 user.start_date = datetime.date.today()
 
-            res[user.uuid] = in_gig
+            res[user.uuid] = f'{in_bytes/1000000:0.3f}MB'
 
         # Remove user from drivers(singbox, xray, wireguard etc.) if they're inactive
+        # print(before_enabled_users[user.uuid], user.is_active)
         if before_enabled_users[user.uuid] and not user.is_active:
             print(f"Removing enabled client {user.uuid} ")
             user_driver.remove_client(user)
@@ -122,14 +122,25 @@ def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
 
     db.session.commit()  # type: ignore
 
+    # Remove invalid users
+    for uuid in before_enabled_users:
+        if uuid in res:
+            continue
+
+        user = User.query.filter(User.uuid == uuid).first()
+        if not user:
+            user_driver.remove_client(User(uuid=uuid))
+        elif not user.is_active:
+            user_driver.remove_client(user)
+
+    # print("------------------", res)
     # Apply the changes to the drivers
     if have_change:
         hiddify.quick_apply_users()
 
     # Sync the new data with the parent node if the data has not been set by the parent node itself and the current panel is a child panel
-    if not sync:
-        if hutils.node.is_child():
-            hutils.node.child.sync_users_usage_with_parent()
+    if not sync and hutils.node.is_child():
+        hutils.node.child.sync_users_usage_with_parent()
 
     return {"status": 'success', "comments": res}