xt-manager 0.2.0__py3-none-any.whl

XTManager/__init__.py

@@ -0,0 +1,39 @@
+"""MT5-style import for the XT Manager client.
+
+    import XTManager
+    manager = XTManager.ManagerAPI()
+    manager.Connect("127.0.0.1:8443", login, password, 0, 30000)
+"""
+
+from xt_manager.manager import ManagerAPI
+from xt_manager.online import Online
+from xt_manager.records import Account, Deal, Group, Position, Symbol, TradeOrder
+from xt_manager.user import User
+
+
+class EnPumpModes:
+    PUMP_MODE_NONE = 0
+    PUMP_MODE_USERS = 1
+    PUMP_MODE_ACTIVITY = 2
+    PUMP_MODE_MAIL = 4
+    PUMP_MODE_NEWS = 8
+    PUMP_MODE_ORDERS = 16
+    PUMP_MODE_GROUPS = 32
+    PUMP_MODE_SYMBOLS = 64
+    PUMP_MODE_FULL = 65535
+
+
+ManagerAPI.EnPumpModes = EnPumpModes
+
+__all__ = [
+    "Account",
+    "Deal",
+    "EnPumpModes",
+    "Group",
+    "ManagerAPI",
+    "Online",
+    "Position",
+    "Symbol",
+    "TradeOrder",
+    "User",
+]

xt_manager/__init__.py

@@ -0,0 +1,20 @@
+"""Python library for connecting to XT with a Manager-style session."""
+
+from xt_manager.cli import main
+from xt_manager.manager import ManagerAPI
+from xt_manager.online import Online
+from xt_manager.records import Account, Deal, Group, Position, Symbol, TradeOrder
+from xt_manager.user import User
+
+__all__ = [
+    "Account",
+    "Deal",
+    "Group",
+    "ManagerAPI",
+    "Online",
+    "Position",
+    "Symbol",
+    "TradeOrder",
+    "User",
+    "main",
+]

xt_manager/api.py

