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

hiddifypanel/hutils/crypto.py

@@ -0,0 +1,48 @@
+import subprocess
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import x25519, ed25519
+
+
+def get_ed25519_private_public_pair():
+    privkey = ed25519.Ed25519PrivateKey.generate()
+    pubkey = privkey.public_key()
+    priv_bytes = privkey.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.OpenSSH,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    pub_bytes = pubkey.public_bytes(
+        encoding=serialization.Encoding.OpenSSH,
+        format=serialization.PublicFormat.OpenSSH,
+    )
+    return priv_bytes.decode(), pub_bytes.decode()
+
+
+def get_wg_private_public_psk_pair():
+    try:
+        private_key = subprocess.run(["wg", "genkey"], capture_output=True, text=True, check=True).stdout.strip()
+        public_key = subprocess.run(["wg", "pubkey"], input=private_key, capture_output=True, text=True, check=True).stdout.strip()
+        psk = subprocess.run(["wg", "genpsk"], capture_output=True, text=True, check=True).stdout.strip()
+        return private_key, public_key, psk
+    except subprocess.CalledProcessError as e:
+        print(f"Error: {e}")
+        return None, None, None
+
+
+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}

hiddifypanel/hutils/encode.py

@@ -1,7 +1,6 @@
 import urllib.parse
 import base64
 import uuid
-import string
 from slugify import slugify
 
 
@@ -26,6 +25,10 @@ def is_valid_uuid(val: str, version: int | None = None) -> bool:
 
     return True
 
+
+def convert_dict_to_url(dict):
+    return '&' + '&'.join([f'{k}={v}' for k, v in dict.items()]) if len(dict) else ''
+
 # not used
 # def is_assci_alphanumeric(str):
 #     for c in str:

hiddifypanel/hutils/flask.py

@@ -1,18 +1,22 @@
-from typing import List
+from typing import List, Tuple
 from flask import current_app, flash as flask_flash, g, request
+from wtforms.validators import ValidationError
 from apiflask import abort as apiflask_abort
 from flask_babel import lazy_gettext as _
-from flask import url_for, Markup  # type: ignore
+from flask import url_for  # type: ignore
 from urllib.parse import urlparse
+from markupsafe import Markup
+
 import user_agents
 import re
 import os
+
 from hiddifypanel.cache import cache
 from hiddifypanel.models import *
+from hiddifypanel import hutils
 
 
 def flash(message: str, category: str = "message"):
-    # print(message)
     return flask_flash(Markup(message), category)
 
 
@@ -32,7 +36,7 @@ def static_url_for(**values):
 
 
 def hurl_for(endpoint, **values):
-    if Child.current.id != 0:
+    if Child.current().id != 0:
 
         new_endpoint = "child_" + endpoint
         if new_endpoint in current_app.view_functions:
@@ -217,7 +221,36 @@ def proxy_path_validator(proxy_path: str) -> None:
 
 
 def list_dir_files(dir_path: str) -> List[str]:
