hiddifypanel 9.0.0.dev92__py3-none-any.whl → 10.5.0.dev0__py3-none-any.whl

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

@@ -1,87 +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"
-    )
+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(UserSchema, 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):
@@ -97,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

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