hiddifypanel 10.14.0__py3-none-any.whl → 10.15.0.dev0__py3-none-any.whl

hiddifypanel/panel/commercial/restapi/v2/parent/usage_api.py

@@ -0,0 +1,57 @@
+from apiflask import abort
+from flask.views import MethodView
+from flask import current_app as app
+from flask import g
+from loguru import logger
+
+from hiddifypanel.models import Child
+from hiddifypanel.panel.usage import add_users_usage_uuid
+from hiddifypanel.auth import login_required
+
+from .schema import UsageInputOutputSchema
+
+
+class UsageApi(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    @app.input(UsageInputOutputSchema, arg_name='data')  # type: ignore
+    @app.output(UsageInputOutputSchema)  # type: ignore
+    def put(self, data):
+        from hiddifypanel import hutils
+        child = Child.query.filter(Child.unique_id == Child.node.unique_id).first()
+        if not child:
+            logger.error("The child does not exist")
+            abort(400, "The child does not exist")
+
+        # parse request data
+        logger.debug(f"Received Usage data from child: {data}")
+        child_usages_data = hutils.node.convert_usage_api_response_to_dict(data)
+
+        # get current usage
+        logger.debug("Getting current usage data from parent")
+        parent_current_usages_data = hutils.node.convert_usage_api_response_to_dict(UsageInputOutputSchema().dump(hutils.node.get_users_usage_data_for_api()))  # type: ignore
+
+        # calculate usages
+        logger.debug("Calculating increased usages")
+        increased_usages = self.__calculate_parent_increased_usages(child_usages_data, parent_current_usages_data)
+        logger.debug(f"Increased usages: {increased_usages}")
+
+        # add users usage
+        if increased_usages:
+            logger.info(f"Adding increased usages to parent: {increased_usages}")
+            add_users_usage_uuid(increased_usages, child.id)
+
+        return hutils.node.get_users_usage_data_for_api()
+
+    def __calculate_parent_increased_usages(self, child_usages_data: dict, parent_usages_data: dict) -> dict:
+        res = {}
+        for p_uuid, p_usage in parent_usages_data.items():
+            if child_usage := child_usages_data.get(p_uuid):
+                if child_usage['usage'] > 0:
+                    usage_data = {
+                        'usage':  child_usage['usage'] - p_usage['usage'],
+                        'devices': child_usage['devices'],
+                    }
+                    if usage_data['usage'] > 0:
+                        res[p_uuid] = usage_data
+        return res

hiddifypanel/panel/commercial/telegrambot/admin.py

@@ -138,8 +138,7 @@ def create_package(call):  # <- passes a CallbackQuery type object to your funct
                 domain = int(splt[4])
                 new_text = _("Please Wait...")
                 bot.edit_message_text(new_text, call.message.chat.id, call.message.message_id, reply_markup=None)
-                DT = (ParentDomain if hconfig(ConfigEnum.is_parent) else Domain)
-                domain = DT.query.filter(DT.id == domain).first()
+                domain = Domain.query.filter(Domain.id == domain).first()
                 from . import Usage
                 admin_id = admin.id
                 admin_name = admin.name

hiddifypanel/panel/common.py

@@ -18,6 +18,8 @@ def init_app(app: APIFlask):
     app.jinja_env.globals['UserMode'] = UserMode
     app.jinja_env.globals['hconfig'] = hconfig
     app.jinja_env.globals['g'] = g
+    app.jinja_env.globals['hutils'] = hutils
+    app.jinja_env.globals['hiddify'] = hiddify
     app.jinja_env.globals['version'] = hiddifypanel.__version__
     app.jinja_env.globals['static_url_for'] = hutils.flask.static_url_for
     app.jinja_env.globals['hurl_for'] = hutils.flask.hurl_for
@@ -34,6 +36,12 @@ def init_app(app: APIFlask):
 
     @app.errorhandler(Exception)
     def internal_server_error(e):
+        if isinstance(e, Exception):
+            if hutils.flask.is_api_call(request.path):
+                return {
+                    'msg': str(e),
+                }, 500
+
         if hasattr(e, 'code') and e.code == 404:
             return jsonify({
                 'message': 'Not Found',
@@ -68,6 +76,7 @@ def init_app(app: APIFlask):
         # print(request.headers)
         if not request.accept_mimetypes.accept_html:
             return app.error_callback(e)
+        # if it's interval server error
         if e.status_code == 500:
             trace = traceback.format_exc()
 
@@ -81,9 +90,17 @@ def init_app(app: APIFlask):
                 has_update = "dev" not in hiddifypanel.__version__ and f'{last_version}' != hiddifypanel.__version__
 
             return render_template('500.html', error=e, trace=trace, has_update=has_update, last_version=last_version, issue_link=issue_link), 500
+
+        # if it's access denied error
         # if e.status_code in [400,401,403]:
         #     return render_template('access-denied.html',error=e), e.status_code
 
+        # if it's api error
+        if hutils.flask.is_api_call(request.path):
+            return {
+                'msg': e.message,
+            }, e.status_code
+
         return render_template('error.html', error=e), e.status_code
 
     @app.url_defaults
@@ -133,12 +150,6 @@ def init_app(app: APIFlask):
         g.child = Child.by_id(g.__child_id) or abort(404, "Child not found")
         g.account = current_account
 
-    @app.before_first_request
-    def first_request():
-        import hiddifypanel.panel.commercial.telegrambot as telegrambot
-        if (not telegrambot.bot) or (not telegrambot.bot.username):  # type: ignore
-            telegrambot.register_bot(set_hook=True)
-
     @app.before_request
     def base_middleware():
         if request.endpoint == 'static' or request.endpoint == "videos":
@@ -174,3 +185,7 @@ def init_app(app: APIFlask):
             return auth_before
 
     app.jinja_env.globals['generate_github_issue_link_for_admin_sidebar'] = hutils.github_issue.generate_github_issue_link_for_admin_sidebar
+    with app.app_context():
+        import hiddifypanel.panel.commercial.telegrambot as telegrambot
+        if (not telegrambot.bot) or (not telegrambot.bot.username):  # type: ignore
+            telegrambot.register_bot(set_hook=True)

hiddifypanel/panel/hiddify.py

@@ -1,22 +1,16 @@
-import glob
 import re
-import json
 import subprocess
 
 from datetime import datetime
 from typing import Tuple
-from cryptography.hazmat.primitives import serialization
-from cryptography.hazmat.primitives.asymmetric import x25519
 from flask import current_app, g
 from flask_babel import lazy_gettext as _
-from flask_babel import gettext as __
 from datetime import timedelta
 
 from hiddifypanel.cache import cache
 from hiddifypanel.models import *
 from hiddifypanel.database import db
 from hiddifypanel.hutils.utils import *
-from hiddifypanel.Events import domain_changed
 from hiddifypanel import hutils
 from hiddifypanel.panel.run_commander import commander, Command
 import subprocess
@@ -69,23 +63,9 @@ def exec_command(cmd, cwd=None):
 
 
 def quick_apply_users():
-    if hconfig(ConfigEnum.is_parent):
-        return
-    # from hiddifypanel.panel import usage
-    # usage.update_local_usage()
-    # return
-    # for user in User.query.all():
-    #     if user.is_active:
-    #         xray_api.add_client(user.uuid)
-    #     else:
-    #         xray_api.remove_client(user.uuid)
-
-    # exec_command("sudo /opt/hiddify-manager/install.sh apply_users --no-gui")
-
     # run install.sh apply_users
     commander(Command.apply_users)
 
-    # time.sleep(1)
     return {"status": 'success'}
 
 
@@ -145,11 +125,12 @@ def check_need_reset(old_configs, do=False):
 
 
 def get_child(unique_id):
-    child_id = Child.current.id
+    child_id = Child.current().id
     if unique_id is None or unique_id in ["self", "default", str(hconfig(ConfigEnum.unique_id))]:
         child_id = 0
     else:
         child = Child.query.filter(Child.unique_id == str(unique_id)).first()
+        # TODO: this doesn't work because name and mode fields are nullable
         if not child:
             child = Child(unique_id=str(unique_id))
             db.session.add(child)
@@ -164,7 +145,7 @@ def dump_db_to_dict():
             "users": [u.to_dict() for u in User.query.all()],
             "domains": [u.to_dict() for u in Domain.query.all()],
             "proxies": [u.to_dict() for u in Proxy.query.all()],
-            "parent_domains": [] if not hconfig(ConfigEnum.license) else [u.to_dict() for u in ParentDomain.query.all()],
+            # "parent_domains": [] if not hconfig(ConfigEnum.license) else [u.to_dict() for u in ParentDomain.query.all()],
             'admin_users': [d.to_dict() for d in AdminUser.query.all()],
             "hconfigs": [*[u.to_dict() for u in BoolConfig.query.all()],
                          *[u.to_dict() for u in StrConfig.query.all()]]
@@ -195,7 +176,7 @@ def set_db_from_json(json_data, override_child_unique_id=True, set_users=True, s
     # override root child unique id
     if override_child_unique_id:
         backup_child_unique_id = get_backup_child_unique_id(json_data)
-        replace_backup_child_unique_id(json_data, backup_child_unique_id, Child.current.unique_id)
+        replace_backup_child_unique_id(json_data, backup_child_unique_id, Child.current().unique_id)
 
     # restore childs
     if set_child and 'childs' in json_data:
@@ -243,13 +224,12 @@ def set_db_from_json(json_data, override_child_unique_id=True, set_users=True, s
     if set_users and 'users' in json_data:
         User.bulk_register(json_data['users'], commit=False, remove=remove_users)
     if set_domains and 'domains' in json_data:
-        bulk_register_domains(json_data['domains'], commit=False, remove=remove_domains, override_child_unique_id=override_child_unique_id)
-    # if set_domains and 'parent_domains' in json_data:
-    #     ParentDomain.bulk_register(json_data['parent_domains'], commit=False, remove=remove_domains)
+        bulk_register_domains(json_data['domains'], commit=False, remove=remove_domains)
+
     if set_settings and 'hconfigs' in json_data:
-        bulk_register_configs(json_data["hconfigs"], commit=True, override_child_unique_id=override_child_unique_id, override_unique_id=override_unique_id)
+        bulk_register_configs(json_data["hconfigs"], commit=True, override_unique_id=override_unique_id)
         if 'proxies' in json_data:
-            Proxy.bulk_register(json_data['proxies'], commit=False, override_child_unique_id=override_child_unique_id)
+            Proxy.bulk_register(json_data['proxies'], commit=False)
 
     ids_without_parent = get_ids_without_parent({u.id: u.to_dict() for u in AdminUser.query.all()})
     owner = AdminUser.get_super_admin()
@@ -276,49 +256,13 @@ def get_domain_btn_link(domain):
     return res
 
 
-def debug_flash_if_not_in_the_same_asn(domain):
-    from hiddifypanel.hutils.network.auto_ip_selector import IPASN
-    ipv4 = hutils.network.get_ip_str(4)
-    dip = hutils.network.get_domain_ip(domain)
-    try:
-        if IPASN:
-            asn_ipv4 = IPASN.get(ipv4)
-            asn_dip = IPASN.get(dip)
-            # country_ipv4= ipcountry.get(ipv4)
-            # country_dip= ipcountry.get(dip)
-            if asn_ipv4.get('autonomous_system_organization') != asn_dip.get('autonomous_system_organization'):
-                hutils.flask.flash(_("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={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
-    except BaseException:
-        pass
-
-
-def generate_x25519_keys():
-    priv = x25519.X25519PrivateKey.generate()
-    pub = priv.public_key()
-    priv_bytes = priv.private_bytes(
-        encoding=serialization.Encoding.Raw,
-        format=serialization.PrivateFormat.Raw,
-        encryption_algorithm=serialization.NoEncryption()
-    )
-    pub_bytes = pub.public_bytes(
-        encoding=serialization.Encoding.Raw,
-        format=serialization.PublicFormat.Raw
-    )
-    import base64
-    pub_str = base64.urlsafe_b64encode(pub_bytes).decode()[:-1]
-    priv_str = base64.urlsafe_b64encode(priv_bytes).decode()[:-1]
-
-    return {'private_key': priv_str, 'public_key': pub_str}
-
-
 def get_ssh_client_version(user):
     return 'SSH-2.0-OpenSSH_7.4p1'
 
 
 def get_account_panel_link(account: BaseAccount, host: str, is_https: bool = True, prefere_path_only: bool = False, child_id=None):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
     is_admin = isinstance(account, AdminUser)
     basic_auth = False  # is_admin #because safri does not support it.
 
@@ -363,11 +307,8 @@ def clone_model(model):
     for k in table.columns.keys():
         if k == "id":
             continue
-        # if k in table.primary_key:
-        #     continue
         setattr(new_model, f'{k}', getattr(model, k))
 
-    # data.pop('id')
     return new_model
 
 
@@ -392,18 +333,6 @@ def get_backup_child_unique_id(backupdata: dict) -> str:
         return "self"
     return backupdata['childs'][0]['unique_id']
 
-    # for k, v in backupdata.items():
-    #     if k == 'admin_users' or k == 'users':
-    #         continue
-    #     if k == 'childs':
-    #         if len(v) < 1:
-    #             continue
-    #         return v[0]['unique_id']
-    #     else:
-    #         for item in v:
-    #             return item['child_unique_id']
-    # return 'self'
-
 
 def is_hiddify_next_version(major_v: int = 0, minor_v: int = 0, patch_v: int = 0) -> bool:
     '''If the user agent version be equals or higher than parameters returns True'''

hiddifypanel/panel/init_db.py

@@ -2,24 +2,50 @@ import datetime
 import json
 import os
 import random
-import string
 import sys
 import uuid
 
-from dateutil import relativedelta
 
 from hiddifypanel import Events, hutils
 from hiddifypanel.models import *
-from hiddifypanel.models import ConfigEnum, User, set_hconfig, ChildMode
 from hiddifypanel.panel import hiddify
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 from hiddifypanel import hutils
-
+from sqlalchemy import text
 from flask import g
 
 MAX_DB_VERSION = 90
 
 
+def _v83(child_id):
+    set_hconfig(ConfigEnum.log_level, LogLevel.CRITICAL)
+
+
+def _v82(child_id):
+    set_hconfig(ConfigEnum.vless_enable, True)
+    set_hconfig(ConfigEnum.trojan_enable, True)
+    set_hconfig(ConfigEnum.reality_enable, True)
+    set_hconfig(ConfigEnum.tcp_enable, True)
+    set_hconfig(ConfigEnum.quic_enable, True)
+    set_hconfig(ConfigEnum.xtls_enable, True)
+    set_hconfig(ConfigEnum.h2_enable, True)
+
+
+def _v80(child_id):
+    set_hconfig(ConfigEnum.parent_domain, '')
+    set_hconfig(ConfigEnum.parent_admin_proxy_path, '')
+
+
+def _v79(child_id):
+    set_hconfig(ConfigEnum.panel_mode, PanelMode.standalone)
+
+
+def _v78(child_id):
+    # equalize panel unique id and root child unique id
+    root_child_unique_id = Child.query.filter(Child.name == "Root").first().unique_id
+    set_hconfig(ConfigEnum.unique_id, root_child_unique_id)
+
+
 def _v77(child_id):
     pass
 
@@ -229,7 +255,7 @@ def _v33():
 
 def _v31():
     add_config_if_not_exist(ConfigEnum.reality_short_ids, uuid.uuid4().hex[0:random.randint(1, 8) * 2])
-    key_pair = hiddify.generate_x25519_keys()
+    key_pair = hutils.crypto.generate_x25519_keys()
     add_config_if_not_exist(ConfigEnum.reality_private_key, key_pair['private_key'])
     add_config_if_not_exist(ConfigEnum.reality_public_key, key_pair['public_key'])
     db.session.bulk_save_objects(get_proxy_rows_v1())
@@ -511,7 +537,7 @@ def make_proxy_rows(cfgs):
 
 def add_config_if_not_exist(key: ConfigEnum, val: str | int, child_id: int | None = None):
     if child_id is None:
-        child_id = Child.current.id
+        child_id = Child.current().id
 
     old_val = hconfig(key, child_id)
     print(key, val, child_id, old_val)
@@ -522,14 +548,16 @@ def add_config_if_not_exist(key: ConfigEnum, val: str | int, child_id: int | Non
 def add_column(column):
     try:
         column_type = column.type.compile(db.engine.dialect)
-        db.engine.execute(f'ALTER TABLE {column.table.name} ADD COLUMN {column.name} {column_type}')
+
+        db_execute(f'ALTER TABLE {column.table.name} ADD COLUMN {column.name} {column_type}')
     except BaseException:
         pass
 
 
-def execute(query):
+def execute(query: str):
     try:
-        db.engine.execute(query)
+
+        db_execute(query)
     except BaseException as e:
         print(e)
         pass
@@ -551,7 +579,8 @@ def add_new_enum_values():
         # Get the values in the enum column in the database
         # result = db.engine.execute(f"SELECT DISTINCT `{column_name}` FROM {table_name}")
         # db_values = {row[0] for row in result}
-        result = db.engine.execute(f"SHOW COLUMNS FROM {table_name} LIKE '{column_name}';")
+
+        result = db_execute(f"SHOW COLUMNS FROM {table_name} LIKE '{column_name}';")
         db_values = []
 
         for row in result:
@@ -570,7 +599,7 @@ def add_new_enum_values():
         # Add the new value to the enum column in the database
         enumstr = ','.join([f"'{a}'" for a in [*existing_values, *old_values]])
 
-        db.engine.execute(f"ALTER TABLE {table_name} MODIFY COLUMN `{column_name}` ENUM({enumstr});")
+        db_execute(text(f"ALTER TABLE {table_name} MODIFY COLUMN `{column_name}` ENUM({enumstr});"))
 
         db.session.commit()
 
@@ -674,6 +703,8 @@ def migrate(db_version):
         for column in table_obj.columns:
             add_column(column)
     Events.db_prehook.notify()
+    if db_version < 82:
+        execute('ALTER TABLE child DROP INDEX `name`;')
     if db_version < 77:
         execute('ALTER TABLE user_detail DROP COLUMN connected_ips;')
         execute('update user_detail set connected_devices="" where connected_devices IS NULL')

hiddifypanel/panel/usage.py

@@ -1,11 +1,13 @@
 from flask_babel import lazy_gettext as _
 from sqlalchemy import func
+from typing import Dict
 import datetime
 
 from hiddifypanel.drivers import user_driver
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
 from hiddifypanel.database import db
+from hiddifypanel import hutils
 
 to_gig_d = 1024**3
 
@@ -17,20 +19,18 @@ def update_local_usage():
     # return {"status": 'success', "comments":res}
 
 
-def add_users_usage_uuid(uuids_bytes, child_id):
+def add_users_usage_uuid(uuids_bytes: Dict[str, Dict], child_id, sync=False):
     uuids_bytes = {u: v for u, v in uuids_bytes.items() if v}
-    uuids = keys(uuids_bytes)
+    uuids = uuids_bytes.keys()
     users = User.query.filter(User.uuid.in_(uuids))
     dbusers_bytes = {u: uuids_bytes.get(u.uuid, 0) for u in users}
-    _add_users_usage(dbusers_bytes, child_id)
+    _add_users_usage(dbusers_bytes, child_id, sync)  # type: ignore
 
 
-def _add_users_usage(dbusers_bytes, child_id):
-    # print(dbusers_bytes)
-    if not hconfig(ConfigEnum.is_parent) and hconfig(ConfigEnum.parent_panel):
-        from hiddifypanel.panel import hiddify_api
-        hiddify_api.add_user_usage_to_parent(dbusers_bytes)
-
+def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
+    '''
+    sync: when enabled, it means we have received usages from the parent panel
+    '''
     res = {}
     have_change = False
     before_enabled_users = user_driver.get_enabled_users()
@@ -44,7 +44,7 @@ def _add_users_usage(dbusers_bytes, child_id):
         daily_usage[adm.id].online = User.query.filter(User.added_by == adm.id).filter(func.DATE(User.last_online) == today).count()
     # db.session.commit()
     userDetails = {p.user_id: p for p in UserDetail.query.filter(UserDetail.child_id == child_id).all()}
-    for user, uinfo in dbusers_bytes.items():
+    for user, uinfo in users_usage_data.items():
         usage_bytes = uinfo['usage']
         devices = uinfo['devices']
         # user_active_before=user.is_active
@@ -68,11 +68,20 @@ def _add_users_usage(dbusers_bytes, child_id):
         if not isinstance(usage_bytes, int) or usage_bytes == 0:
             res[user.uuid] = "No usage"
         else:
-            daily_usage.get(user.added_by, daily_usage[1]).usage += usage_bytes
+            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
+            else:
+                daily_usage.get(user.added_by, daily_usage[1]).usage += usage_bytes
             in_gig = (usage_bytes) / to_gig_d
             res[user.uuid] = in_gig
-            user.current_usage_GB += in_gig
-            detail.current_usage_GB += in_gig
+            if sync:
+                if user.current_usage_GB != in_gig:
+                    user.current_usage_GB = in_gig
+                # detail.current_usage_GB = in_gig
+            else:
+                user.current_usage_GB += in_gig
+                detail.current_usage_GB += in_gig
             user.last_online = datetime.datetime.now()
             detail.last_online = datetime.datetime.now()
 
@@ -85,15 +94,19 @@ def _add_users_usage(dbusers_bytes, child_id):
             have_change = True
             res[user.uuid] = f"{res[user.uuid]} !OUT of USAGE! Client Removed"
 
-    db.session.commit()
+    db.session.commit()  # type: ignore
     if have_change:
         hiddify.quick_apply_users()
 
+    # sync with the parent
+    if not sync:
+        if hutils.node.is_child():
+            hutils.node.child.sync_users_usage_with_parent()
     return {"status": 'success', "comments": res}
 
 
 def send_bot_message(user):
-    if not (hconfig(ConfigEnum.telegram_bot_token) and not hconfig(ConfigEnum.parent_panel)):
+    if not (hconfig(ConfigEnum.telegram_bot_token) or not hutils.node.is_parent()):
         return
     if not user.telegram_id:
         return

hiddifypanel/panel/user/templates/home/usage.html

@@ -23,7 +23,7 @@
                     {% endif %}
                     {% if not user.is_active %}
                     {{_("User is inactive")}}
-                    {% if (user.ips|length)>user.max_ips: %}
+                    {% if (user.devices|length)>user.max_ips: %}
                     <br>
                     <i class="fa-solid fa-users-slash text-danger"></i> {{_("Too many Connected IPs")}}
                     {% endif %}

hiddifypanel/panel/user/templates/new.html

@@ -13,7 +13,7 @@
     <link rel="manifest" href="{{ url_for('common_bp.LoginView:create_pwa_manifest',secret_uuid=g.account.uuid or '')}}">
     
     <title>Hiddify | Panel</title>
-    <script type="module" crossorigin src="../static/new/assets/index-bce9b1a6.js"></script>
+    <script type="module" crossorigin src="../static/new/assets/index-ccb9873c.js"></script>
     <link rel="stylesheet" href="../static/new/assets/index-fa00de9a.css">
   </head>
   <body>

hiddifypanel/static/css/custom.css

@@ -555,4 +555,17 @@ td.col-uuid a {
 
 .select2-container {
   display: none;
+}
+
+
+#main-sidebar .nav-sidebar>.nav-item>.nav-link {
+  color: white;
+}
+
+#main-sidebar .nav-sidebar>.nav-item>.nav-link:hover {
+  background: #007bff;
+}
+
+.dark-mode #main-sidebar .nav-sidebar>.nav-item>.nav-link:hover {
+  background: #3f6791;
 }