-    return [f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))]
+    return sorted([f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))])
+
+
+def validate_domain_exist(form, field):
+    domain = field.data
+    if not domain:
+        return
+    dip = hutils.network.get_domain_ip(domain)
+    if dip is None:
+        raise ValidationError(
+            _("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
+
+
+def get_proxy_stats_url():
+    proxy_stats_url = f'{request.host_url}{g.proxy_path}/proxy-stats/'
+    params = f'hostname={proxy_stats_url}api/&port=443&secret=hiddify'
+    return f'{proxy_stats_url}?{params}/'
+
+
+def extract_parent_info_from_url(url) -> Tuple[str | None, str | None, str | None]:
+    pattern = r'^https?://([^/]+)/([^/]+)/([^/]+)/.*$'
+    match = re.match(pattern, url)
+
+    if match:
+        domain = match.group(1)
+        proxy_path = match.group(2)
+        admin_uuid = match.group(3)
+        return domain, proxy_path, admin_uuid
+    else:
+        return None, None, None
 # region not used
 
 

hiddifypanel/hutils/github_issue.py

@@ -12,7 +12,6 @@ from flask import g, request, render_template
 import hiddifypanel
 from hiddifypanel.models.config import hconfig
 from hiddifypanel.models.config_enum import ConfigEnum
-from hiddifypanel.auth import current_account
 
 
 class __IssueUrl:
@@ -136,6 +135,7 @@ def __github_issue_details() -> dict:
 
 
 def __remove_sensetive_data_from_github_issue_link(issue_link: str):
+    from hiddifypanel.auth import current_account
     if current_account.uuid:
         issue_link.replace(f'{current_account.uuid}', '*******************')
 

hiddifypanel/hutils/importer/xui.py

@@ -6,15 +6,18 @@ from datetime import datetime
 from dateutil.relativedelta import relativedelta
 from hiddifypanel import hutils
 from hiddifypanel.models import *
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute
 import os
+from sqlalchemy import text
 
 
 def __query_fetch_json(db, query: str, args: Tuple = ()) -> List[Dict[str, Any]]:
     try:
-        db.execute(query, args) if args else db.execute(query)
+
+        db_execute(query, args)
         r = [dict((db.description[i][0], value)
                   for i, value in enumerate(row)) for row in db.fetchall()]
+        connection.close()
         return r
     except Exception as err:
         raise err

hiddifypanel/{models/utils.py → hutils/model.py}

@@ -1,6 +1,4 @@
-
-
-def fill_username(model) -> None:
+def gen_username(model) -> None:
     from hiddifypanel import hutils
     if model.username:
         return
@@ -19,8 +17,20 @@ def fill_username(model) -> None:
         model.username += rand_str
 
 
-def fill_password(model) -> None:
+def gen_password(model) -> None:
     from hiddifypanel import hutils
     # TODO: hash the password
     if not model.password or len(model.password) < 16:
         model.password = hutils.random.get_random_password(length=16)
+
+
+def gen_wg_keys(model) -> None:
+    from hiddifypanel import hutils
+    if not model.wg_pk or not model.wg_pub or not model.wg_psk:
+        model.wg_pk, model.wg_pub, model.wg_psk = hutils.crypto.get_wg_private_public_psk_pair()
+
+
+def gen_ed25519_keys(model) -> None:
+    from hiddifypanel import hutils
+    if not model.ed25519_private_key or not model.ed25519_public_key:
+        model.ed25519_private_key, model.ed25519_public_key = hutils.crypto.get_ed25519_private_public_pair()

hiddifypanel/hutils/network/auto_ip_selector.py

@@ -116,6 +116,8 @@ def get_real_user_ip_debug(user_ip: str = '') -> str:
 
 @cache.cache()
 def __get_real_user_ip_debug_imp(user_ip) -> str:
+    if type(user_ip) is str and ',' in user_ip:
+        user_ip = user_ip.split(',')[0]
     asnres = IPASN.get(user_ip) or {}
     asn = f"{asnres.get('autonomous_system_number','unknown')}" if asnres else "unknown"
     asn_dscr = f"{asnres.get('autonomous_system_organization','unknown')}" if asnres else "unknown"

hiddifypanel/hutils/network/net.py

@@ -1,7 +1,8 @@
-from typing import List, Literal, Union
+from typing import List, Literal, Tuple, Union
 from urllib.parse import urlparse
 import urllib.request
 import ipaddress
+from hiddifypanel.hutils.network.auto_ip_selector import IPASN
 import netifaces
 import requests
 import random
@@ -16,7 +17,7 @@ from hiddifypanel.models import *
 from hiddifypanel.cache import cache
 
 
-def get_domain_ip(domain: str, retry: int = 3, version: Literal[4, 6] = None) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]:
+def get_domain_ip(domain: str, retry: int = 3, version: Literal[4, 6] | None = None) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]:
     res = None
     if not version:
         try:
@@ -326,3 +327,46 @@ def add_number_to_ipv6(ip: str, number: int) -> str:
     modified_ipv6 = ":".join(segments)
 
     return modified_ipv6
