hiddifypanel 10.11.1__py3-none-any.whl → 10.12.0__py3-none-any.whl

hiddifypanel/hutils/proxy/xrayjson.py

@@ -0,0 +1,391 @@
+import datetime
+import json
+import copy
+from flask import render_template, request, g
+from hiddifypanel import hutils
+from hiddifypanel.models import Proxy, ProxyTransport, ProxyL3, ProxyCDN, ProxyProto, Domain, ConfigEnum, DomainType
+from flask_babel import gettext as _
+from .xray import is_muxable_agent
+OUTBOUND_LEVEL = 8
+
+
+def configs_as_json(domains: list[Domain], remarks: str) -> str:
+    '''Returns xray configs as json'''
+    outbounds = []
+    for proxy in hutils.proxy.get_valid_proxies(domains):
+        outbound = to_xray(proxy)
+        if 'msg' not in outbound:
+            outbounds.append(outbound)
+
+    outbounds_len = len(outbounds)
+    # reutrn no outbound
+    if outbounds_len < 1:
+        return ''
+
+    all_configs = []
+    base_config = json.loads(render_template('base_xray_config.json.j2', remarks=remarks))
+    # multiple outbounds needs multiple whole base config not just one with multiple outbounds (at least for v2rayng)
+    # https://github.com/2dust/v2rayNG/pull/2827#issue-2127534078
+    if outbounds_len > 1:
+        for out in outbounds:
+            base_config['remarks'] = out['tag']
+            base_config['outbounds'].insert(0, out)
+            all_configs.append(copy.deepcopy(base_config))
+            del base_config['outbounds'][0]
+    else:  # single outbound
+        base_config['outbounds'].insert(0, outbounds[0])
+        all_configs = base_config
+
+    json_configs = json.dumps(all_configs, indent=2, cls=hutils.proxy.ProxyJsonEncoder)
+    return json_configs
+
+
+def to_xray(proxy: dict) -> dict:
+    outbound = {
+        'tag': f'{proxy["extra_info"]} {proxy["name"]} § {proxy["port"]} {proxy["dbdomain"].id}',
+        'protocol': str(proxy['proto']),
+        'settings': {},
+        'streamSettings': {},
+        'mux': {  # default value
+            'enabled': False,
+            'concurrency': -1
+        }
+    }
+    # add multiplex to outbound
+    add_multiplex(outbound, proxy)
+
+    # add stream setting to outbound
+    add_stream_settings(outbound, proxy)
+
+    # add protocol settings to outbound
+    add_proto_settings(outbound, proxy)
+
+    return outbound
+
+# region proto settings
+
+
+def add_proto_settings(base: dict, proxy: dict):
+    if proxy['proto'] == ProxyProto.wireguard:
+        add_wireguard_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.ss:
+        add_shadowsocks_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.vless:
+        add_vless_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.vmess:
+        add_vmess_settings(base, proxy)
+    elif proxy['proto'] == ProxyProto.trojan:
+        proxy['password'] = proxy['uuid']
+        add_trojan_settings(base, proxy)
+
+
+def add_wireguard_settings(base: dict, proxy: dict):
+
+    base['settings']['secretKey'] = proxy['wg_pk']
+    base['settings']['reversed'] = [0, 0, 0]
+    base['settings']['mtu'] = 1380  # optional
+    base['settings']['peers'] = [{
+        'endpoint': f'{proxy["server"]}:{int(proxy["port"])}',
+        'publicKey': proxy["wg_server_pub"]
+        # 'allowedIPs':'', 'preSharedKey':'', 'keepAlive':'' # optionals
+    }]
+
+    # optionals
+    # base['settings']['address'] = [f'{proxy["wg_ipv4"]}/32',f'{proxy["wg_ipv6"]}/128']
+    # base['settings']['workers'] = 4
+    # base['settings']['domainStrategy'] = 'ForceIP' # default
+
+
+def add_vless_settings(base: dict, proxy: dict):
+    base['settings']['vnext'] = [
+        {
+            'address': proxy['server'],
+            'port': proxy['port'],
+            "users": [
+                {
+                    'id': proxy['uuid'],
+                    'encryption': 'none',
+                    # 'security': 'auto',
+                    'flow': 'xtls-rprx-vision' if (proxy['transport'] == ProxyTransport.XTLS or base['streamSettings']['security'] == 'reality') else '',
+                    'level': OUTBOUND_LEVEL
+                }
+            ]
+        }
+    ]
+
+
+def add_vmess_settings(base: dict, proxy: dict):
+    base['settings']['vnext'] = [
+        {
+            "address": proxy['server'],
+            "port": proxy['port'],
+            "users": [
+                {
+                    "id": proxy['uuid'],
+                    "security": proxy['cipher'],
+                    "level": OUTBOUND_LEVEL
+                }
+            ]
+        }
+    ]
+
+
+def add_trojan_settings(base: dict, proxy: dict):
+    base['settings']['servers'] = [
+        {
+            # 'email': proxy['uuid'], optional
+            'address': proxy['server'],
+            'port': proxy['port'],
+            'password': proxy['password'],
+            'level': OUTBOUND_LEVEL
+        }
+    ]
+
+
+def add_shadowsocks_settings(base: dict, proxy: dict):
+    base['settings']['servers'] = [
+        {
+            'address': proxy['server'],
+            'port': proxy['port'],
+            'method': proxy['cipher'],
+            'password': proxy['password'],
+            'uot': True,
+            'level': OUTBOUND_LEVEL
+            # 'email': '', optional
+        }
+    ]
+
+# endregion
+
+
+# region stream settings
+
+def add_stream_settings(base: dict, proxy: dict):
+    ss = base['streamSettings']
+    ss['security'] = 'none'  # default
+
+    # security
+    if proxy['l3'] == ProxyL3.reality:
+        ss['security'] = 'reality'
+    elif proxy['l3'] in [ProxyL3.tls, ProxyL3.tls_h2, ProxyL3.tls_h2_h1]:
+        ss['security'] = 'tls'
+
+    # network and transport settings
+    if ss['security'] == 'tls' or 'xtls':
+        ss['tlsSettings'] = {
+            'serverName': proxy['sni'],
+            'allowInsecure': proxy['allow_insecure'],
+            'fingerprint': proxy['fingerprint'],
+            'alpn': [proxy['alpn']],
+            # 'minVersion': '1.2',
+            # 'disableSystemRoot': '',
+            # 'enableSessionResumption': '',
+            # 'pinnedPeerCertificateChainSha256': '',
+            # 'certificates': '',
+            # 'maxVersion': '1.3', # Go lang sets
+            # 'cipherSuites': '', # Go lang sets
+            # 'rejectUnknownSni': '', # default is false
+        }
+    if ss['security'] == 'reality':
+        ss['network'] = proxy['transport']
+        add_reality_stream(ss, proxy)
+    if proxy['l3'] == ProxyL3.kcp:
+        ss['network'] = 'kcp'
+        add_kcp_stream(ss, proxy)
+
+    if proxy['l3'] == ProxyL3.h3_quic:
+        add_quic_stream(ss, proxy)
+
+    if proxy['transport'] == 'tcp' or ss['security'] == 'reality' or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS]):
+        ss['network'] = proxy['transport']
+        add_tcp_stream(ss, proxy)
+    if proxy['transport'] == ProxyTransport.h2 and ss['security'] == 'none' and ss['security'] != 'reality':
+        ss['network'] = proxy['transport']
+        add_http_stream(ss, proxy)
+    if proxy['transport'] == ProxyTransport.grpc:
+        ss['network'] = proxy['transport']
+        add_grpc_stream(ss, proxy)
+    if proxy['transport'] == ProxyTransport.httpupgrade:
+        ss['network'] = proxy['transport']
+        add_httpupgrade_stream(ss, proxy)
+    if proxy['transport'] == 'ws':
+        ss['network'] = proxy['transport']
+        add_ws_stream(ss, proxy)
+
+    # tls fragmentaion
+    add_tls_fragmentation_stream_settings(base, proxy)
+
+
+def add_tcp_stream(ss: dict, proxy: dict):
+    if proxy['l3'] == ProxyL3.http:
+        ss['tcpSettings'] = {
+            'header': {
+                'type': 'http',
+                'request': {
+                    'path': [proxy['path']]
+                }
+            }
+            # 'acceptProxyProtocol': False
+        }
+    else:
+        ss['tcpSettings'] = {
+            'header': {
+                'type': 'none'
+            }
+            # 'acceptProxyProtocol': False
+        }
+
+
+def add_http_stream(ss: dict, proxy: dict):
+    ss['httpSettings'] = {
+        'host': proxy['host'],
+        'path': proxy['path'],
+        # 'read_idle_timeout': 10,  # default disabled
+        # 'health_check_timeout': 15,  # default is 15
+        # 'method': 'PUT',  # default is 15
+        # 'headers': {
+
+        # }
+    }
+
+
+def add_ws_stream(ss: dict, proxy: dict):
+    ss['wsSettings'] = {
+        'path': proxy['path'],
+        'headers': {
+            "Host": proxy['host']
+        }
+        # 'acceptProxyProtocol': False,
+    }
+
+
+def add_grpc_stream(ss: dict, proxy: dict):
+    ss['grpcSettings'] = {
+        'serviceName': proxy['path'],  # proxy['path'] is equal toproxy['grpc_service_name']
+        'idle_timeout': 115,  # by default, the health check is not enabled. may solve some "connection drop" issues
+        'health_check_timeout': 20,  # default is 20
+        # 'initial_windows_size': 0,  # 0 means disabled. greater than 65535 means Dynamic Window mechanism will be disabled
+        # 'permit_without_stream': False, # health check performed when there are no sub-connections
+        # 'multiMode': false, # experimental
+    }
+
+
+def add_httpupgrade_stream(ss: dict, proxy: dict):
+    ss['httpupgradeSettings'] = {
+        'path': proxy['path'],
+        'host': proxy['host'],
+        # 'acceptProxyProtocol': '', for inbounds only
+    }
+
+
+def add_kcp_stream(ss: dict, proxy: dict):
+    # TODO: fix server side configs first
+    ss['kcpSettings'] = {}
+    return
+    ss['kcpSettings'] = {
+        'seed': proxy['path'],
+        # 'mtu': 1350, # optional, default value is written
+        # 'tti': 50, # optional, default value is written
+        # 'uplinkCapacity': 5, # optional, default value is written
+        # 'downlinkCapacity': 20, # optional, default value is written
+        # 'congestion':False, # optional, default value is written
+        # 'readBufferSize': 2,# optional, default value is written
+        # 'writeBufferSize':2 # optional, default value is written
+        # 'header': { # must be same as server (hiddify doesn't use yet)
+        #     'type': 'none'  # choices: none(default), srtp, utp, wechat-video, dtls, wireguards
+        # }
+    }
+
+
+def add_quic_stream(ss: dict, proxy: dict):
+    # TODO: fix server side configs first
+    ss['quicSettings'] = {}
+    return
+    ss['quicSettings'] = {
+        'security': 'chacha20-poly1305',
+        'key': proxy['path'],
+        'header': {
+            'type': 'none'
+        }
+    }
+
+
+def add_reality_stream(ss: dict, proxy: dict):
+    ss['realitySettings'] = {
+        'serverName': proxy['sni'],
+        'fingerprint': proxy['fingerprint'],
+        'shortId': proxy['reality_short_id'],
+        'publicKey': proxy['reality_pbk'],
+        'show': False,
+    }
+
+
+def add_tls_fragmentation_stream_settings(base: dict, proxy: dict):
+    '''Adds tls fragment in the outbounds if tls fragmentation is enabled'''
+    if base['streamSettings']['security'] in ['tls', 'reality']:
+        if proxy.get('tls_fragment_enable'):
+            base['streamSettings']['sockopt'] = {
+                'dialerProxy': 'fragment',
+                'tcpKeepAliveIdle': 100,
+                'tcpNoDelay': True,  # recommended to be enabled with "tcpMptcp": true.
+                "mark": 255
+                # 'tcpFastOpen': True, # the system default setting be used.
+                # 'tcpKeepAliveInterval': 0, # 0 means default GO lang settings, -1 means not enable
+                # 'tcpcongestion': bbr, # Not configuring means using the system default value
+                # 'tcpMptcp': True, # need to be enabled in both server and client configuration (not supported by panel yet)
+            }
+
+# endregion
+
+
+def add_multiplex(base: dict, proxy: dict):
+    if proxy.get('mux_enable') != "xray":
+        return
+
+    concurrency = proxy['mux_max_connections']
+    if concurrency and concurrency > 0:
+        base['mux']['enabled'] = True
+        base['mux']['concurrency'] = concurrency
+        base['mux']['xudpConcurrency'] = concurrency
+        base['mux']['xudpProxyUDP443'] = 'reject'
+
+
+def add_tls_tricks_to_dict(d: dict, proxy: dict):
+    if proxy.get('tls_fragment_enable'):
+        if g.user_agent.get('is_shadowrocket'):
+            d['fragment'] = f'1,{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]}'
+        else:
+            d['fragment'] = f'{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]},tlshello'
+
+    if proxy.get("tls_mixed_case"):
+        d['mc'] = 1
+    if proxy.get("tls_padding_enable"):
+        d['padsize'] = proxy["tls_padding_length"]
+
+
+def add_mux_to_dict(d: dict, proxy):
+    if not is_muxable_agent(proxy):
+        return
+
+    # according to github.com/hiddify/ray2sing/
+    d['muxtype'] = proxy["mux_protocol"]
+    d['muxmaxc'] = proxy["mux_max_connections"]
+    d['mux'] = proxy['mux_min_streams']
+    d['muxsmax'] = proxy["mux_max_streams"]
+    d['muxpad'] = proxy["mux_padding_enable"]
+
+    if proxy.get('mux_brutal_enable'):
+        d['muxup'] = proxy["mux_brutal_up_mbps"]
+        d['muxdown'] = proxy["mux_brutal_down_mbps"]
+
+
+def add_tls_tricks_to_link(proxy: dict) -> str:
+    out = {}
+    add_tls_tricks_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)
+
+
+def add_mux_to_link(proxy: dict) -> str:
+    out = {}
+    add_mux_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)

