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

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

@@ -11,13 +11,13 @@ from hiddifypanel.models import AdminUser
 class AdminUsersApi(MethodView):
     decorators = [login_required({Role.super_admin, Role.admin})]
 
-    @app.output(AdminSchema(many=True))
+    @app.output(AdminSchema(many=True))  # type: ignore
     def get(self):
         admins = AdminUser.query.filter(AdminUser.id.in_(g.account.recursive_sub_admins_ids())).all() or abort(404, "You have no admin")
         return [admin.to_dict() for admin in admins]  # type: ignore
 
-    @app.input(AdminSchema, arg_name='data')
-    @app.output(AdminSchema)
+    @app.input(AdminSchema, arg_name='data')  # type: ignore
+    @app.output(AdminSchema)  # type: ignore
     def put(self, data):
         uuid = data.get('uuid') or abort(422, "Parameter issue: 'uuid'")
         admin = AdminUser.by_uuid(uuid)  # type: ignore
@@ -31,4 +31,4 @@ class AdminUsersApi(MethodView):
                 abort(403, "You don't have permission to access this admin")
 
         dbadmin = AdminUser.add_or_update(**data) or abort(502, "Unknown issue: Admin is not added")
-        return dbadmin.to_dict()
+        return dbadmin.to_dict()  # type: ignore

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

@@ -0,0 +1,157 @@
+import uuid
+from apiflask.fields import String, Float, Enum, Date, Integer, Boolean
+from apiflask import Schema, fields
+from typing import Any, Mapping
+
+from hiddifypanel.models import UserMode, Lang, AdminMode
+from hiddifypanel import hutils
+
+# region user api
+
+
+class FriendlyDateTime(fields.Field):
+    def _serialize(self, value: Any, attr: str | None, obj: Any, **kwargs):
+        return hutils.convert.time_to_json(value)
+
+    def _deserialize(self, value: Any, attr: str | None, data: Mapping[str, Any] | None, **kwargs):
+        return hutils.convert.json_to_time(value)
+
+
+class FriendlyUUID(fields.Field):
+    def _serialize(self, value: Any, attr: str | None, obj: Any, **kwargs):
+        if value is None:
+            return None
+        return str(value)
+
+    def _deserialize(self, value: Any, attr: str | None, data: Mapping[str, Any] | None, **kwargs):
+        if value is None:
+            return None
+        try:
+            return uuid.UUID(value)
+        except ValueError:
+            self.fail('Invalid uuid')
+
+
+class UserSchema(Schema):
+    uuid = FriendlyUUID(required=True, description="Unique identifier for the user")
+    name = String(required=True, description="Name of the user")
+
+    usage_limit_GB = Float(
+        required=False,
+        allow_none=True,
+        description="The data usage limit for the user in gigabytes"
+    )
+    package_days = Integer(
+        required=False,
+        allow_none=True,
+        description="The number of days in the user's package"
+    )
+    mode = Enum(UserMode,
+                required=False,
+                allow_none=True,
+                description="The mode of the user's account, which dictates access level or type"
+                )
+    last_online = FriendlyDateTime(
+        format="%Y-%m-%d %H:%M:%S",
+        allow_none=True,
+        description="The last time the user was online, converted to a JSON-friendly format"
+    )
+    start_date = Date(
+        format='%Y-%m-%d',
+        allow_none=True,
+        description="The start date of the user's package, in a JSON-friendly format"
+    )
+    current_usage_GB = Float(
+        required=False,
+        allow_none=True,
+        description="The current data usage of the user in gigabytes"
+    )
+    last_reset_time = Date(
+        format='%Y-%m-%d',
+        description="The last time the user's data usage was reset, in a JSON-friendly format",
+        allow_none=True
+    )
+    comment = String(
+        missing=None,
+        allow_none=True,
+        description="An optional comment about the user"
+    )
+    added_by_uuid = FriendlyUUID(
+        required=False,
+        description="UUID of the admin who added this user",
+        allow_none=True,
+        # validate=OneOf([p.uuid for p in AdminUser.query.all()])
+    )
+    telegram_id = Integer(
+        required=False,
+        description="The Telegram ID associated with the user",
+        allow_none=True
+    )
+    ed25519_private_key = String(
+        required=False,
+        allow_none=True,
+        description="If empty, it will be created automatically, The user's private key using the Ed25519 algorithm"
+    )
+    ed25519_public_key = String(
+        required=False,
+        allow_none=True,
+        description="If empty, it will be created automatically,The user's public key using the Ed25519 algorithm"
+    )
+    wg_pk = String(
+        required=False,
+        allow_none=True,
+        description="If empty, it will be created automatically, The user's WireGuard private key"
+    )
+
+    wg_pub = String(
+        required=False,
+        allow_none=True,
+        description="If empty, it will be created automatically, The user's WireGuard public key"
+    )
+    wg_psk = String(
+        required=False,
+        allow_none=True,
+        description="If empty, it will be created automatically, The user's WireGuard preshared key"
+    )
+
+    lang = Enum(Lang, required=False, allow_none=True, description="The language of the user")
+
+
+class PatchUserSchema(UserSchema):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields['name'].required = False
+    pass
+
+# endregion
+
+# region admin api
+
+
+class AdminSchema(Schema):
+    name = String(required=True, description='The name of the admin')
+    comment = String(required=False, description='A comment related to the admin', allow_none=True)
+    uuid = FriendlyUUID(required=True, description='The unique identifier for the admin')
+    mode = Enum(AdminMode, required=True, description='The mode for the admin')
+    can_add_admin = Boolean(required=True, description='Whether the admin can add other admins')
+    parent_admin_uuid = FriendlyUUID(description='The unique identifier for the parent admin', allow_none=True,
+                                     # validate=OneOf([p.uuid for p in AdminUser.query.all()])
+                                     )
+    telegram_id = Integer(required=False, description='The Telegram ID associated with the admin', allow_none=True)
+    lang = Enum(Lang, required=True)
+
+
+class PatchAdminSchema(AdminSchema):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields['name'].required = False
+        self.fields['mode'].required = False
+        self.fields['lang'].required = False
+        self.fields['can_add_admin'].required = False
+    pass
+# endregion
+
+
+class SuccessfulSchema(Schema):
+    status = Integer()
+    msg = String()

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