+
+
+def is_in_same_asn(domain_or_ip: str, domain_or_ip_target: str) -> bool:
+    '''Returns True if domain is in panel ASN'''
+    if not IPASN:
+        return False
+    try:
+        ip = domain_or_ip if is_ip(domain_or_ip) else get_domain_ip(domain_or_ip)
+        ip_target = domain_or_ip_target if is_ip(domain_or_ip_target) else get_domain_ip(domain_or_ip_target)
+
+        if not ip or not ip_target:
+            return False
+
+        ip_asn = get_ip_asn_name(ip)
+        ip_target_asn = get_ip_asn_name(ip_target)
+
+        if not ip_asn or not ip_target_asn:
+            return False
+
+        return ip_asn == ip_target_asn
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return False
+
+        # 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")
+
+
+def get_ip_asn_name(ip: ipaddress.IPv4Address | ipaddress.IPv6Address | str) -> str:
+    try:
+        if asn := IPASN.get(str(ip)):
+            return str(asn.get('autonomous_system_organization', ''))
+        return ''
+    except:
+        return ''
+
+
+def is_ip(input: str):
+    try:
+        _ = ipaddress.ip_address(input)
+        return True
+    except:
+        return False

hiddifypanel/hutils/node/__init__.py

@@ -0,0 +1,3 @@
+from .shared import *
+from . import child
+from . import parent

hiddifypanel/hutils/node/api_client.py

