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

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

@@ -0,0 +1,115 @@
+from apiflask import fields, Schema
+from marshmallow import ValidationError
+
+from hiddifypanel.models import DomainType, ProxyProto, ProxyL3, ProxyTransport, ProxyCDN, ConfigEnum, ChildMode
+from hiddifypanel.panel.commercial.restapi.v2.admin.schema import UserSchema, AdminSchema
+
+
+def hconfig_key_validator(value):
+    if value not in [c.name for c in ConfigEnum]:
+        raise ValidationError(f"{value} is not a valid hconfig key.")
+    return value
+
+
+class DomainSchema(Schema):
+    child_unique_id = fields.String(description="The child's unique id")
+    domain = fields.String(required=True, description="The domain name")
+    alias = fields.String(description="The domain alias", allow_none=True)
+    sub_link_only = fields.Boolean(required=True, description="Is the domain sub link only")
+    mode = fields.Enum(DomainType, required=True, description="The domain type")
+    cdn_ip = fields.String(description="The cdn ip", allow_none=True)
+    grpc = fields.Boolean(required=True, description="Is the domain grpc")
+    servernames = fields.String(description="The servernames", allow_none=True)
+    show_domains = fields.List(fields.String(), desciption="The list of domains to show")
+
+
+class ProxySchema(Schema):
+    child_unique_id = fields.String(description="The child's unique id")
+    name = fields.String(required=True, description="The proxy name")
+    enable = fields.Boolean(required=True, description="Is the proxy enabled")
+    proto = fields.Enum(ProxyProto, required=True, description="The proxy protocol")
+    l3 = fields.Enum(ProxyL3, required=True, description="The proxy l3")
+    transport = fields.Enum(ProxyTransport, required=True, description="The proxy transport")
+    cdn = fields.Enum(ProxyCDN, required=True, description="The proxy cdn")
+
+
+class StringOrBooleanField(fields.Field):
+    def _deserialize(self, value, attr, data, **kwargs):
+        if isinstance(value, (str, bool)):
+            return str(value)
+        else:
+            raise ValidationError("Value must be a string or a boolean.")
+
+    def _serialize(self, value, attr, obj, **kwargs):
+        return value
+
+
+class HConfigSchema(Schema):
+    child_unique_id = fields.String(description="The child's unique id")
+    key = fields.String(required=True, description="The config key", validate=hconfig_key_validator)  # type: ignore
+    value = StringOrBooleanField(required=True, description="The config value")
+
+
+# region usage
+class UsageData(Schema):
+    uuid = fields.UUID(required=True, desciption="The user uuid")
+    usage = fields.Integer(required=True, description="The user usage in bytes")
+    devices = fields.List(fields.String(required=True, description="The user connected devices"))
+
+
+class UsageInputOutputSchema(Schema):
+    usages = fields.List(fields.Nested(UsageData), required=True, description="The list of usages")
+# endregion
+
+
+# region sync
+class SyncInputSchema(Schema):
+    # users = fields.List(fields.Nested(UserSchema),required=True,description="The list of users")
+    domains = fields.List(fields.Nested(DomainSchema), required=True, description="The list of domains")
+    proxies = fields.List(fields.Nested(ProxySchema), required=True, description="The list of proxies")
+    # parent_domains = fields.List(fields.Nested(ParentDomainSchema),required=True,description="The list of parent domains")
+    # admin_users = fields.List(fields.Nested(AdminSchema),required=True,description="The list of admin users")
+    hconfigs = fields.List(fields.Nested(HConfigSchema), required=True, description="The list of configs")
+
+
+class SyncOutputSchema(Schema):
+    users = fields.List(fields.Nested(UserSchema), required=True, description="The list of users")
+    admin_users = fields.List(fields.Nested(AdminSchema), required=True, description="The list of admin users")
+
+# endregion
+
+
+# region child status
+class ChildStatusInputSchema(Schema):
+    child_unique_id = fields.String(required=True, description="The child's unique id")
+
+
+class ChildStatusOutputSchema(Schema):
+    existance = fields.Boolean(required=True, description="Whether child exists")
+
+# end region
+
+
+# region register
+
+class RegisterDataSchema(Schema):
+    users = fields.List(fields.Nested(UserSchema), required=True, description="The list of users")
+    domains = fields.List(fields.Nested(DomainSchema), required=True, description="The list of domains")
+    proxies = fields.List(fields.Nested(ProxySchema), required=True, description="The list of proxies")
+    admin_users = fields.List(fields.Nested(AdminSchema), required=True, description="The list of admin users")
+    hconfigs = fields.List(fields.Nested(HConfigSchema), required=True, description="The list of configs")
+
+
+class RegisterInputSchema(Schema):
+    panel_data = fields.Nested(RegisterDataSchema, required=True, description="The child's data")
+    unique_id = fields.String(required=True, description="The child's unique id")
+    name = fields.String(required=True, description="The child's name")
+    mode = fields.Enum(ChildMode, required=True, description="The child's mode")
+
+
+class RegisterOutputSchema(Schema):
+    parent_unique_id = fields.String(description="The parent's unique id")
+    users = fields.List(fields.Nested(UserSchema), required=True, description="The list of users")
+    admin_users = fields.List(fields.Nested(AdminSchema), required=True, description="The list of admin users")
+
+# endregion

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