hiddifypanel/hutils/random.py

@@ -48,3 +48,7 @@ def get_random_unused_port():
     while __is_in_used_port(port):
         port = random.randint(11000, 60000)
     return port
+
+
+def random_case(string):
+    return ''.join(random.choice((str.upper, str.lower))(c) for c in string)

hiddifypanel/models/config.py

@@ -63,14 +63,19 @@ def hconfig(key: ConfigEnum, child_id: int | None = None) -> str | int | None:
     except BaseException:
         error(f'{key} error!')
         raise
-
+    if key.type == int and value != None:
+        return int(value)
     return value
 
 
 def set_hconfig(key: ConfigEnum, value: str | int | bool, child_id: int | None = None, commit: bool = True):
     if child_id is None:
         child_id = Child.current.id
+
     print(f"chainging .... {key}---{value}---{child_id}---{commit}")
+    if key.type == int and value != None:
+        int(value)  # for testing int
+
     # hconfig.invalidate(key, child_id)
     # get_hconfigs.invalidate(child_id)
     hconfig.invalidate(key, child_id)
@@ -113,7 +118,7 @@ def get_hconfigs(child_id: int | None = None, json=False) -> dict:
         child_id = Child.current.id
 
     return {**{f'{u.key}' if json else u.key: u.value for u in BoolConfig.query.filter(BoolConfig.child_id == child_id).all() if u.key.type == bool},
-            **{f'{u.key}' if json else u.key: u.value for u in StrConfig.query.filter(StrConfig.child_id == child_id).all() if u.key.type != bool},
+            **{f'{u.key}' if json else u.key: int(u.value) if u.key.type == int and u.value != None else u.value for u in StrConfig.query.filter(StrConfig.child_id == child_id).all() if u.key.type != bool},
             # ConfigEnum.telegram_fakedomain:hdomain(DomainType.telegram_faketls),
             # ConfigEnum.ssfaketls_fakedomain:hdomain(DomainType.ss_faketls),
             # ConfigEnum.fake_cdn_domain:hdomain(DomainType.fake_cdn)

hiddifypanel/models/config_enum.py

@@ -55,6 +55,10 @@ def _StrConfigDscr(category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.n
     return category, apply_mode, str, show_in_parent
 
 
+def _IntConfigDscr(category: ConfigCategory, apply_mode: ApplyMode = ApplyMode.nothing, show_in_parent: bool = True, hide_in_virtual_child=False):
+    return category, apply_mode, int, show_in_parent
+
+
 class ConfigEnum(metaclass=FastEnum):
     # category: ConfigCategory
     __slots__ = ('category', 'apply_mode', 'type', 'show_in_parent', 'hide_in_virtual_child')
@@ -128,13 +132,13 @@ class ConfigEnum(metaclass=FastEnum):
     # mux
     mux_enable = _BoolConfigDscr(ConfigCategory.mux, ApplyMode.apply)
     mux_protocol = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_max_connections = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_min_streams = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_max_streams = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_max_connections = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_min_streams = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_max_streams = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
     mux_padding_enable = _BoolConfigDscr(ConfigCategory.mux, ApplyMode.apply)
     mux_brutal_enable = _BoolConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_brutal_up_mbps = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
-    mux_brutal_down_mbps = _StrConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_brutal_up_mbps = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
+    mux_brutal_down_mbps = _IntConfigDscr(ConfigCategory.mux, ApplyMode.apply)
 
     http_ports = _StrConfigDscr(ConfigCategory.http, ApplyMode.apply)
     kcp_ports = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply)

hiddifypanel/panel/admin/DomainAdmin.py

@@ -234,8 +234,9 @@ class DomainAdmin(AdminLTEModelView):
                     if not hutils.network.is_in_same_asn(d, ipv4_list[0]):
                         server_asn = hutils.network.get_ip_asn_name(ipv4_list[0])
                         domain_asn = hutils.network.get_ip_asn_name(dip)  # type: ignore
-                    msg = _("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={server_asn}<br>{d}_ASN={domain_asn}" if server_asn or domain_asn else "")
-                    hutils.flask.flash(msg, 'warning')
+                        msg = _("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={server_asn}<br>{d}_ASN={domain_asn}" if server_asn or domain_asn else "")
+                        hutils.flask.flash(msg, 'warning')
 
             for d in model.servernames.split(","):
                 if not hutils.network.fallback_domain_compatible_with_servernames(model.domain, d):

hiddifypanel/panel/admin/templates/model/user_list.html

@@ -7,26 +7,37 @@
         <summary>
             {{_("Send Message to User's Telegram")}}
         </summary>
-        <button onclick="show_send_message('all')" type="button" class="btn hbtn bg-h-blue">{{_("All Users")}}</button>
-        <button onclick="show_send_message('expired')" type="button" class="btn hbtn bg-h-red">
-            {{_("Expired Users")}}</button>
-        <button onclick="show_send_message('active')" type="button" class="btn hbtn bg-h-green">
-            {{_("Active Users")}}</button>
-        <br>
-        <button onclick="show_send_message('offline 1h')" type="button" class="btn  hbtn bg-h-orange">
-            {{_("Offline more than 1 hour")}}</button>
-        <button onclick="show_send_message('offline 1d')" type="button" class="btn  hbtn bg-h-red">
-            {{_("Offline more than 1 day")}}</button>
-        <button onclick="show_send_message('offline 1w')" type="button" class="btn hbtn bg-h-grey">
-            {{_("Offline more than 1 week")}}</button>
+        <div style="margin-top: 10px;">
+            <button onclick="show_send_message('all')" type="button" class="btn hbtn bg-h-green">
+                {{_("All Users")}}
+            </button>
+            <button onclick="show_send_message('active')" type="button" class="btn hbtn bg-h-green" style="margin-left: 5px;margin-right: 5px;">
+                {{_("Active Users")}}
+            </button>
+            <button onclick="show_send_message('selected')" type="button" class="btn hbtn bg-h-green">
+                {{_("Seleted Users")}}
+            </button>
+        </div>
+
+        <div style="margin-top: 10px;">
+            <button onclick="show_send_message('offline 1h')" type="button" class="btn  hbtn bg-h-red">
+                {{_("Offline more than 1 hour")}}</button>
+            <button onclick="show_send_message('offline 1d')" type="button" class="btn  hbtn bg-h-red" style="margin-left: 5px;">
+                {{_("Offline more than 1 day")}}</button>
+            <button onclick="show_send_message('offline 1w')" type="button" class="btn hbtn bg-h-red" style="margin-left: 5px;margin-right: 5px;">
+                {{_("Offline more than 1 week")}}
+            </button>
+            <button onclick="show_send_message('expired')" type="button" class="btn hbtn bg-h-red">
+                {{_("Expired Users")}}
+            </button>
+        </div>
     </details>
 </div>
 {% endif %}
 {{super()}}
 
 <div class="callout callout-success">
-    {{_('User usage will be updated every 6 minutes. To update it now click <a href="%(link)s"
-        class="btn btn-info">here</a>',link=hurl_for("admin.Actions:update_usage"))}}
+    {{_('User usage will be updated every 6 minutes. To update it now click <a href="%(link)s" class="btn btn-info">here</a>',link=hurl_for("admin.Actions:update_usage"))}}
 
 </div>
 <style>
@@ -69,23 +80,36 @@
 {% block tail_js%}
 {{super()}}
 <script>
+    function get_selected_users_id() {
+        let ids = [];
+        $('input[type="checkbox"][name="rowid"]:checked[value][class="action-checkbox"]').each(function () {
+            ids.push($(this).val());
+        });
+        return ids
+    }
     function show_send_message(id) {
+        if (id == 'selected') {
+            id = get_selected_users_id();
+            if (id.length == 0) {
+                alert(`{{_("Please select at least one user")}}`);
+                return
+            }
+        }
         bootbox.prompt({
             title: '{{_("Please type your message to send to the telegram:")}}',
             inputType: 'textarea',
             locale: '{{get_locale()}}',
-            callback: function (result) {
-                console.log(result);
-                if (!result) return
+            callback: function (msg) {
+                console.log(msg);
+                if (!msg) return
                 // let dialog = bootbox.dialog({           
                 //     message: '<p><i class="fas fa-spin fa-spinner"></i> {{_("Sending")}}</p>'
                 // });
-
                 $.ajax({
                     type: "POST",
                     url: '{{hurl_for("api_v1.sendmsgresource")}}',
 
-                    data: JSON.stringify({ 'text': result, 'id': id }),
+                    data: JSON.stringify({ 'text': msg, 'id': id }),
                     contentType: "application/json",
                     dataType: "json",
                     error: function (jqx, status, error) {
@@ -131,4 +155,4 @@
     }
 
 </script>
-{% endblock %}
+{% endblock %}

hiddifypanel/panel/commercial/restapi/v1/tgmsg.py

@@ -39,30 +39,34 @@ class SendMsgResource(Resource):
         else:
             return {'msg': 'error', 'res': res}
 
-    def get_users_by_identifier(self, identifier: str) -> List[User]:
+    def get_users_by_identifier(self, identifier: str | list) -> List[User]:
         '''Returns all users that match the identifier for sending a message to them'''
         # when we are here we must have g.account but ...
         if not hasattr(g, 'account'):
             return []
+        
         query = User.query.filter(User.added_by.in_(g.account.recursive_sub_admins_ids()))
         query = query.filter(User.telegram_id is not None, User.telegram_id != 0)
 
-        if hutils.convert.is_int(identifier):
+        # user selected many ids as users identifier
+        if isinstance(identifier, list):
+            return query.filter(User.id.in_(identifier)).all()
+
+        if hutils.convert.is_int(identifier):  # type: ignore
             return [query.filter(User.id == int(identifier)).first() or abort(404, 'The user not found')]  # type: ignore
-        elif identifier == 'all':
+        if identifier == 'all':
             return query.all()
-        elif identifier == 'expired':
+        if identifier == 'expired':
             return [u for u in query.all() if not u.is_active]
-        elif identifier == 'active':
+        if identifier == 'active':
             return [u for u in query.all() if u.is_active]
-        elif identifier == 'offline 1h':
+        if identifier == 'offline 1h':
             h1 = datetime.datetime.now() - datetime.timedelta(hours=1)
             return [u for u in query.all() if u.is_active and u.last_online < h1]
-        elif identifier == 'offline 1d':
+        if identifier == 'offline 1d':
             d1 = datetime.datetime.now() - datetime.timedelta(hours=24)
             return [u for u in query.all() if u.is_active and u.last_online < d1]
-        elif identifier == 'offline 1w':
+        if identifier == 'offline 1w':
             d7 = datetime.datetime.now() - datetime.timedelta(days=7)
             return [u for u in query.all() if u.is_active and u.last_online < d7]
-        else:
-            return []
+        return []