@@ -0,0 +1,76 @@
+from typing import Optional, Union, Type
+from apiflask import Schema, fields
+import traceback
+import requests
+from loguru import logger
+from hiddifypanel.models import hconfig, ConfigEnum
+
+
+class NodeApiErrorSchema(Schema):
+    msg = fields.String(required=True)
+    stacktrace = fields.String(required=True)
+    code = fields.Integer(required=True)
+    reason = fields.String(required=True)
+
+
+class NodeApiClient():
+    def __init__(self, base_url: str, apikey: Optional[str] = None, max_retry: int = 3):
+        self.base_url = base_url if base_url.endswith('/') else base_url+'/'
+        self.max_retry = max_retry
+        self.headers = {'Hiddify-API-Key': apikey or hconfig(ConfigEnum.unique_id)}
+
+    def __call(self, method: str, path: str, payload: Optional[Schema], output_schema: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:  # type: ignore
+        retry_count = 1
+        full_url = self.base_url + path.removeprefix('/')
+        while 1:
+            try:
+                # TODO: implement it with aiohttp
+
+                logger.trace(f"Attempting {method} request to node at {full_url}")
+
+                # send request
+                if payload:
+                    response = requests.request(method, full_url, json=payload.dump(payload), headers=self.headers)
+                else:
+                    response = requests.request(method, full_url, headers=self.headers)
+
+                # parse response
+                response.raise_for_status()
+                resp = response.json()
+                if not resp:
+                    err = NodeApiErrorSchema()
+                    err.msg = 'Empty response'  # type: ignore
+                    err.stacktrace = ''  # type: ignore
+                    err.code = response.status_code  # type: ignore
+                    err.reason = response.reason  # type: ignore
+                    with logger.contextualize(payload=payload):
+                        logger.warning(f"Received empty response from {full_url} with method {method}")
+                    return err
+
+                logger.trace(f"Successfully received response from {full_url}")
+                return resp if isinstance(output_schema, type(dict)) else output_schema().load(resp)  # type: ignore
+
+            except requests.HTTPError as e:
+                if retry_count >= self.max_retry:
+                    stack_trace = traceback.format_exc()
+                    err = NodeApiErrorSchema()
+                    err.msg = str(e)  # type: ignore
+                    err.stacktrace = stack_trace  # type: ignore
+                    err.code = response.status_code  # type: ignore
+                    err.reason = response.reason  # type: ignore
+                    with logger.contextualize(status_code=err.code, reason=err.reason, stack_trace=stack_trace, payload=payload):
+                        logger.error(f"HTTP error after {self.max_retry} retries")
+                        logger.exception(e)
+                    return err
+
+                logger.warning(f"Error occurred: {e} from {full_url} with method {method}, retrying... ({retry_count}/{self.max_retry})")
+                retry_count += 1
+
+    def get(self, path: str, output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("GET", path, None, output)
+
+    def post(self, path: str, payload: Optional[Schema], output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("POST", path, payload, output)
+
+    def put(self, path: str, payload: Optional[Schema], output: Type[Union[Schema, dict]]) -> Union[dict, NodeApiErrorSchema]:
+        return self.__call("PUT", path, payload, output)

hiddifypanel/hutils/node/child.py

@@ -0,0 +1,147 @@
+from loguru import logger
+import socket
+
+from hiddifypanel.models import AdminUser, User, hconfig, ConfigEnum, ChildMode, set_hconfig, Domain, Proxy, StrConfig, BoolConfig, Child, ChildMode
+from hiddifypanel import hutils
+from hiddifypanel.panel import hiddify
+from hiddifypanel.panel import usage
+from hiddifypanel.database import db
+from hiddifypanel.cache import cache
+
+# import schmeas
+from hiddifypanel.panel.commercial.restapi.v2.parent.schema import *
+from hiddifypanel.panel.commercial.restapi.v2.child.schema import *
+
+from .api_client import NodeApiClient, NodeApiErrorSchema
+# region private
+
+
+def __get_register_data_for_api(name: str, mode: ChildMode) -> RegisterInputSchema:
+
+    register_data = RegisterInputSchema()
+    register_data.unique_id = hconfig(ConfigEnum.unique_id)
+    register_data.name = name  # type: ignore
+    register_data.mode = mode  # type: ignore
+
+    panel_data = RegisterDataSchema()  # type: ignore
+    panel_data.admin_users = [admin_user.to_schema() for admin_user in AdminUser.query.all()]  # type: ignore
+    panel_data.users = [user.to_schema() for user in User.query.all()]  # type: ignore
+    panel_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+    panel_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+    panel_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+    register_data.panel_data = panel_data
+
+    return register_data
+
+
+def __get_sync_data_for_api() -> SyncInputSchema:
+    sync_data = SyncInputSchema()
+    sync_data.domains = [domain.to_schema() for domain in Domain.query.all()]  # type: ignore
+    sync_data.proxies = [proxy.to_schema() for proxy in Proxy.query.all()]  # type: ignore
+    sync_data.hconfigs = [*[u.to_schema() for u in StrConfig.query.all()], *[u.to_schema() for u in BoolConfig.query.all()]]  # type: ignore
+
+    return sync_data
+
+
+def __get_parent_panel_url() -> str:
+    url = 'https://' + f"{hconfig(ConfigEnum.parent_domain).removesuffix('/')}/{hconfig(ConfigEnum.parent_admin_proxy_path).removesuffix('/')}"
+    return url
+
+# endregion
+
+
+def is_registered() -> bool:
+    '''Checks if the current parent registered as a child'''
+    try:
+        logger.debug("Checking if current panel is registered with parent")
+        base_url = __get_parent_panel_url()
+        if not base_url:
+            return False
+        payload = ChildStatusInputSchema()
+        payload.child_unique_id = hconfig(ConfigEnum.unique_id)
+
+        res = NodeApiClient(base_url).post('/api/v2/parent/status/', payload, ChildStatusOutputSchema)
+        if isinstance(res, NodeApiErrorSchema):
+            logger.error(f"Error while checking if current panel is registered with parent: {res.msg}")
+            return False
+
+        if res['existance']:
+            return True
+        return False
+    except Exception as e:
+        logger.error(f"Error while checking if current panel is registered with parent")
+        logger.exception(e)
+        return False
+
+
+def register_to_parent(name: str, apikey: str, mode: ChildMode = ChildMode.remote) -> bool:
+    # get parent link its format is "https://panel.hiddify.com/<admin_proxy_path>/"
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Parent url is empty")
+        return False
+
+    payload = __get_register_data_for_api(name, mode)
+    res = NodeApiClient(p_url, apikey).put('/api/v2/parent/register/', payload, RegisterOutputSchema)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while registering to parent: {res.msg}")
+        return False
+
+    # TODO: change the bulk_register and such methods to accept models instead of dict
+    AdminUser.bulk_register(res['admin_users'], commit=False)
+    User.bulk_register(res['users'], commit=False)
+
+    # add new child as parent
+    db.session.add(  # type: ignore
+        Child(unique_id=res['parent_unique_id'], name=socket.gethostname() or res['parent_unique_id'], mode=ChildMode.parent)
+    )
+
+    db.session.commit()  # type: ignore
+
+    logger.success("Successfully registered to parent")
+    cache.invalidate_all_cached_functions()
+    return True
+
+
+def sync_with_parent() -> bool:
+    # sync usage first
+    if not sync_users_usage_with_parent():
+        logger.error("Error while syncing with parent: Failed to sync users usage")
+        return False
+
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Error while syncing with parent: Parent url is empty")
+        return False
+    payload = __get_sync_data_for_api()
+    res = NodeApiClient(p_url).put('/api/v2/parent/sync/', payload, SyncOutputSchema)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while syncing with parent: {res.msg}")
+        return False
+    AdminUser.bulk_register(res['admin_users'], commit=False, remove=True)
+    User.bulk_register(res['users'], commit=False, remove=True)
+    db.session.commit()  # type: ignore
+    logger.success("Successfully synced with parent")
+    cache.invalidate_all_cached_functions()
+    return True
+
+
+def sync_users_usage_with_parent() -> bool:
+    p_url = __get_parent_panel_url()
+    if not p_url:
+        logger.error("Parent url is empty")
+        return False
+
+    payload = hutils.node.get_users_usage_data_for_api()
+    if payload:
+        res = NodeApiClient(p_url).put('/api/v2/parent/usage/', payload, UsageInputOutputSchema)  # type: ignore
+        if isinstance(res, NodeApiErrorSchema):
+            logger.error(f"Error while syncing users usage with parent: {res.msg}")
+            return False
+
+        # parse usages data
+        res = hutils.node.convert_usage_api_response_to_dict(res)  # type: ignore
+        usage.add_users_usage_uuid(res, hiddify.get_child(None), True)
+        logger.success(f"Successfully synced users usage with parent: {res}")
+
+    return True

hiddifypanel/hutils/node/parent.py

@@ -0,0 +1,100 @@
+from flask import g
+from flask_babel import lazy_gettext as _
+from typing import List
+from loguru import logger
+
+from hiddifypanel.models import Child, AdminUser, ConfigEnum, Domain, ChildMode, hconfig, get_panel_link
+from hiddifypanel import hutils
+from hiddifypanel.panel.commercial.restapi.v2.child.schema import RegisterWithParentInputSchema
+from .api_client import NodeApiClient, NodeApiErrorSchema
+
+from hiddifypanel.cache import cache
+
+
+def request_childs_to_sync():
+    for c in Child.query.filter(Child.id != 0).all():
+        if not request_child_to_sync(c):
+            logger.error(f'{c.name}: {_("parent.sync-req-failed")}')
+            hutils.flask.flash(f'{c.name}: ' + _('parent.sync-req-failed'), 'danger')
+
+
+def request_child_to_sync(child: Child) -> bool:
+    '''Requests to a child to sync itself with the current panel'''
+    child_domain = get_panel_link(child.id)
+    if not child_domain:
+        logger.error(f"Child {child.name} has no valid domain")
+        return False
+
+    child_admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin, child.id)
+    base_url = f'https://{child_domain}/{child_admin_proxy_path}'
+    path = '/api/v2/child/sync-parent/'
+    res = NodeApiClient(base_url).post(path, payload=None, output=dict)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while requesting child {child.name} to sync: {res.msg}")
+        return False
+    if res['msg'] == 'ok':
+        logger.success(f"Successfully requested child {child.name} to sync")
+        cache.invalidate_all_cached_functions()
+        return True
+
+    logger.error(f"Request to child {child.name} to sync failed")
+    return False
+
+# before using this function should check child version
+
+
+# TODO: not used
+def request_chlid_to_register(name: str, child_link: str, apikey: str) -> bool:
+    '''Requests to a child to register itself with the current panel'''
+    if not child_link or not apikey:
+        logger.error("Child link or apikey is empty")
+        return False
+    domain = get_panel_link()
+    if not domain:
+        logger.error("Domain is empty")
+        return False
+    from hiddifypanel.panel import hiddify
+
+    payload = RegisterWithParentInputSchema()
+    payload.parent_panel = hiddify.get_account_panel_link(AdminUser.by_uuid(g.account.uuid), domain.domain)  # type: ignore
+    payload.apikey = payload.name = hconfig(ConfigEnum.unique_id)
+
+    logger.debug(f"Requesting child {name} to register")
+    res = NodeApiClient(child_link, apikey).post('/api/v2/child/register-parent/', payload, dict)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while requesting child {name} to register: {res.msg}")
+        return False
+
+    if res['msg'] == 'ok':
+        logger.success(f"Successfully requested child {name} to register")
+        cache.invalidate_all_cached_functions()
+        return True
+
+    logger.error(f"Request to child {name} to register failed")
+    return False
+
+
+def is_child_domain_active(child: Child, domain: Domain) -> bool:
+    '''Checks whether a child's domain is responsive'''
+    if not domain.need_valid_ssl:
+        return False
+    child_admin_proxy_path = hconfig(ConfigEnum.proxy_path_admin, child.id)
+    if not child_admin_proxy_path:
+        return False
+
+    return hutils.node.is_panel_active(domain.domain, child_admin_proxy_path)
+
+
+def get_child_active_domains(child: Child) -> List[Domain]:
+    actives = []
+    for d in child.domains:
+        if is_child_domain_active(child, d):
+            actives.append(d)
+    return actives
+
+
+def is_child_active(child: Child) -> bool:
+    for d in child.domains:
+        if is_child_domain_active(child, d):
+            return True
+    return False

hiddifypanel/hutils/node/shared.py

@@ -0,0 +1,65 @@
+from loguru import logger
+
+from hiddifypanel.models import hconfig, ConfigEnum, PanelMode, User
+from hiddifypanel.cache import cache
+from hiddifypanel.panel.commercial.restapi.v2.parent.schema import UsageInputOutputSchema, UsageData
+from hiddifypanel.panel.commercial.restapi.v2.panel.schema import PanelInfoOutputSchema
+from .api_client import NodeApiClient, NodeApiErrorSchema
+
+
+def is_child() -> bool:
+    return hconfig(ConfigEnum.panel_mode) == PanelMode.child
+
+
+def is_parent() -> bool:
+    return hconfig(ConfigEnum.panel_mode) == PanelMode.parent
+
+# region usage
+
+
+def get_users_usage_data_for_api() -> UsageInputOutputSchema:
+    res = UsageInputOutputSchema()
+    res.usages = []  # type: ignore
+    for u in User.query.all():
+        usage_data = UsageData()
+        usage_data.uuid = u.uuid
+        usage_data.usage = u.current_usage
+        usage_data.devices = u.devices
+        res.usages.append(usage_data)  # type: ignore
+    return res
+
+
+def convert_usage_api_response_to_dict(data: dict) -> dict:
+    converted = {}
+    for i in data['usages']:  # type: ignore
+        converted[str(i['uuid'])] = {
+            'usage': i['usage'],
+            'devices': ','.join(i['devices'])  # type: ignore
+        }
+    return converted
+
+# endregion
+
+
+#@cache.cache(ttl=150)
+def is_panel_active(domain: str, proxy_path: str,apikey:str|None = None) -> bool:
+    base_url = f'https://{domain}/{proxy_path}'
+    res = NodeApiClient(base_url,apikey).get('/api/v2/panel/ping/', dict)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while checking if panel is active: {res.msg}")
+        return False
+    if 'PONG' in res['msg']:
+        logger.debug(f"Panel is active: {res['msg']}")
+        return True
+    logger.debug("Panel is not active")
+    return False
+
+
+#@cache.cache(300)
+def get_panel_info(domain: str, proxy_path: str,apikey:str|None = None) -> dict | None:
+    base_url = f'https://{domain}/{proxy_path}'
+    res = NodeApiClient(base_url,apikey).get('/api/v2/panel/info/', PanelInfoOutputSchema)
+    if isinstance(res, NodeApiErrorSchema):
+        logger.error(f"Error while getting panel info from {domain}: {res.msg}")
+        return None
+    return res