@@ -0,0 +1,26 @@
+from flask.views import MethodView
+from flask import current_app as app
+from loguru import logger
+
+from hiddifypanel.models import Child, Role
+from hiddifypanel.auth import login_required
+
+from .schema import ChildStatusInputSchema, ChildStatusOutputSchema
+
+
+class StatusApi(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    @app.input(ChildStatusInputSchema, arg_name='data')  # type: ignore
+    @app.output(ChildStatusOutputSchema)  # type: ignore
+    def post(self, data):
+        logger.info(f"Checking the existence of child with unique_id: {data['child_unique_id']}")
+        res = ChildStatusOutputSchema()
+        res.existance = False  # type: ignore
+
+        child = Child.query.filter(Child.unique_id == data['child_unique_id']).first()
+        if child:
+            logger.info(f"Child with unique_id: {data['child_unique_id']} exists")
+            res.existance = True  # type: ignore
+
+        return res

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

@@ -0,0 +1,53 @@
+
+from flask.views import MethodView
+from flask import current_app as app
+from flask import g
+from apiflask import abort
+
+from hiddifypanel.models.user import User
+from hiddifypanel.database import db
+from hiddifypanel.models.child import Child
+from loguru import logger
+from hiddifypanel.models import *
+from hiddifypanel.auth import login_required
+from .schema import SyncInputSchema, SyncOutputSchema
+
+
+class SyncApi(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    @app.input(SyncInputSchema, arg_name='data')  # type: ignore
+    @app.output(SyncOutputSchema)  # type: ignore
+    def put(self, data):
+        from hiddifypanel import hutils
+        unique_id = Child.node.unique_id
+
+        logger.info(f"Sync child with unique_id: {unique_id}")
+        if not hutils.node.is_parent():
+            logger.error("Not a parent")
+            abort(400, "Not a parent")
+
+        child = Child.query.filter(Child.unique_id == unique_id).first()
+        if not child:
+            logger.error("The child does not exist")
+            abort(404, "The child does not exist")
+
+        try:
+            logger.info("Syncing domains...")
+            bulk_register_domains(data['domains'], commit=False, force_child_unique_id=child.unique_id)
+            logger.info("Syncing hconfigs...")
+            bulk_register_configs(data['hconfigs'], commit=False, froce_child_unique_id=child.unique_id)
+            logger.info("Syncing proxies...")
+            Proxy.bulk_register(data['proxies'], commit=False, force_child_unique_id=child.unique_id)
+            db.session.commit()  # type: ignore
+        except Exception as err:
+            with logger.contextualize(error=err):
+                logger.error(f"Error while syncing data")
+            abort(400, str(err))
+
+        res = SyncOutputSchema()
+        res.users = [u.to_schema() for u in User.query.all()]  # type: ignore
+        res.admin_users = [a.to_schema() for a in AdminUser.query.all()]  # type: ignore
+
+        logger.info("Returning sync output")
+        return res

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'''