@@ -10,7 +10,7 @@ from hiddifypanel.panel import hiddify
 from hiddifypanel import hutils
 
 
-class ServerStatus(Schema):
+class ServerStatusOutputSchema(Schema):
     stats = Dict(required=True, description="System stats")
     usage_history = Dict(required=True, description="System usage history")
 
@@ -18,9 +18,9 @@ class ServerStatus(Schema):
 class AdminServerStatusApi(MethodView):
     decorators = [login_required({Role.super_admin, Role.admin, Role.agent})]
 
-    @app.output(ServerStatus)  # type: ignore
+    @app.output(ServerStatusOutputSchema)  # type: ignore
     def get(self):
-        dto = ServerStatus()
+        dto = ServerStatusOutputSchema()
         dto.stats = {  # type: ignore
             'system': hutils.system.system_stats(),
             'top5': hutils.system.top_processes()

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

@@ -1,94 +1,30 @@
 from flask import g
 from flask.views import MethodView
 from flask import current_app as app
-from apiflask import abort, Schema
+from apiflask import abort
 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 apiflask.fields import UUID, String, Float, Enum, Date, Time, Integer
 
-from . import SuccessfulSchema, has_permission
-
-
-class UserSchema(Schema):
-    uuid = UUID(required=True, description="Unique identifier for the user")
-    name = String(required=True, description="Name of the user")
-
-    usage_limit_GB = Float(
-        required=False,
-        description="The data usage limit for the user in gigabytes"
-    )
-    package_days = Integer(
-        required=False,
-        description="The number of days in the user's package"
-    )
-    mode = Enum(UserMode,
-                required=False,
-                description="The mode of the user's account, which dictates access level or type"
-                )
-    last_online = Time(
-        format="%Y-%m-%d %H:%M:%S",
-        description="The last time the user was online, converted to a JSON-friendly format"
-    )
-    start_date = Date(
-        format='%Y-%m-%d',
-        description="The start date of the user's package, in a JSON-friendly format"
-    )
-    current_usage_GB = Float(
-        required=False,
-        description="The current data usage of the user in gigabytes"
-    )
-    last_reset_time = Date(
-        format='%Y-%m-%d',
-        description="The last time the user's data usage was reset, in a JSON-friendly format"
-    )
-    comment = String(
-        missing=None,
-        description="An optional comment about the user"
-    )
-    added_by_uuid = UUID(
-        required=False,
-        description="UUID of the admin who added this user",
-        allow_none=True,
-        # validate=OneOf([p.uuid for p in AdminUser.query.all()])
-    )
-    telegram_id = Integer(
-        required=False,
-        description="The Telegram ID associated with the user",
-        allow_none=True
-    )
-    ed25519_private_key = String(
-        required=False,
-        description="If empty, it will be created automatically, The user's private key using the Ed25519 algorithm"
-    )
-    ed25519_public_key = String(
-        required=False,
-        description="If empty, it will be created automatically,The user's public key using the Ed25519 algorithm"
-    )
-
-
-class PatchUserSchema(UserSchema):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.fields['name'].required = False
-    pass
+from . import has_permission
+from .schema import UserSchema, PatchUserSchema, SuccessfulSchema
 
 
 class UserApi(MethodView):
     decorators = [login_required({Role.super_admin, Role.admin, Role.agent})]
 
-    @app.output(UserSchema)
+    @app.output(UserSchema)  # type: ignore
     def get(self, uuid):
         user = User.by_uuid(uuid) or abort(404, "user not found")
         if not has_permission(user):
             abort(403, "You don't have permission to access this user")
 
-        return user.to_dict(False)
+        return user.to_dict(False)  # type: ignore
 
-    @app.input(PatchUserSchema, arg_name="data")
-    @app.output(SuccessfulSchema)
+    @app.input(PatchUserSchema, arg_name="data")  # type: ignore
+    @app.output(SuccessfulSchema)  # type: ignore
     def patch(self, uuid, data):
         user = User.by_uuid(uuid) or abort(404, "user not found")
         if not has_permission(user):
@@ -104,11 +40,11 @@ class UserApi(MethodView):
         hiddify.quick_apply_users()
         return {'status': 200, 'msg': 'ok'}
 
-    @app.output(SuccessfulSchema)
+    @app.output(SuccessfulSchema)  # type: ignore
     def delete(self, uuid):
         user = User.by_uuid(uuid) or abort(404, "user not found")
         if not has_permission(user):
             abort(403, "You don't have permission to access this user")
-        user.remove()
+        user.remove()  # type: ignore
         hiddify.quick_apply_users()
         return {'status': 200, 'msg': 'ok'}

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

@@ -22,7 +22,7 @@ class UsersApi(MethodView):
     @app.output(UserSchema)  # type: ignore
     def put(self, data):
         uuid = data.get('uuid') or abort(422, "Parameter issue: 'uuid'")
-        user = User.by_uuid(uuid)
+        user = User.by_uuid(uuid)  # type: ignore
 
         if not data.get('added_by_uuid'):
             data['added_by_uuid'] = g.account.uuid

hiddifypanel/panel/commercial/restapi/v2/child/__init__.py

@@ -0,0 +1,18 @@
+from apiflask import APIBlueprint
+
+bp = APIBlueprint("api_child", __name__, url_prefix="/<proxy_path>/api/v2/child/", enable_openapi=True)
+
+
+def init_app(app):
+    with app.app_context():
+        from .register_parent_api import RegisterWithParentApi
+        from .sync_parent_api import SyncWithParentApi
+        from .actions import ApplyConfig, Restart, Status, UpdateUsage, Install
+        bp.add_url_rule('/sync-parent/', view_func=SyncWithParentApi)
+        bp.add_url_rule('/register-parent/', view_func=RegisterWithParentApi)
+        bp.add_url_rule('/status/', view_func=Status)
+        bp.add_url_rule('/restart/', view_func=Restart)
+        bp.add_url_rule('/apply-config/', view_func=ApplyConfig)
+        bp.add_url_rule('/install/', view_func=Install)
+        bp.add_url_rule('/update-usage/', view_func=UpdateUsage)
+    app.register_blueprint(bp)

hiddifypanel/panel/commercial/restapi/v2/child/actions.py

@@ -0,0 +1,63 @@
+from apiflask import fields, Schema
+from flask import current_app as app
+from flask import g
+from flask.views import MethodView
+from loguru import logger
+
+from hiddifypanel.models.child import Child
+from hiddifypanel.panel.run_commander import commander, Command
+from hiddifypanel.auth import login_required
+
+
+class Status(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    def post(self):
+        logger.info(f"Status action called by parent: {Child.node.unique_id}")
+        commander(Command.status)
+        return {'status': 200, 'msg': 'ok'}
+
+
+class UpdateUsage(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    def post(self):
+        logger.info(f"Update usage action called by parent: {Child.node.unique_id}")
+        commander(Command.update_usage)
+        return {'status': 200, 'msg': 'ok'}
+
+
+class Restart(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    def post(self):
+        logger.info(f"Restart action called by parent: {Child.node.unique_id}")
+        commander(Command.restart_services)
+        return {'status': 200, 'msg': 'ok'}
+
+
+class ApplyConfig(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    def post(self):
+        logger.info(f"Apply config action called by parent: {Child.node.unique_id}")
+        commander(Command.apply)
+        return {'status': 200, 'msg': 'ok'}
+
+
+class InstallSchema(Schema):
+    full = fields.Boolean(description="full install", required=True, default=True)
+
+
+class Install(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    @app.input(InstallSchema, arg_name="data")  # type: ignore
+    def post(self, data: dict):
+        if data.get('full'):
+            logger.info(f"Install action called by parent: {Child.node.unique_id}, full=True")
+            commander(Command.install)
+        else:
+            logger.info(f"Install action called by parent: {Child.node.unique_id}, full=False")
+            commander(Command.apply)
+        return {'status': 200, 'msg': 'ok'}

hiddifypanel/panel/commercial/restapi/v2/child/register_parent_api.py

@@ -0,0 +1,34 @@
+from apiflask import abort, fields, Schema
+from flask.views import MethodView
+from flask import current_app as app, g
+from flask_babel import lazy_gettext as _
+from loguru import logger
+
+from hiddifypanel.auth import login_required
+from hiddifypanel.models import set_hconfig, ConfigEnum, PanelMode, Role
+from hiddifypanel import hutils
+
+from .schema import RegisterWithParentInputSchema
+
+
+class RegisterWithParentApi(MethodView):
+    decorators = [login_required({Role.super_admin})]
+
+    # TODO: incomplete (not used)
+    @app.input(RegisterWithParentInputSchema, arg_name='data')  # type: ignore
+    def post(self, data):
+        logger.info(f"Registering panel with parent called by {data['parent_unique_id']}")
+        if hutils.node.is_parent() or hutils.node.is_child():
+            logger.error("The panel is not in standalone mode nor in child")
+            abort(400, 'The panel is not in standalone mode nor in child')
+
+        set_hconfig(ConfigEnum.parent_panel, data['parent_panel'])  # type: ignore
+
+        if not hutils.node.child.register_to_parent(data['name'], data['apikey']):
+            logger.error("Child registration to parent failed")
+            set_hconfig(ConfigEnum.parent_panel, '')  # type: ignore
+            abort(400, _('child.register-failed'))  # type: ignore
+
+        set_hconfig(ConfigEnum.panel_mode, PanelMode.child)  # type: ignore
+        logger.info("Registered panel with parent, panel mode is now child")
+        return {'status': 200, 'msg': 'ok'}

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

@@ -0,0 +1,7 @@
+from apiflask import Schema, fields
+
+
+class RegisterWithParentInputSchema(Schema):
+    parent_panel = fields.String(required=True, description="The parent panel url")
+    name = fields.String(required=True, description="The child's name in the parent panel")
+    apikey = fields.String(description="The parent's apikey")

hiddifypanel/panel/commercial/restapi/v2/child/sync_parent_api.py

@@ -0,0 +1,21 @@
+from apiflask import abort
+from flask.views import MethodView
+from flask_babel import lazy_gettext as _
+from flask import g
+from loguru import logger
+
+from hiddifypanel.models.child import Child
+from hiddifypanel.auth import login_required
+from hiddifypanel import hutils
+
+
+class SyncWithParentApi(MethodView):
+    decorators = [login_required(node_auth=True)]
+
+    def post(self):
+        logger.info(f"Syncing panel with parent called by {Child.node.unique_id}")
+        if not hutils.node.child.sync_with_parent():
+            logger.error("Sync with parent failed")
+            abort(400, _('child.sync-failed'))  # type: ignore
+        logger.success(f"Synced panel with parent {Child.node.unique_id}")
+        return {'status': 200, 'msg': 'ok'}

hiddifypanel/panel/commercial/restapi/v2/panel/__init__.py

@@ -0,0 +1,13 @@
+from apiflask import APIBlueprint
+
+bp = APIBlueprint("api_panel", __name__, url_prefix="/<proxy_path>/api/v2/panel/", enable_openapi=True)
+
+
+def init_app(app):
+
+    with app.app_context():
+        from .info import PanelInfoApi
+        from .ping_pong import PingPongApi
+        bp.add_url_rule('/info/', view_func=PanelInfoApi)
+        bp.add_url_rule('/ping/', view_func=PingPongApi)
+    app.register_blueprint(bp)

hiddifypanel/panel/commercial/restapi/v2/panel/info.py

@@ -0,0 +1,18 @@
+from flask.views import MethodView
+from flask import current_app as app
+
+from hiddifypanel.auth import login_required
+from hiddifypanel.models import Role
+from hiddifypanel import __version__
+
+from .schema import PanelInfoOutputSchema
+
+
+class PanelInfoApi(MethodView):
+    decorators = [login_required(roles={Role.super_admin, Role.admin, Role.agent}, node_auth=True)]
+
+    @app.output(PanelInfoOutputSchema)  # type: ignore
+    def get(self):
+        res = PanelInfoOutputSchema()
+        res.version = __version__  # type: ignore
+        return res

hiddifypanel/panel/commercial/restapi/v2/panel/ping_pong.py

@@ -0,0 +1,23 @@
+from flask.views import MethodView
+
+from hiddifypanel.auth import login_required
+from hiddifypanel.models import Role
+
+
+class PingPongApi(MethodView):
+    decorators = [login_required(roles={Role.super_admin, Role.admin, Role.agent}, node_auth=True)]
+
+    def get(self):
+        return {'msg': 'GET: PONG'}
+
+    def post(self):
+        return {'msg': 'POST: PONG'}
+
+    def patch(self):
+        return {'msg': 'PATCH: PONG'}
+
+    def delete(self):
+        return {'msg': 'DELETE: PONG'}
+
+    def put(self):
+        return {'msg': 'PUT: PONG'}

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

@@ -0,0 +1,7 @@
+from apiflask import Schema, fields
+# region info
+
+
+class PanelInfoOutputSchema(Schema):
+    version = fields.String(description="The panel version")
+# endregion

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

@@ -0,0 +1,16 @@
+from apiflask import APIBlueprint
+
+bp = APIBlueprint("api_parent", __name__, url_prefix="/<proxy_path>/api/v2/parent/", enable_openapi=True)
+
+
+def init_app(app):
+    with app.app_context():
+        from .register_api import RegisterApi
+        from .sync_api import SyncApi
+        from .usage_api import UsageApi
+        from .status_api import StatusApi
+        bp.add_url_rule('/status/', view_func=StatusApi)
+        bp.add_url_rule('/register/', view_func=RegisterApi)
+        bp.add_url_rule('/sync/', view_func=SyncApi)
+        bp.add_url_rule('/usage/', view_func=UsageApi)
+    app.register_blueprint(bp)

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

@@ -0,0 +1,65 @@
+from apiflask import abort
+from hiddifypanel.database import db
+from flask import current_app as app
+from flask.views import MethodView
+from loguru import logger
+
+from hiddifypanel.models import *
+from hiddifypanel.auth import login_required
+
+from .schema import RegisterInputSchema, RegisterOutputSchema
+
+
+class RegisterApi(MethodView):
+    decorators = [login_required({Role.super_admin})]
+
+    @app.input(RegisterInputSchema, arg_name='data')  # type: ignore
+    @app.output(RegisterOutputSchema)  # type: ignore
+    def put(self, data):
+        from hiddifypanel import hutils
+        logger.info("Register child panel with unique_id: {}", data['unique_id'])
+        if hutils.node.is_child():
+            logger.error("The panel in child, not a parent nor standalone")
+            abort(400, 'The panel in child, not a parent nor standalone')
+
+        unique_id = data['unique_id']
+        name = data['name']
+        mode = data['mode']
+
+        child = Child.query.filter(Child.unique_id == unique_id).first()
+        if not child:
+            logger.info("Adding new child with unique_id: {}", unique_id)
+            child = Child(unique_id=unique_id, name=name, mode=mode)
+            db.session.add(child)  # type: ignore
+            db.session.commit()  # type: ignore
+            child = Child.query.filter(Child.unique_id == unique_id).first()
+
+        try:
+            # add data
+            logger.info("Adding admin users...")
+            AdminUser.bulk_register(data['panel_data']['admin_users'], commit=False)
+            logger.info("Adding users...")
+            User.bulk_register(data['panel_data']['users'], commit=False)
+            logger.info("Adding domains...")
+            bulk_register_domains(data['panel_data']['domains'], commit=False, force_child_unique_id=child.unique_id)
+            logger.info("Adding hconfigs...")
+            bulk_register_configs(data['panel_data']['hconfigs'], commit=False, froce_child_unique_id=child.unique_id)
+            logger.info("Adding proxies...")
+            Proxy.bulk_register(data['panel_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("Error while registering data")
+            abort(400, str(err))
+
+        if not hutils.node.is_parent():
+            logger.info("Setting panel to parent mode")
+            set_hconfig(ConfigEnum.panel_mode, PanelMode.parent)  # type: ignore
+
+        logger.info("Returning register output")
+        res = RegisterOutputSchema()
+        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
+        res.parent_unique_id = hconfig(ConfigEnum.unique_id)
+
+        return res