ForcePilot/backend/package/yuxi/channel/extensions/signal/account_management.py

import logging
from typing import Any

from yuxi.channel.extensions.signal.client import SignalRpcClient

logger = logging.getLogger(__name__)


async def register_account(
    client: SignalRpcClient,
    account: str,
    voice_verification: bool = False,
    captcha: str | None = None,
) -> None:
    params: dict[str, Any] = {"account": account}
    if voice_verification:
        params["voice"] = True
    if captcha:
        params["captcha"] = captcha
    await client.call("register", params, account=account)


async def verify_account(
    client: SignalRpcClient,
    account: str,
    verification_code: str,
    pin: str | None = None,
) -> None:
    params: dict[str, Any] = {"account": account, "verificationCode": verification_code}
    if pin:
        params["pin"] = pin
    await client.call("verify", params, account=account)


async def list_devices(client: SignalRpcClient, *, account: str | None = None) -> list[dict]:
    result = await client.call("listDevices", account=account)
    if isinstance(result, list):
        return result
    if isinstance(result, dict):
        return result.get("devices", [])
    return []


async def add_device(
    client: SignalRpcClient,
    uri: str,
    *,
    account: str | None = None,
) -> None:
    params: dict[str, Any] = {"uri": uri}
    if account:
        params["account"] = account
    await client.call("addDevice", params, account=account)


async def remove_device(
    client: SignalRpcClient,
    device_id: int,
    *,
    account: str | None = None,
) -> None:
    params: dict[str, Any] = {"deviceId": device_id}
    if account:
        params["account"] = account
    await client.call("removeDevice", params, account=account)


async def list_identities(
    client: SignalRpcClient,
    identifier: str | None = None,
    *,
    account: str | None = None,
) -> list[dict]:
    params: dict[str, Any] = {}
    if identifier:
        params["number"] = identifier
    if account:
        params["account"] = account
    result = await client.call("listIdentities", params, account=account)
    if isinstance(result, list):
        return result
    if isinstance(result, dict):
        return result.get("identities", [])
    return []


async def trust_identity(
    client: SignalRpcClient,
    identifier: str,
    verified_safety_number: str,
    *,
    account: str | None = None,
    trust_all: bool = False,
) -> None:
    params: dict[str, Any] = {
        "account": identifier,
        "verifiedSafetyNumber": verified_safety_number,
    }
    if trust_all:
        params["trustAll"] = True
    if account:
        params["account"] = account
    await client.call("trust", params, account=account)


async def set_account_attributes(
    client: SignalRpcClient,
    *,
    pin: str | None = None,
    registration_lock_pin: str | None = None,
    unregister_account: bool = False,
    discoverable_by_number: bool | None = None,
    number_sharing: bool | None = None,
    account: str | None = None,
) -> None:
    params: dict[str, Any] = {}
    if pin is not None:
        params["pin"] = pin
    if registration_lock_pin is not None:
        params["registrationLockPin"] = registration_lock_pin
    if unregister_account:
        params["unregister"] = True
    if discoverable_by_number is not None:
        params["discoverableByNumber"] = discoverable_by_number
    if number_sharing is not None:
        params["numberSharing"] = number_sharing
    if account:
        params["account"] = account
    await client.call("setAccountAttributes", params, account=account)


async def submit_rate_limit_challenge(
    client: SignalRpcClient,
    challenge: str,
    captcha: str,
    *,
    account: str | None = None,
) -> None:
    params: dict[str, Any] = {"challenge": challenge, "captcha": captcha}
    if account:
        params["account"] = account
    await client.call("submitRateLimitChallenge", params, account=account)