@@ -0,0 +1,464 @@
+"""XT Manager HTTP API. Routes belong to this app only."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from uuid import uuid4
+
+from fastapi import FastAPI, Header, HTTPException, Request
+from pydantic import BaseModel, Field, ValidationError
+
+from xt_manager.broker_sync import apply_balance, post_balance, store_trading_account
+from xt_manager.online import Online
+from xt_manager.store import MemoryStore
+from xt_manager.trading_api import register_trading
+from xt_manager.user import User
+
+_SESSION_HEADER = "X-XT-Manager-Session"
+
+
+class ManagerBody(BaseModel):
+    login: str = Field(examples=["2504"])
+    role: str = Field(examples=["manager"])
+    name: str = Field(default="", examples=["Demo Manager"])
+
+
+class ManagerResult(BaseModel):
+    ok: bool = True
+    login: str
+    role: str
+    name: str
+
+
+class AccountBody(BaseModel):
+    manager_login: str = Field(examples=["2504"])
+    password: str = Field(examples=["TradePass1!"])
+    group: str = Field(default="demo", examples=["demo"])
+    name: str = Field(default="", examples=["Amit Shah"])
+    balance: str = Field(default="0.00", examples=["10500.50"])
+    leverage: str = Field(default="100", examples=["100"])
+
+
+class AccountResult(BaseModel):
+    ok: bool = True
+    login: str
+    manager_login: str
+
+
+class ConnectBody(BaseModel):
+    login: str = Field(examples=["2504"])
+    password: str = Field(examples=["TradePass1!"])
+
+
+class ConnectResult(BaseModel):
+    ok: bool = True
+    session_id: str
+
+
+class UserResult(BaseModel):
+    ok: bool = True
+    user: User
+
+
+class OnlineResult(BaseModel):
+    ok: bool = True
+    total: int
+    connections: list[Online]
+
+
+class UsersResult(BaseModel):
+    ok: bool = True
+    total: int
+    users: list[User]
+
+
+class LoginsResult(BaseModel):
+    ok: bool = True
+    logins: list[str]
+
+
+class LoginsBody(BaseModel):
+    logins: list[str] = Field(examples=[["2504"]])
+
+
+class PasswordBody(BaseModel):
+    type: int = Field(default=0, examples=[0])
+    password: str = Field(examples=["TradePass1!"])
+
+
+class UserCreateBody(BaseModel):
+    password: str = Field(examples=["TradePass1!"])
+    group: str = Field(default="demo", examples=["demo\\testing\\BB\\SWAP\\ALPHA"])
+    name: str = Field(default="", examples=["Amit Shah"])
+    first_name: str = Field(default="", examples=["Amit"])
+    last_name: str = Field(default="", examples=["Shah"])
+    leverage: str = Field(default="100", examples=["100"])
+    balance: str = Field(default="0.00", examples=["10000.00"])
+    email: str = Field(default="", examples=["amit.shah@example.com"])
+    country: str = Field(default="", examples=["India"])
+
+
+class BalanceBody(BaseModel):
+    amount: str = Field(examples=["10000.00"])
+    comment: str = Field(default="", examples=["Initial Deposit"])
+    type: int = Field(default=2, examples=[2])
+    raw: bool = False
+
+
+class BalanceResult(BaseModel):
+    ok: bool = True
+    user: User
+    deal: str
+
+
+class StatusResult(BaseModel):
+    ok: bool = True
+    status: str
+
+
+def _restore_balance(store: MemoryStore, manager_login: str, login: str, body: BalanceBody) -> BalanceResult | str:
+    """Apply a deposit for a login that lives in the terminal database only."""
+    deal = f"restore-{login}-{uuid4().hex}"
+    status, account, error = post_balance(login, body.amount, body.comment, body.type or 2, deal)
+    if status == 0 and error is None:
+        return "missing"
+    if status == 404:
+        return "missing"
+    if error or account is None:
+        return error or "terminal balance store rejected the change"
+    user = User(
+        Login=str(login).strip(),
+        Group=str(account.get("comment") or "demo"),
+        Name=str(login).strip(),
+        Balance=str(account.get("balance") or "0.00"),
+        Leverage=str(account.get("leverage") or "100"),
+        Credit=str(account.get("credit") or "0.00"),
+        ManagerLogin=manager_login,
+    )
+    store.remember_client(manager_login, user)
+    return BalanceResult(user=user, deal=deal)
+
+
+def create_app(store: MemoryStore) -> FastAPI:
+    app = FastAPI(title="XT Manager API", version="0.1.0")
+    app.state.store = store
+
+    @app.post("/xt-manager/v1/managers", response_model=ManagerResult)
+    def create_manager(body: ManagerBody) -> ManagerResult:
+        created = store.add_manager(body.login, body.role.strip().lower(), body.name)
+        if created is None:
+            raise HTTPException(
+                status_code=409,
+                detail={"ok": False, "code": "manager.not_created", "message": "Manager id was not assigned"},
+            )
+        return ManagerResult(login=created.login, role=created.role, name=created.name)
+
+    @app.post("/xt-manager/v1/accounts", response_model=AccountResult)
+    def create_account(body: AccountBody) -> AccountResult:
+        if store.get_manager(body.manager_login) is None:
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "manager.not_found", "message": "Assign a manager id before creating an account"},
+            )
+        manager_login = body.manager_login.strip()
+        created = store.add_account(
+            manager_login,
+            body.password,
+            User(
+                Login=manager_login,
+                Group=body.group.strip() or "demo",
+                Name=body.name.strip() or manager_login,
+                Balance=body.balance.strip() or "0.00",
+                Leverage=body.leverage.strip() or "100",
+                ManagerLogin=manager_login,
+            ),
+        )
+        if created is None:
+            raise HTTPException(
+                status_code=409,
+                detail={"ok": False, "code": "account.not_created", "message": "Trading account was not created"},
+            )
+        return AccountResult(login=created.login, manager_login=created.manager_login)
+
+    @app.post("/xt-manager/v1/users", response_model=UserResult)
+    def user_add(
+        body: UserCreateBody,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> UserResult:
+        manager_login = _require_session(session)
+        name = body.name.strip() or " ".join(part for part in (body.first_name.strip(), body.last_name.strip()) if part)
+        created, error = store.add_client_user(
+            manager_login,
+            body.password,
+            User(
+                Login="",
+                Group=body.group.strip() or "demo",
+                Name=name or manager_login,
+                FirstName=body.first_name.strip(),
+                LastName=body.last_name.strip(),
+                Balance=body.balance.strip() or "0.00",
+                Leverage=body.leverage.strip() or "100",
+                Email=body.email.strip(),
+                Country=body.country.strip(),
+                ManagerLogin=manager_login,
+            ),
+        )
+        if error == "password.invalid":
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "ok": False,
+                    "code": error,
+                    "message": "Password must be 8 to 16 characters and include lower, upper, digit, and special characters",
+                },
+            )
+        if created is None:
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "manager.not_found", "message": "Assign a manager id before creating an account"},
+            )
+        stored = store_trading_account(
+            created.login,
+            body.password,
+            created.user.Group,
+            created.user.Name,
+            created.user.Leverage,
+            created.user.Balance,
+            created.user.Email,
+        )
+        if stored is not None:
+            store.delete_user(created.login)
+            raise HTTPException(
+                status_code=502,
+                detail={"ok": False, "code": "terminal.store_failed", "message": stored},
+            )
+        print(f"user created login={created.login} manager={created.manager_login}", flush=True)
+        return UserResult(user=created.user)
+
+    @app.post("/xt-manager/v1/users/{login}/balance", response_model=BalanceResult)
+    def user_balance(
+        login: str,
+        body: BalanceBody,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> BalanceResult:
+        manager_login = _require_session(session)
+        try:
+            updated = store.adjust_balance(login, body.amount, body.comment, body.type, body.raw)
+        except Exception:
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": "invalid_argument", "message": "Balance amount is not valid"},
+            ) from None
+        if updated == "balance.unsupported":
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": updated, "message": "Balance type must be 2 for balance or 3 for credit"},
+            )
+        if updated == "balance.insufficient":
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": updated, "message": "Balance cannot go below zero"},
+            )
+        if updated is None:
+            restored = _restore_balance(store, manager_login, login, body)
+            if isinstance(restored, BalanceResult):
+                return restored
+            if restored == "missing":
+                raise HTTPException(
+                    status_code=404,
+                    detail={"ok": False, "code": "user.not_found", "message": f"User {login} was not found"},
+                )
+            raise HTTPException(
+                status_code=502,
+                detail={"ok": False, "code": "terminal.store_failed", "message": str(restored)},
+            )
+        if isinstance(updated, str):
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "user.not_found", "message": f"User {login} was not found"},
+            )
+        user, ticket = updated
+        stored = apply_balance(login, body.amount, body.comment, body.type, ticket)
+        if stored is not None:
+            try:
+                store.adjust_balance(login, str(-Decimal(body.amount)), body.comment, body.type, body.raw)
+            except Exception:
+                pass
+            raise HTTPException(
+                status_code=502,
+                detail={"ok": False, "code": "terminal.store_failed", "message": stored},
+            )
+        return BalanceResult(user=user, deal=ticket)
+
+    @app.post("/xt-manager/v1/connect", response_model=ConnectResult)
+    def connect(body: ConnectBody, request: Request) -> ConnectResult:
+        address = request.client.host if request.client is not None else ""
+        session_id = store.open_session(body.login, body.password, address)
+        if session_id is None:
+            raise HTTPException(
+                status_code=401,
+                detail={"ok": False, "code": "auth.invalid_credentials", "message": "Invalid credentials"},
+            )
+        print(f"online login={body.login.strip()} address={address}", flush=True)
+        return ConnectResult(session_id=session_id)
+
+    def _require_session(session: str | None) -> str:
+        login = store.session_login(session or "")
+        if login is None:
+            raise HTTPException(
+                status_code=401,
+                detail={"ok": False, "code": "auth.session_required", "message": "Manager session is required"},
+            )
+        return login
+
+    @app.get("/xt-manager/v1/users/total", response_model=UsersResult)
+    def user_total(session: str | None = Header(default=None, alias=_SESSION_HEADER)) -> UsersResult:
+        _require_session(session)
+        return UsersResult(total=store.user_total(), users=[])
+
+    @app.get("/xt-manager/v1/users/by-group", response_model=UsersResult)
+    def users_by_group(
+        group: str,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> UsersResult:
+        _require_session(session)
+        users = store.users_by_group(group)
+        return UsersResult(total=len(users), users=users)
+
+    @app.post("/xt-manager/v1/users/by-logins", response_model=UsersResult)
+    def users_by_logins(
+        body: LoginsBody,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> UsersResult:
+        _require_session(session)
+        if not body.logins:
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": "invalid_argument", "message": "At least one login is required"},
+            )
+        users = store.users_by_logins(body.logins)
+        return UsersResult(total=len(users), users=users)
+
+    @app.get("/xt-manager/v1/groups/{group}/logins", response_model=LoginsResult)
+    def user_logins(group: str, session: str | None = Header(default=None, alias=_SESSION_HEADER)) -> LoginsResult:
+        _require_session(session)
+        return LoginsResult(logins=store.user_logins(group))
+
+    @app.get("/xt-manager/v1/users/{login}", response_model=UserResult)
+    def user_request(
+        login: str,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> UserResult:
+        if store.session_login(session or "") is None:
+            raise HTTPException(
+                status_code=401,
+                detail={"ok": False, "code": "auth.session_required", "message": "Manager session is required"},
+            )
+        user = store.get_user(login)
+        if user is None:
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "user.not_found", "message": f"User {login} was not found"},
+            )
+        return UserResult(user=user)
+
+    @app.put("/xt-manager/v1/users/{login}", response_model=UserResult)
+    def user_update(
+        login: str,
+        body: dict[str, object],
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> UserResult:
+        _require_session(session)
+        sent_login = body.get("Login")
+        if sent_login is not None and str(sent_login) != login:
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": "invalid_argument", "message": "User login must match the path"},
+            )
+        try:
+            updated = store.update_user(login, body)
+        except ValidationError:
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": "invalid_argument", "message": "User fields are not valid"},
+            ) from None
+        if updated is None:
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "user.not_found", "message": f"User {login} was not found"},
+            )
+        return UserResult(user=updated)
+
+    @app.post("/xt-manager/v1/users/{login}/password/check", response_model=StatusResult)
+    def user_password_check(
+        login: str,
+        body: PasswordBody,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> StatusResult:
+        _require_session(session)
+        if body.type != 0:
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": "password.unsupported", "message": "Only the main password can be checked"},
+            )
+        matched = store.password_matches_login(login, body.password, body.type)
+        if matched is None:
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "user.not_found", "message": f"User {login} was not found"},
+            )
+        if not matched:
+            raise HTTPException(
+                status_code=401,
+                detail={"ok": False, "code": "auth.invalid_credentials", "message": "Invalid credentials"},
+            )
+        return StatusResult(status="ok")
+
+    @app.post("/xt-manager/v1/users/{login}/password", response_model=StatusResult)
+    def user_password_change(
+        login: str,
+        body: PasswordBody,
+        session: str | None = Header(default=None, alias=_SESSION_HEADER),
+    ) -> StatusResult:
+        _require_session(session)
+        error = store.change_password(login, body.password, body.type)
+        if error == "password.unsupported":
+            raise HTTPException(
+                status_code=400,
+                detail={"ok": False, "code": error, "message": "Only the main password can be changed"},
+            )
+        if error == "password.invalid":
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "ok": False,
+                    "code": error,
+                    "message": "Password must be 8 to 16 characters and include lower, upper, digit, and special characters",
+                },
+            )
+        if error is not None:
+            raise HTTPException(
+                status_code=404,
+                detail={"ok": False, "code": "user.not_found", "message": f"User {login} was not found"},
+            )
+        return StatusResult(status="ok")
+
+    @app.get("/xt-manager/v1/online", response_model=OnlineResult)
+    def online(session: str | None = Header(default=None, alias=_SESSION_HEADER)) -> OnlineResult:
+        if store.session_login(session or "") is None:
+            raise HTTPException(
+                status_code=401,
+                detail={"ok": False, "code": "auth.session_required", "message": "Manager session is required"},
+            )
+        connections = store.online()
+        return OnlineResult(total=len(connections), connections=connections)
+
+    @app.post("/xt-manager/v1/disconnect", response_model=StatusResult)
+    def disconnect(session: str | None = Header(default=None, alias=_SESSION_HEADER)) -> StatusResult:
+        closed = store.close_session(session) if session else None
+        if closed is not None:
+            print(f"offline login={closed.login} address={closed.address}", flush=True)
+        return StatusResult(status="disconnected")
+
+    register_trading(app, store, _require_session)
+    return app

xt_manager/broker_sync.py

@@ -0,0 +1,106 @@
+"""Store a manager-created login in the broker database the terminal reads."""
+
+from __future__ import annotations
+
+import os
+
+import httpx
+
+_URL = "XT_BROKER_API_URL"
+_TOKEN = "XT_BROKER_SYNC_TOKEN"
+
+
+def store_trading_account(
+    login: str,
+    password: str,
+    group: str,
+    name: str,
+    leverage: str,
+    balance: str,
+    email: str = "",
+) -> str | None:
+    """Return an error message when the terminal database rejects the account.
+
+    When the broker URL or sync token is unset, the account stays in this process only.
+    """
+    origin = os.environ.get(_URL, "").strip().rstrip("/")
+    token = os.environ.get(_TOKEN, "").strip()
+    if not origin or not token:
+        return None
+    try:
+        response = httpx.post(
+            f"{origin}/api/v1/internal/manager/trading-accounts",
+            headers={"X-XT-Manager-Sync": token},
+            json={
+                "login": login,
+                "group": group,
+                "name": name,
+                "email": email,
+                "leverage": leverage,
+                "master_password": password,
+                "balance": balance,
+            },
+            timeout=30,
+        )
+    except httpx.HTTPError as exc:
+        return f"terminal account store failed: {exc}"
+    if response.status_code in {200, 201}:
+        return None
+    message = "terminal account store rejected the login"
+    try:
+        body = response.json()
+    except ValueError:
+        return message
+    if isinstance(body, dict):
+        detail = body.get("message") or body.get("user_message")
+        if isinstance(body.get("detail"), dict):
+            detail = body["detail"].get("message") or detail
+        if detail:
+            message = str(detail)
+    return message
+
+
+def apply_balance(login: str, amount: str, comment: str, kind: int, deal: str) -> str | None:
+    """Return an error message when the terminal database rejects the balance change."""
+    _status, _account, error = post_balance(login, amount, comment, kind, deal)
+    return error
+
+
+def post_balance(
+    login: str, amount: str, comment: str, kind: int, deal: str
+) -> tuple[int, dict | None, str | None]:
+    """Post a balance change and return ``(status, account, error)``.
+
+    Status ``0`` means the broker URL or token is unset.
+    """
+    origin = os.environ.get(_URL, "").strip().rstrip("/")
+    token = os.environ.get(_TOKEN, "").strip()
+    if not origin or not token:
+        return 0, None, None
+    try:
+        response = httpx.post(
+            f"{origin}/api/v1/internal/manager/trading-accounts/{login}/balance",
+            headers={"X-XT-Manager-Sync": token},
+            json={"amount": amount, "comment": comment, "type": kind, "deal": deal},
+            timeout=30,
+        )
+    except httpx.HTTPError as exc:
+        return 0, None, f"terminal balance store failed: {exc}"
+    try:
+        body = response.json()
+    except ValueError:
+        body = {}
+    if response.status_code in {200, 201}:
+        account = body.get("data") if isinstance(body, dict) else None
+        return response.status_code, account if isinstance(account, dict) else {}, None
+    message = "terminal balance store rejected the change"
+    if isinstance(body, dict):
+        detail = body.get("message") or body.get("user_message")
+        nested = body.get("detail")
+        if isinstance(nested, dict):
+            detail = nested.get("message") or detail
+        if isinstance(detail, dict):
+            detail = detail.get("message") or detail.get("user_message")
+        if detail:
+            message = str(detail)
+    return response.status_code, None, message