From 6981119a4d4d0c420574a76edd9608179002a792 Mon Sep 17 00:00:00 2001
From: dmitei
Date: Tue, 10 Nov 2026 23:18:00 +0300
Subject: [PATCH 1/3] add login and registration
Co-Authored-By: Claude Opus 5.5
---
.env.example | 2 +
README.md | 19 ++-
.../versions/1395cb8114bd_add_users.py | 38 +++++
backend/app/api/auth.py | 53 +++++++
backend/app/core/config.py | 3 +
backend/app/core/security.py | 40 ++++++
backend/app/models/__init__.py | 4 +-
backend/app/models/users.py | 12 ++
backend/app/schemas/auth.py | 35 +++++
backend/app/services/auth_service.py | 31 +++++
backend/main.py | 15 +-
backend/pytest.ini | 3 +
backend/requirements.txt | 4 +-
backend/tests/conftest.py | 90 ++++++++++++
backend/tests/test_auth.py | 131 ++++++++++++++++++
frontend/src/App.tsx | 48 +++++--
frontend/src/api.ts | 48 +++++--
frontend/src/index.css | 50 +++++++
frontend/src/pages/Auth.tsx | 97 +++++++++++++
frontend/src/session.ts | 56 ++++++++
20 files changed, 752 insertions(+), 27 deletions(-)
create mode 100644 backend/alembic/versions/1395cb8114bd_add_users.py
create mode 100644 backend/app/api/auth.py
create mode 100644 backend/app/core/security.py
create mode 100644 backend/app/models/users.py
create mode 100644 backend/app/schemas/auth.py
create mode 100644 backend/app/services/auth_service.py
create mode 100644 backend/pytest.ini
create mode 100644 backend/tests/conftest.py
create mode 100644 backend/tests/test_auth.py
create mode 100644 frontend/src/pages/Auth.tsx
create mode 100644 frontend/src/session.ts
diff --git a/.env.example b/.env.example
index b78e297..6dc6983 100644
--- a/.env.example
+++ b/.env.example
@@ -12,3 +12,5 @@ RUL_CRITICAL=30
RUL_CLIP=125
BOT_TOKEN=
CHAT_ID=
+JWT_SECRET=
+JWT_EXPIRE_MINUTES=1440
diff --git a/README.md b/README.md
index de2d9f4..b5b7d24 100644
--- a/README.md
+++ b/README.md
@@ -116,6 +116,16 @@ api/v1 (эндпоинты, валидация) → services (бизнес-ло
Все эндпоинты — с префиксом `/api/v1`. Документация OpenAPI: `/docs`.
+### Авторизация
+
+Все эндпоинты, кроме `/auth/register`, `/auth/login` и `/health`, требуют заголовок `Authorization: Bearer <токен>`, без него отвечают `401`. Токен — JWT, его выдают регистрация и вход; живёт `JWT_EXPIRE_MINUTES` минут (по умолчанию сутки). Подписывается ключом `JWT_SECRET` из `.env`: сгенерировать — `python -c "import secrets; print(secrets.token_urlsafe(32))"`. Если ключ не задан, backend создаёт временный, и после его перезапуска войти придётся заново. Пароли хранятся только как bcrypt-хэш.
+
+| Метод | Эндпоинт | Описание | Ожидаемый latency |
+| ----- | ---------------- | ------------------------------------------------------------- | ----------------- |
+| POST | `/auth/register` | Регистрация по email и паролю (от 8 символов), сразу выдаёт токен; `409`, если email занят | < 500 мс |
+| POST | `/auth/login` | Вход: токен; `401` при неверном email или пароле | < 500 мс |
+| GET | `/auth/me` | Текущий пользователь | < 100 мс |
+
### Оборудование
| Метод | Эндпоинт | Описание | Ожидаемый latency |
@@ -225,9 +235,16 @@ erDiagram
varchar severity "info warning critical"
text message
}
+
+ users {
+ int id PK
+ text email "уникальный, в нижнем регистре"
+ text password_hash "bcrypt"
+ timestamp created_at
+ }
```
-Ограничения и индексы: `UNIQUE (dataset, unit_number)` в `equipment`; `UNIQUE (equipment_id, cycle)` в `sensor_readings`, `physics_predictions`, `ml_predictions`; индекс `alerts (equipment_id, triggered_at DESC)`. Показания хранятся широкой таблицей: набор из 14 датчиков фиксирован, так запросы истории не требуют `PIVOT`. Для других наборов (FD002–FD004) добавляются колонки миграцией; полный список датчиков и признак `is_used` лежат в `sensor_catalog`.
+Ограничения и индексы: `UNIQUE (dataset, unit_number)` в `equipment`; `UNIQUE (equipment_id, cycle)` в `sensor_readings`, `physics_predictions`, `ml_predictions`; индекс `alerts (equipment_id, triggered_at DESC)`; `UNIQUE (email)` в `users`. Показания хранятся широкой таблицей: набор из 14 датчиков фиксирован, так запросы истории не требуют `PIVOT`. Для других наборов (FD002–FD004) добавляются колонки миграцией; полный список датчиков и признак `is_used` лежат в `sensor_catalog`.
При записи (40 записей/сек) все вставки идут в разные таблицы от фоновых процессов. 40 INSERT/сек — незначительная нагрузка для PostgreSQL.
При чтении (~10-20 RPS) PostgreSQL будет находить строки за O(log n). Проблем не возникнет.
diff --git a/backend/alembic/versions/1395cb8114bd_add_users.py b/backend/alembic/versions/1395cb8114bd_add_users.py
new file mode 100644
index 0000000..ba08f3c
--- /dev/null
+++ b/backend/alembic/versions/1395cb8114bd_add_users.py
@@ -0,0 +1,38 @@
+"""add users
+
+Revision ID: 1395cb8114bd
+Revises: e74d5734bc65
+Create Date: 2026-11-10 23:10:55.971571
+
+"""
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = '1395cb8114bd'
+down_revision: str | Sequence[str] | None = 'e74d5734bc65'
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+ """Upgrade schema."""
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.create_table('users',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('email', sa.Text(), nullable=False),
+ sa.Column('password_hash', sa.Text(), nullable=False),
+ sa.Column('created_at', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('email')
+ )
+ # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+ """Downgrade schema."""
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_table('users')
+ # ### end Alembic commands ###
diff --git a/backend/app/api/auth.py b/backend/app/api/auth.py
new file mode 100644
index 0000000..f1b411c
--- /dev/null
+++ b/backend/app/api/auth.py
@@ -0,0 +1,53 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from app.core.db import DB
+from app.core.security import create_token, user_id_from_token
+from app.schemas.auth import AuthOut, LoginIn, RegisterIn, UserOut
+from app.services import auth_service
+
+router = APIRouter(prefix="/auth", tags=["Авторизация"])
+
+bearer = HTTPBearer(auto_error=False, description="Токен из /auth/login или /auth/register")
+
+UNAUTHORIZED = {401: {"description": "Нет токена, токен неверен или просрочен"}}
+
+
+def _unauthorized(detail: str) -> HTTPException:
+ return HTTPException(status.HTTP_401_UNAUTHORIZED, detail, headers={"WWW-Authenticate": "Bearer"})
+
+
+def get_current_user(db: DB, credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(bearer)]) -> dict:
+ user_id = user_id_from_token(credentials.credentials) if credentials else None
+ user = auth_service.get_user(db, user_id) if user_id is not None else None
+ if user is None:
+ raise _unauthorized("Требуется вход в систему")
+ return user
+
+
+def _session(user: dict) -> dict:
+ return {"access_token": create_token(user["id"]), "token_type": "bearer", "user": user}
+
+
+@router.post("/register", response_model=AuthOut, status_code=status.HTTP_201_CREATED,
+ responses={409: {"description": "Email уже зарегистрирован"}}, summary="Регистрация")
+def register(body: RegisterIn, db: DB):
+ user = auth_service.create_user(db, body.email, body.password)
+ if user is None:
+ raise HTTPException(status.HTTP_409_CONFLICT, "Пользователь с таким email уже зарегистрирован")
+ return _session(user)
+
+
+@router.post("/login", response_model=AuthOut, responses=UNAUTHORIZED, summary="Вход по email и паролю")
+def login(body: LoginIn, db: DB):
+ user = auth_service.authenticate(db, body.email, body.password)
+ if user is None:
+ raise _unauthorized("Неверный email или пароль")
+ return _session(user)
+
+
+@router.get("/me", response_model=UserOut, responses=UNAUTHORIZED, summary="Текущий пользователь")
+def me(user: Annotated[dict, Depends(get_current_user)]):
+ return user
diff --git a/backend/app/core/config.py b/backend/app/core/config.py
index 2c4cbd0..739b497 100644
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -9,3 +9,6 @@
RUL_WARNING = int(os.getenv("RUL_WARNING"))
RUL_CRITICAL = int(os.getenv("RUL_CRITICAL"))
RUL_CLIP = int(os.getenv("RUL_CLIP"))
+
+JWT_SECRET = os.getenv("JWT_SECRET", "")
+JWT_EXPIRE_MINUTES = int(os.getenv("JWT_EXPIRE_MINUTES", "1440"))
diff --git a/backend/app/core/security.py b/backend/app/core/security.py
new file mode 100644
index 0000000..eef5e28
--- /dev/null
+++ b/backend/app/core/security.py
@@ -0,0 +1,40 @@
+import logging
+import secrets
+from datetime import UTC, datetime, timedelta
+
+import bcrypt
+import jwt
+
+from app.core.config import JWT_EXPIRE_MINUTES, JWT_SECRET
+
+logger = logging.getLogger("security")
+
+ALGORITHM = "HS256"
+
+if JWT_SECRET:
+ _secret = JWT_SECRET
+else:
+ _secret = secrets.token_urlsafe(32)
+ logger.warning("JWT_SECRET не задан: сгенерирован временный ключ, после перезапуска backend войти придётся заново")
+
+
+def hash_password(password: str) -> str:
+ return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+
+
+def verify_password(password: str, password_hash: str) -> bool:
+ return bcrypt.checkpw(password.encode(), password_hash.encode())
+
+
+def create_token(user_id: int) -> str:
+ expires = datetime.now(UTC) + timedelta(minutes=JWT_EXPIRE_MINUTES)
+ return jwt.encode({"sub": str(user_id), "exp": expires}, _secret, algorithm=ALGORITHM)
+
+
+def user_id_from_token(token: str) -> int | None:
+ """id пользователя из токена; None, если токен неверен или просрочен."""
+ try:
+ payload = jwt.decode(token, _secret, algorithms=[ALGORITHM], options={"require": ["exp", "sub"]})
+ return int(payload["sub"])
+ except (jwt.InvalidTokenError, ValueError):
+ return None
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index 9041430..f153bad 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -4,6 +4,7 @@
from .physics_predictions import PhysicsPrediction
from .sensor_catalog import SensorCatalog
from .sensor_readings import SensorReading
+from .users import User
__all__ = [
"Alert",
@@ -12,4 +13,5 @@
"PhysicsPrediction",
"SensorCatalog",
"SensorReading",
-]
\ No newline at end of file
+ "User",
+]
diff --git a/backend/app/models/users.py b/backend/app/models/users.py
new file mode 100644
index 0000000..dd90531
--- /dev/null
+++ b/backend/app/models/users.py
@@ -0,0 +1,12 @@
+from sqlalchemy import Column, DateTime, Integer, Text, func
+
+from app.core.db import Base
+
+
+class User(Base):
+ __tablename__ = "users"
+
+ id = Column(Integer, primary_key=True)
+ email = Column(Text, nullable=False, unique=True)
+ password_hash = Column(Text, nullable=False)
+ created_at = Column(DateTime, nullable=False, server_default=func.now())
diff --git a/backend/app/schemas/auth.py b/backend/app/schemas/auth.py
new file mode 100644
index 0000000..8506d6d
--- /dev/null
+++ b/backend/app/schemas/auth.py
@@ -0,0 +1,35 @@
+from pydantic import BaseModel, Field, field_validator
+
+PASSWORD_MAX_BYTES = 72 # bcrypt не принимает пароли длиннее
+
+
+class LoginIn(BaseModel):
+ email: str = Field(max_length=254, pattern=r"^[^@\s]+@[^@\s]+\.[^@\s]+$", examples=["operator@example.com"])
+ password: str = Field(min_length=1)
+
+ @field_validator("email", mode="before")
+ @classmethod
+ def normalize_email(cls, value):
+ return value.strip().lower() if isinstance(value, str) else value
+
+ @field_validator("password")
+ @classmethod
+ def fits_bcrypt(cls, value: str) -> str:
+ if len(value.encode()) > PASSWORD_MAX_BYTES:
+ raise ValueError(f"пароль длиннее {PASSWORD_MAX_BYTES} байт")
+ return value
+
+
+class RegisterIn(LoginIn):
+ password: str = Field(min_length=8, description="От 8 символов, не длиннее 72 байт в UTF-8")
+
+
+class UserOut(BaseModel):
+ id: int
+ email: str
+
+
+class AuthOut(BaseModel):
+ access_token: str = Field(description="JWT для заголовка Authorization: Bearer")
+ token_type: str = "bearer"
+ user: UserOut
diff --git a/backend/app/services/auth_service.py b/backend/app/services/auth_service.py
new file mode 100644
index 0000000..b826dbf
--- /dev/null
+++ b/backend/app/services/auth_service.py
@@ -0,0 +1,31 @@
+from sqlalchemy import Connection, select
+from sqlalchemy.dialects.postgresql import insert
+
+from app.core.security import hash_password, verify_password
+from app.models.users import User
+
+
+def create_user(db: Connection, email: str, password: str) -> dict | None:
+ """Новый пользователь; None, если email уже занят."""
+ query = (
+ insert(User)
+ .values(email=email, password_hash=hash_password(password))
+ .on_conflict_do_nothing(index_elements=[User.email])
+ .returning(User.id, User.email)
+ )
+ row = db.execute(query).mappings().first()
+ db.commit()
+ return dict(row) if row else None
+
+
+def authenticate(db: Connection, email: str, password: str) -> dict | None:
+ query = select(User.id, User.email, User.password_hash).where(User.email == email)
+ row = db.execute(query).mappings().first()
+ if row is None or not verify_password(password, row["password_hash"]):
+ return None
+ return {"id": row["id"], "email": row["email"]}
+
+
+def get_user(db: Connection, user_id: int) -> dict | None:
+ row = db.execute(select(User.id, User.email).where(User.id == user_id)).mappings().first()
+ return dict(row) if row else None
diff --git a/backend/main.py b/backend/main.py
index b3376de..b687a2a 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -1,6 +1,7 @@
-from app.api import alerts, equipment, predict
+from app.api import alerts, auth, equipment, predict
+from app.api.auth import UNAUTHORIZED, get_current_user
from app.core.config import CORS_ORIGINS
-from fastapi import FastAPI
+from fastapi import Depends, FastAPI
from fastapi.middleware.cors import CORSMiddleware
app = FastAPI(title="OFF-Tech: оценка состояния оборудования", version="0.1.0")
@@ -8,6 +9,10 @@
app.add_middleware(CORSMiddleware, allow_origins=CORS_ORIGINS,
allow_methods=["*"], allow_headers=["*"])
-app.include_router(equipment.router)
-app.include_router(alerts.router)
-app.include_router(predict.router)
+# Данные — только с токеном; /auth/register и /auth/login открыты.
+PROTECTED = [Depends(get_current_user)]
+
+app.include_router(auth.router)
+app.include_router(equipment.router, dependencies=PROTECTED, responses=UNAUTHORIZED)
+app.include_router(alerts.router, dependencies=PROTECTED, responses=UNAUTHORIZED)
+app.include_router(predict.router, dependencies=PROTECTED, responses=UNAUTHORIZED)
diff --git a/backend/pytest.ini b/backend/pytest.ini
new file mode 100644
index 0000000..c7b23ec
--- /dev/null
+++ b/backend/pytest.ini
@@ -0,0 +1,3 @@
+[pytest]
+pythonpath = .
+testpaths = tests
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 8b88dc1..4388894 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -8,4 +8,6 @@ httpx==0.27.2
alembic==1.20.0
psycopg[binary]==3.3.6
alembic==1.20.0
-python-dotenv==1.0.1
\ No newline at end of file
+python-dotenv==1.0.1
+PyJWT==2.15.1
+bcrypt==5.0.0
diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py
new file mode 100644
index 0000000..5410b7c
--- /dev/null
+++ b/backend/tests/conftest.py
@@ -0,0 +1,90 @@
+import os
+from datetime import date
+
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import insert, text
+
+# Тесты очищают таблицы, поэтому БД для них задаётся отдельной переменной:
+# рабочий DATABASE_URL здесь намеренно не используется.
+os.environ["DATABASE_URL"] = os.environ["TEST_DATABASE_URL"]
+os.environ["RUL_WARNING"] = "75"
+os.environ["RUL_CRITICAL"] = "30"
+os.environ["RUL_CLIP"] = "125"
+os.environ["JWT_SECRET"] = "test-secret-for-pytest-only-0123456789"
+
+TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users"
+
+
+@pytest.fixture
+def db():
+ from app.core.db import engine
+
+ with engine.begin() as connection:
+ connection.execute(text(f"TRUNCATE {TABLES} RESTART IDENTITY CASCADE"))
+ with engine.connect() as connection:
+ yield connection
+
+
+@pytest.fixture
+def anon_client(db):
+ from main import app
+
+ return TestClient(app)
+
+
+@pytest.fixture
+def client(db):
+ """Клиент вошедшего пользователя: все эндпоинты, кроме /auth, требуют токен."""
+ from app.core.security import create_token
+ from app.models import User
+ from main import app
+
+ statement = insert(User).values(email="operator@example.com", password_hash="-").returning(User.id)
+ user_id = db.execute(statement).scalar_one()
+ db.commit()
+ return TestClient(app, headers={"Authorization": f"Bearer {create_token(user_id)}"})
+
+
+@pytest.fixture
+def add_equipment(db):
+ from app.models import Equipment
+
+ def add(unit_number: int = 81) -> int:
+ statement = insert(Equipment).values(
+ name=f"Turbofan №{unit_number}", type="turbofan", dataset="FD001",
+ unit_number=unit_number, install_date=date(2024, 1, 1),
+ )
+ equipment_id = db.execute(statement.returning(Equipment.id)).scalar_one()
+ db.commit()
+ return equipment_id
+
+ return add
+
+
+@pytest.fixture
+def add_prediction(db):
+ from app.models import MlPrediction
+
+ def add(equipment_id: int, cycle: int, rul: float) -> None:
+ db.execute(insert(MlPrediction).values(
+ equipment_id=equipment_id, cycle=cycle, predicted_rul=rul,
+ defect_probability=0, residual=0, model_version="test",
+ ))
+ db.commit()
+
+ return add
+
+
+@pytest.fixture
+def add_reading(db):
+ from app.models import SensorReading
+ from app.services.equipment_service import SENSOR_CODES
+
+ def add(equipment_id: int, cycle: int) -> dict[str, float]:
+ sensors = {code: float(i + cycle) for i, code in enumerate(SENSOR_CODES)}
+ db.execute(insert(SensorReading).values(equipment_id=equipment_id, cycle=cycle, **sensors))
+ db.commit()
+ return sensors
+
+ return add
diff --git a/backend/tests/test_auth.py b/backend/tests/test_auth.py
new file mode 100644
index 0000000..d81b24b
--- /dev/null
+++ b/backend/tests/test_auth.py
@@ -0,0 +1,131 @@
+import re
+from datetime import UTC, datetime, timedelta
+
+import bcrypt
+import jwt
+import pytest
+from fastapi.routing import APIRoute
+from sqlalchemy import text
+
+OPEN_PATHS = {"/auth/register", "/auth/login", "/health"}
+CREDENTIALS = {"email": "operator@example.com", "password": "correct-horse"}
+
+
+def protected_routes() -> list[tuple[str, str]]:
+ from main import app
+
+ return sorted(
+ (method, re.sub(r"\{[^}]+\}", "1", route.path))
+ for route in app.routes
+ if isinstance(route, APIRoute) and route.path not in OPEN_PATHS
+ for method in route.methods
+ )
+
+
+def bearer(token: str) -> dict[str, str]:
+ return {"Authorization": f"Bearer {token}"}
+
+
+def test_register_returns_working_token(anon_client):
+ response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": " Operator@Example.COM "})
+
+ assert response.status_code == 201
+ body = response.json()
+ assert body["token_type"] == "bearer"
+ assert body["user"]["email"] == "operator@example.com"
+
+ me = anon_client.get("/auth/me", headers=bearer(body["access_token"]))
+ assert me.status_code == 200
+ assert me.json() == body["user"]
+
+
+def test_password_is_stored_as_bcrypt_hash(anon_client, db):
+ anon_client.post("/auth/register", json=CREDENTIALS)
+
+ stored = db.execute(text("SELECT password_hash FROM users")).scalar_one()
+
+ assert CREDENTIALS["password"] not in stored
+ assert bcrypt.checkpw(CREDENTIALS["password"].encode(), stored.encode())
+
+
+def test_register_same_email_conflicts(anon_client):
+ assert anon_client.post("/auth/register", json=CREDENTIALS).status_code == 201
+
+ response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": "OPERATOR@example.com"})
+
+ assert response.status_code == 409
+
+
+@pytest.mark.parametrize("payload", [
+ {"email": "not-an-email", "password": "correct-horse"},
+ {"email": "operator@example.com", "password": "short"},
+ {"email": "operator@example.com", "password": "я" * 37}, # 74 байта — больше лимита bcrypt
+ {"email": "operator@example.com"},
+])
+def test_register_validates_input(anon_client, payload):
+ assert anon_client.post("/auth/register", json=payload).status_code == 422
+
+
+def test_login_returns_working_token(anon_client):
+ anon_client.post("/auth/register", json=CREDENTIALS)
+
+ response = anon_client.post("/auth/login", json={**CREDENTIALS, "email": "Operator@example.com"})
+
+ assert response.status_code == 200
+ assert anon_client.get("/equipment", headers=bearer(response.json()["access_token"])).status_code == 200
+
+
+@pytest.mark.parametrize("credentials", [
+ {**CREDENTIALS, "password": "wrong-password"},
+ {**CREDENTIALS, "email": "nobody@example.com"},
+])
+def test_login_rejects_wrong_credentials(anon_client, credentials):
+ anon_client.post("/auth/register", json=CREDENTIALS)
+
+ response = anon_client.post("/auth/login", json=credentials)
+
+ assert response.status_code == 401
+ assert response.json()["detail"] == "Неверный email или пароль"
+
+
+@pytest.mark.parametrize(("method", "path"), protected_routes())
+def test_api_requires_token(anon_client, method, path):
+ response = anon_client.request(method, path)
+
+ assert response.status_code == 401
+ assert response.headers["WWW-Authenticate"] == "Bearer"
+
+
+def test_protected_routes_cover_api():
+ routes = protected_routes()
+
+ assert ("GET", "/equipment") in routes
+ assert ("GET", "/auth/me") in routes
+
+
+def test_signed_in_client_reaches_api(client):
+ assert client.get("/equipment").status_code == 200
+ assert client.get("/auth/me").json()["email"] == "operator@example.com"
+
+
+def _token(secret: str, sub: str = "1", minutes: int = 5) -> str:
+ expires = datetime.now(UTC) + timedelta(minutes=minutes)
+ return jwt.encode({"sub": sub, "exp": expires}, secret, algorithm="HS256")
+
+
+def test_rejects_bad_tokens(client):
+ from app.core.config import JWT_SECRET
+
+ user_token = client.headers["Authorization"].removeprefix("Bearer ")
+ user_id = jwt.decode(user_token, JWT_SECRET, algorithms=["HS256"])["sub"]
+ bad = {
+ "garbage": bearer("garbage"),
+ "foreign secret": bearer(_token("another-secret-another-secret-0123", user_id)),
+ "expired": bearer(_token(JWT_SECRET, user_id, minutes=-1)),
+ "unknown user": bearer(_token(JWT_SECRET, "999")),
+ "basic scheme": {"Authorization": f"Basic {user_token}"},
+ }
+
+ for name, headers in bad.items():
+ response = client.get("/equipment", headers=headers)
+ assert response.status_code == 401, name
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index cb460a0..564e879 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,30 +1,56 @@
-import { NavLink, Route, Routes } from "react-router-dom";
+import { Navigate, NavLink, Outlet, Route, Routes, useLocation } from "react-router-dom";
import { Alerts } from "./pages/Alerts";
+import { AuthPage } from "./pages/Auth";
import { EquipmentCard } from "./pages/EquipmentCard";
import { EquipmentList } from "./pages/EquipmentList";
+import { setSession, useSession } from "./session";
export function App() {
+ const session = useSession();
+
return (
<>
- } />
- } />
- } />
- Страница не найдена
} />
+ } />
+ } />
+ }>
+ } />
+ } />
+ } />
+ Страница не найдена} />
+
>
);
}
+
+function RequireAuth() {
+ const session = useSession();
+ const location = useLocation();
+
+ if (!session) return ;
+ return ;
+}
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index 5819da1..6572e7a 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -1,3 +1,5 @@
+import { getToken, setSession } from "./session";
+
export type Status = "normal" | "warning" | "critical";
export interface Equipment {
@@ -49,21 +51,53 @@ export interface Alert {
message: string;
}
+export interface User {
+ id: number;
+ email: string;
+}
+
+export interface AuthResponse {
+ access_token: string;
+ token_type: string;
+ user: User;
+}
+
+export class ApiError extends Error {
+ status: number;
+ detail: string;
+
+ constructor(status: number, detail: string) {
+ super(`${status}: ${detail}`);
+ this.status = status;
+ this.detail = detail;
+ }
+}
+
const BASE = "/api";
async function request(path: string, init?: RequestInit): Promise {
- const res = await fetch(BASE + path, init);
+ const token = getToken();
+ const headers = new Headers(init?.headers);
+ if (token) headers.set("Authorization", `Bearer ${token}`);
+ const res = await fetch(BASE + path, { ...init, headers });
if (!res.ok) {
+ // Токен просрочен или пользователь удалён: выходим, RequireAuth откроет страницу входа.
+ if (res.status === 401 && token && token === getToken()) setSession(null);
let detail = res.statusText;
try {
const body = await res.json();
if (typeof body.detail === "string") detail = body.detail;
+ else if (Array.isArray(body.detail)) detail = body.detail.map((d: { msg: string }) => d.msg).join("; ");
} catch {}
- throw new Error(`${res.status}: ${detail}`);
+ throw new ApiError(res.status, detail);
}
return res.json() as Promise;
}
+function postJson(body: unknown): RequestInit {
+ return { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) };
+}
+
export const api = {
listEquipment: () => request("/equipment"),
getEquipment: (id: number) => request(`/equipment/${id}`),
@@ -71,10 +105,8 @@ export const api = {
getForecast: (id: number) => request(`/equipment/${id}/forecast`),
listAlerts: (limit = 100) => request(`/alerts?limit=${limit}`),
alertsByEquipment: (id: number, limit = 50) => request(`/alerts/${id}?limit=${limit}`),
- predict: (id: number) =>
- request("/predict", {
- method: "POST",
- headers: { "Content-Type": "application/json" },
- body: JSON.stringify({ equipment_id: id }),
- }),
+ predict: (id: number) => request("/predict", postJson({ equipment_id: id })),
+ login: (email: string, password: string) => request("/auth/login", postJson({ email, password })),
+ register: (email: string, password: string) =>
+ request("/auth/register", postJson({ email, password })),
};
diff --git a/frontend/src/index.css b/frontend/src/index.css
index 9cca51c..fd4a7fa 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -248,3 +248,53 @@ h2 {
color: #2563eb;
font-weight: 500;
}
+
+.user {
+ margin-left: auto;
+ display: flex;
+ align-items: center;
+ gap: 12px;
+ min-width: 0;
+ color: #d1d5db;
+ font-size: 14px;
+}
+.user-email {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
+
+.auth {
+ max-width: 380px;
+ margin: 48px auto;
+ padding: 24px;
+}
+.auth form {
+ display: flex;
+ flex-direction: column;
+ gap: 14px;
+ margin: 20px 0 16px;
+}
+.auth label {
+ display: flex;
+ flex-direction: column;
+ gap: 6px;
+ font-size: 14px;
+ font-weight: 500;
+}
+.auth input {
+ padding: 8px 10px;
+ border: 1px solid #d1d5db;
+ border-radius: 6px;
+ font: inherit;
+}
+.auth input:focus {
+ outline: 2px solid #93c5fd;
+ border-color: #2563eb;
+}
+.auth .error {
+ margin: 0;
+}
+.auth .muted {
+ text-align: center;
+}
diff --git a/frontend/src/pages/Auth.tsx b/frontend/src/pages/Auth.tsx
new file mode 100644
index 0000000..fc51e61
--- /dev/null
+++ b/frontend/src/pages/Auth.tsx
@@ -0,0 +1,97 @@
+import { type FormEvent, useState } from "react";
+import { Link, Navigate, useLocation } from "react-router-dom";
+
+import { ApiError, api } from "../api";
+import { setSession, useSession } from "../session";
+
+const PASSWORD_MIN = 8;
+const PASSWORD_MAX_BYTES = 72;
+
+const MODES = {
+ login: {
+ title: "Вход",
+ submit: "Войти",
+ send: api.login,
+ other: { question: "Нет аккаунта?", link: "Зарегистрироваться", to: "/register" },
+ },
+ register: {
+ title: "Регистрация",
+ submit: "Зарегистрироваться",
+ send: api.register,
+ other: { question: "Уже есть аккаунт?", link: "Войти", to: "/login" },
+ },
+};
+
+export function AuthPage({ mode }: { mode: keyof typeof MODES }) {
+ const session = useSession();
+ const location = useLocation();
+ const [error, setError] = useState(null);
+ const [busy, setBusy] = useState(false);
+ const page = MODES[mode];
+ const register = mode === "register";
+
+ if (session) {
+ const from = (location.state as { from?: string } | null)?.from ?? "/";
+ return ;
+ }
+
+ async function onSubmit(e: FormEvent) {
+ e.preventDefault();
+ const form = new FormData(e.currentTarget);
+ const email = String(form.get("email"));
+ const password = String(form.get("password"));
+ if (register && password !== form.get("confirm")) return setError("Пароли не совпадают");
+ if (register && new TextEncoder().encode(password).length > PASSWORD_MAX_BYTES) {
+ return setError(`Пароль слишком длинный: не больше ${PASSWORD_MAX_BYTES} байт`);
+ }
+
+ setBusy(true);
+ setError(null);
+ try {
+ const res = await page.send(email, password);
+ setSession({ token: res.access_token, email: res.user.email });
+ } catch (err) {
+ setError(err instanceof ApiError ? err.detail : "Нет связи с сервером");
+ setBusy(false);
+ }
+ }
+
+ return (
+
+ {page.title}
+
+
+ {page.other.question}{" "}
+
+ {page.other.link}
+
+
+
+ );
+}
diff --git a/frontend/src/session.ts b/frontend/src/session.ts
new file mode 100644
index 0000000..bd7fa76
--- /dev/null
+++ b/frontend/src/session.ts
@@ -0,0 +1,56 @@
+import { useSyncExternalStore } from "react";
+
+export interface Session {
+ token: string;
+ email: string;
+}
+
+const KEY = "offtech.session";
+const listeners = new Set<() => void>();
+
+function read(): Session | null {
+ try {
+ const value = JSON.parse(localStorage.getItem(KEY) ?? "null");
+ return typeof value?.token === "string" && typeof value?.email === "string" ? value : null;
+ } catch {
+ return null;
+ }
+}
+
+let session = read();
+
+function notify(): void {
+ listeners.forEach((l) => l());
+}
+
+export function getToken(): string | null {
+ return session?.token ?? null;
+}
+
+export function setSession(next: Session | null): void {
+ session = next;
+ try {
+ if (next) localStorage.setItem(KEY, JSON.stringify(next));
+ else localStorage.removeItem(KEY);
+ } catch {
+ }
+ notify();
+}
+
+// Вход и выход в соседней вкладке.
+window.addEventListener("storage", (e) => {
+ if (e.key !== KEY && e.key !== null) return;
+ session = read();
+ notify();
+});
+
+export function useSession(): Session | null {
+ return useSyncExternalStore(
+ (cb) => {
+ listeners.add(cb);
+ return () => listeners.delete(cb);
+ },
+ () => session,
+ () => null,
+ );
+}
From 6bebd45beb8002dbea543cda43abe6da6c812656 Mon Sep 17 00:00:00 2001
From: mqudiee
Date: Wed, 11 Nov 2026 02:52:59 +0300
Subject: [PATCH 2/3] feat: add admin-managed user accounts
---
.env.example | 3 +
.github/workflows/ci.yml | 21 ++
README.md | 56 +++-
.../versions/b48a001_managed_accounts.py | 44 +++
backend/app/api/auth.py | 49 ++-
backend/app/api/users.py | 56 ++++
backend/app/core/login_throttle.py | 45 +++
backend/app/core/security.py | 43 +--
backend/app/create_admin.py | 33 ++
backend/app/models/__init__.py | 3 +-
backend/app/models/users.py | 29 +-
backend/app/schemas/auth.py | 69 +++-
backend/app/services/auth_service.py | 31 +-
backend/main.py | 15 +-
backend/tests/conftest.py | 30 +-
backend/tests/test_auth.py | 297 ++++++++++++------
docker-compose.yml | 4 +-
frontend/src/App.tsx | 99 +++---
frontend/src/api.ts | 23 +-
frontend/src/components/PasswordField.tsx | 22 ++
frontend/src/index.css | 36 ++-
frontend/src/pages/Auth.tsx | 97 ++----
frontend/src/pages/Users.tsx | 131 ++++++++
frontend/src/session.ts | 5 +-
24 files changed, 923 insertions(+), 318 deletions(-)
create mode 100644 backend/alembic/versions/b48a001_managed_accounts.py
create mode 100644 backend/app/api/users.py
create mode 100644 backend/app/core/login_throttle.py
create mode 100644 backend/app/create_admin.py
create mode 100644 frontend/src/components/PasswordField.tsx
create mode 100644 frontend/src/pages/Users.tsx
diff --git a/.env.example b/.env.example
index 6dc6983..8a3dd53 100644
--- a/.env.example
+++ b/.env.example
@@ -2,6 +2,8 @@ POSTGRES_USER=pdm
POSTGRES_PASSWORD=pdm
POSTGRES_DB=pdm
POSTGRES_PORT=5432
+BACKEND_PORT=8000
+FRONTEND_PORT=5173
DATABASE_URL=postgresql+psycopg://pdm:pdm@localhost:5432/pdm
SIMULATOR_WAIT_TIME=30
WORKER_POLL_INTERVAL=30
@@ -12,5 +14,6 @@ RUL_CRITICAL=30
RUL_CLIP=125
BOT_TOKEN=
CHAT_ID=
+# Required: persistent random signing secret, at least 32 bytes (not a user password).
JWT_SECRET=
JWT_EXPIRE_MINUTES=1440
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 066a9bf..4b37909 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -64,6 +64,12 @@ jobs:
working-directory: backend
run: alembic check
+ - name: Test authentication and authorization
+ working-directory: backend
+ env:
+ TEST_DATABASE_URL: postgresql+psycopg://pdm:pdm@localhost:5432/pdm
+ run: pytest -q
+
model:
runs-on: ubuntu-latest
@@ -156,3 +162,18 @@ jobs:
ML=$(psql "$PSQL_URL" -tAc "SELECT count(*) FROM ml_predictions")
echo "equipment=$EQ sensor_readings=$SR ml_predictions=$ML"
[ "$EQ" -eq 20 ] && [ "$SR" -gt 0 ] && [ "$ML" -eq "$SR" ]
+
+ frontend:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: actions/setup-node@v4
+ with:
+ node-version: "22"
+ cache: npm
+ cache-dependency-path: frontend/package-lock.json
+ - name: Install and build frontend
+ working-directory: frontend
+ run: |
+ npm ci
+ npm run build
diff --git a/README.md b/README.md
index b5b7d24..ddace6e 100644
--- a/README.md
+++ b/README.md
@@ -114,17 +114,57 @@ api/v1 (эндпоинты, валидация) → services (бизнес-ло
## Контракты API
-Все эндпоинты — с префиксом `/api/v1`. Документация OpenAPI: `/docs`.
+Ниже указаны пути backend. Frontend обращается к ним через прокси `/api` (например, `/api/auth/login`). Документация OpenAPI backend: `/docs`.
-### Авторизация
+### Авторизация и управление аккаунтами
-Все эндпоинты, кроме `/auth/register`, `/auth/login` и `/health`, требуют заголовок `Authorization: Bearer <токен>`, без него отвечают `401`. Токен — JWT, его выдают регистрация и вход; живёт `JWT_EXPIRE_MINUTES` минут (по умолчанию сутки). Подписывается ключом `JWT_SECRET` из `.env`: сгенерировать — `python -c "import secrets; print(secrets.token_urlsafe(32))"`. Если ключ не задан, backend создаёт временный, и после его перезапуска войти придётся заново. Пароли хранятся только как bcrypt-хэш.
+Публичной регистрации нет. Аккаунты выдаёт администратор; он вручную задаёт логин и постоянный пароль. Почтовая отправка не используется.
-| Метод | Эндпоинт | Описание | Ожидаемый latency |
-| ----- | ---------------- | ------------------------------------------------------------- | ----------------- |
-| POST | `/auth/register` | Регистрация по email и паролю (от 8 символов), сразу выдаёт токен; `409`, если email занят | < 500 мс |
-| POST | `/auth/login` | Вход: токен; `401` при неверном email или пароле | < 500 мс |
-| GET | `/auth/me` | Текущий пользователь | < 100 мс |
+- `employee`: оборудование, история, графики, алерты и прогнозирование.
+- `admin`: все возможности сотрудника, плюс список аккаунтов, создание сотрудников, сброс их паролей и блокировка/разблокировка.
+- Логин: 3–64 символа, латинские буквы, цифры, `.`, `_`, `-`. Пробелы по краям убираются, регистр приводится к нижнему. Уникальность обеспечивает PostgreSQL.
+- Новый пароль: от 12 символов, не более 72 байт UTF-8 (лимит bcrypt). Пробелы, регистр и спецсимволы сохраняются. В базе хранится только bcrypt-хеш с индивидуальной солью.
+- JWT выдаётся только при входе и действует `JWT_EXPIRE_MINUTES` минут (по умолчанию 1440). Для запуска обязателен постоянный `JWT_SECRET` длиной минимум 32 байта. Он не является паролем пользователя.
+- На каждом защищённом запросе backend сверяет пользователя, его состояние и версию токена с базой; административные операции дополнительно проверяют роль. Данные роли из браузера не принимаются.
+- Сброс пароля и изменение блокировки увеличивают `token_version`. Старые токены больше не работают, в том числе после разблокировки. Сброс пароля не разблокирует аккаунт.
+- Через панель можно изменять только сотрудников. Администратора нельзя заблокировать или изменить его пароль через эти endpoints.
+- Лимит входа: 10 попыток на логин и 60 на адрес за 15 минут, включая успешные попытки. Счётчики атомарные, общие для процессов backend в PostgreSQL. Ответ `429` содержит `Retry-After`. Учитывается адрес подключения, не пользовательский `X-Forwarded-For`; за обратным прокси лимит адреса может быть общим для клиентов этого прокси.
+
+| Метод | Путь | Доступ и действие |
+| --- | --- | --- |
+| POST | `/auth/login` | Публичный вход: `{ "login": "ivan.petrov", "password": "…" }` |
+| GET | `/auth/me` | Текущий активный пользователь |
+| GET | `/admin/users?limit=50&offset=0` | Администратор: список аккаунтов без паролей и хешей |
+| POST | `/admin/users` | Администратор: `{ "login": "ivan.petrov", "password": "…" }`, создаёт только `employee` |
+| PUT | `/admin/users/{id}/password` | Администратор: `{ "password": "…" }`, сброс пароля сотрудника и отзыв токенов |
+| PUT | `/admin/users/{id}/status` | Администратор: `{ "is_active": false }` для блокировки, `true` для разблокировки |
+
+Остальные рабочие endpoints тоже требуют `Authorization: Bearer <токен>`. Без действующего токена — `401`; сотруднику на административном endpoint — `403`; занятый логин — `409`. `/auth/register` удалён, отвечает `404`.
+
+#### Запуск и первый администратор
+
+1. Скопировать `.env.example` в `.env` и заполнить настройки. Секрет подписи сгенерировать командой `python3 -c "import secrets; print(secrets.token_urlsafe(32))"` и записать в `JWT_SECRET`. Файл `.env` не коммитить.
+2. Запустить `docker compose up -d --build db backend frontend`. Backend применит миграции автоматически. Для данных симулятора и расчётов отдельно запустить нужные сервисы проекта.
+3. Выполнить `docker compose exec backend python -m app.create_admin`. Вручную ввести логин и дважды пароль (ввод пароля скрыт). Повторение занятого логина не изменяет существующий аккаунт. Команда доступна только имеющему доступ к серверу; не принимает пароль аргументом командной строки.
+4. Открыть `http://localhost:5173` (либо порт `FRONTEND_PORT`), войти администратором. В разделе «Пользователи» создать сотрудника и лично передать ему введённые данные.
+
+При локальном запуске без Docker сначала выполнить `alembic upgrade head` из `backend`, затем `python -m app.create_admin` в том же окружении с настроенным `DATABASE_URL` и `JWT_SECRET`.
+
+Миграция `b48a001` следует за миграцией PR #48 `1395cb8114bd`. Она рассчитана на согласованное отсутствие существующих аккаунтов: если `users` не пуста, миграция остановится без удаления данных. Не применять её к базе прежней локальной реализации с другой веткой миграций. Для параллельной проверки использовать отдельную базу/Compose-проект. Порты задаются `POSTGRES_PORT`, `BACKEND_PORT`, `FRONTEND_PORT`.
+
+Для размещения вне локальной разработки требуется HTTPS. В этой версии сохранён способ хранения токена из #48 — localStorage; выход удаляет его из браузера, но сам по себе не отзывает скопированную копию токена. Серверный отзыв выполняется при сбросе пароля или блокировке. Администратор знает вручную заданный пароль сотрудника — это осознанное упрощение учебного проекта, обязательной смены пароля нет.
+
+#### Проверки
+
+Backend-тесты **очищают таблицы**. Указать отдельную тестовую базу:
+
+```bash
+cd backend
+DATABASE_URL=postgresql+psycopg://pdm:pdm@localhost:5432/offtech_test alembic upgrade head
+TEST_DATABASE_URL=postgresql+psycopg://pdm:pdm@localhost:5432/offtech_test pytest -q
+```
+
+Тесты задают тестовый ключ JWT самостоятельно. Проверяют обе роли, административные операции, прямой обход UI, блокировку, отзыв токенов, параллельные изменения, валидацию и лимиты входа. Проверка миграций: `alembic check`. Проверка frontend: `cd frontend && npm ci && npm run build`. Эти проверки также добавлены в CI.
### Оборудование
diff --git a/backend/alembic/versions/b48a001_managed_accounts.py b/backend/alembic/versions/b48a001_managed_accounts.py
new file mode 100644
index 0000000..c5dcbf8
--- /dev/null
+++ b/backend/alembic/versions/b48a001_managed_accounts.py
@@ -0,0 +1,44 @@
+"""Managed accounts: logins, roles, revocable tokens and login throttling.
+
+Revision ID: b48a001
+Revises: 1395cb8114bd
+"""
+import sqlalchemy as sa
+from alembic import op
+
+revision = "b48a001"
+down_revision = "1395cb8114bd"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # This deployment has no existing accounts. Do not silently convert real emails.
+ if op.get_bind().execute(sa.text("SELECT EXISTS (SELECT 1 FROM users)")).scalar():
+ raise RuntimeError("Managed-account migration requires an empty users table; existing accounts need an explicit migration plan.")
+ op.drop_constraint("users_email_key", "users", type_="unique")
+ op.alter_column("users", "email", new_column_name="login", type_=sa.String(64), existing_type=sa.Text())
+ op.create_unique_constraint("users_login_key", "users", ["login"])
+ op.add_column("users", sa.Column("role", sa.String(16), nullable=False, server_default="employee"))
+ op.add_column("users", sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")))
+ op.add_column("users", sa.Column("token_version", sa.Integer(), nullable=False, server_default="0"))
+ op.create_check_constraint("users_role_check", "users", "role IN ('admin', 'employee')")
+ op.create_check_constraint("users_login_check", "users", "login ~ '^[a-z0-9._-]{3,64}$'")
+ op.create_table("login_attempts",
+ sa.Column("key", sa.String(64), primary_key=True),
+ sa.Column("count", sa.Integer(), nullable=False),
+ sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
+ )
+ op.create_index("ix_login_attempts_expires_at", "login_attempts", ["expires_at"])
+
+
+def downgrade():
+ op.drop_table("login_attempts")
+ op.drop_constraint("users_login_check", "users", type_="check")
+ op.drop_constraint("users_role_check", "users", type_="check")
+ op.drop_column("users", "token_version")
+ op.drop_column("users", "is_active")
+ op.drop_column("users", "role")
+ op.drop_constraint("users_login_key", "users", type_="unique")
+ op.alter_column("users", "login", new_column_name="email", type_=sa.Text(), existing_type=sa.String(64))
+ op.create_unique_constraint("users_email_key", "users", ["email"])
diff --git a/backend/app/api/auth.py b/backend/app/api/auth.py
index f1b411c..54ad6c9 100644
--- a/backend/app/api/auth.py
+++ b/backend/app/api/auth.py
@@ -1,53 +1,50 @@
from typing import Annotated
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, Request
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from app.core.db import DB
-from app.core.security import create_token, user_id_from_token
-from app.schemas.auth import AuthOut, LoginIn, RegisterIn, UserOut
+from app.core.login_throttle import check_login_attempt
+from app.core.security import create_token, identity_from_token
+from app.schemas.auth import AuthOut, LoginIn, UserOut
from app.services import auth_service
router = APIRouter(prefix="/auth", tags=["Авторизация"])
-
-bearer = HTTPBearer(auto_error=False, description="Токен из /auth/login или /auth/register")
-
-UNAUTHORIZED = {401: {"description": "Нет токена, токен неверен или просрочен"}}
+bearer = HTTPBearer(auto_error=False, description="Токен из /auth/login")
+UNAUTHORIZED = {401: {"description": "Требуется действующий токен активного пользователя"}}
def _unauthorized(detail: str) -> HTTPException:
- return HTTPException(status.HTTP_401_UNAUTHORIZED, detail, headers={"WWW-Authenticate": "Bearer"})
+ return HTTPException(401, detail, headers={"WWW-Authenticate": "Bearer"})
def get_current_user(db: DB, credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(bearer)]) -> dict:
- user_id = user_id_from_token(credentials.credentials) if credentials else None
- user = auth_service.get_user(db, user_id) if user_id is not None else None
- if user is None:
+ identity = identity_from_token(credentials.credentials) if credentials else None
+ user = auth_service.get_user(db, identity[0]) if identity else None
+ if user is None or not user["is_active"] or user["token_version"] != identity[1]:
raise _unauthorized("Требуется вход в систему")
return user
-def _session(user: dict) -> dict:
- return {"access_token": create_token(user["id"]), "token_type": "bearer", "user": user}
+CurrentUser = Annotated[dict, Depends(get_current_user)]
-@router.post("/register", response_model=AuthOut, status_code=status.HTTP_201_CREATED,
- responses={409: {"description": "Email уже зарегистрирован"}}, summary="Регистрация")
-def register(body: RegisterIn, db: DB):
- user = auth_service.create_user(db, body.email, body.password)
- if user is None:
- raise HTTPException(status.HTTP_409_CONFLICT, "Пользователь с таким email уже зарегистрирован")
- return _session(user)
+def require_admin(user: CurrentUser) -> dict:
+ if user["role"] != "admin":
+ raise HTTPException(403, "Доступ разрешён только администратору")
+ return user
-@router.post("/login", response_model=AuthOut, responses=UNAUTHORIZED, summary="Вход по email и паролю")
-def login(body: LoginIn, db: DB):
- user = auth_service.authenticate(db, body.email, body.password)
+@router.post("/login", response_model=AuthOut, responses={**UNAUTHORIZED, 429: {"description": "Лимит попыток входа"}},
+ summary="Вход по логину и паролю")
+def login(body: LoginIn, request: Request, db: DB):
+ check_login_attempt(request, body.login)
+ user = auth_service.authenticate(db, body.login, body.password)
if user is None:
- raise _unauthorized("Неверный email или пароль")
- return _session(user)
+ raise _unauthorized("Неверный логин или пароль")
+ return {"access_token": create_token(user["id"], user["token_version"]), "token_type": "bearer", "user": user}
@router.get("/me", response_model=UserOut, responses=UNAUTHORIZED, summary="Текущий пользователь")
-def me(user: Annotated[dict, Depends(get_current_user)]):
+def me(user: CurrentUser):
return user
diff --git a/backend/app/api/users.py b/backend/app/api/users.py
new file mode 100644
index 0000000..9131968
--- /dev/null
+++ b/backend/app/api/users.py
@@ -0,0 +1,56 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy import select, update
+
+from app.api.auth import require_admin
+from app.core.db import DB
+from app.core.security import hash_password
+from app.models.users import User
+from app.schemas.auth import CreateUserIn, ManagedUserOut, ResetPasswordIn, SetActiveIn
+from app.services.auth_service import PUBLIC_COLUMNS, create_user
+
+router = APIRouter(prefix="/admin/users", tags=["Управление аккаунтами"], dependencies=[Depends(require_admin)],
+ responses={401: {"description": "Требуется вход"}, 403: {"description": "Недостаточно прав"}})
+
+
+@router.get("", response_model=list[ManagedUserOut])
+def list_users(db: DB, limit: Annotated[int, Query(ge=1, le=100)] = 50,
+ offset: Annotated[int, Query(ge=0)] = 0):
+ return db.execute(select(*PUBLIC_COLUMNS).order_by(User.id).limit(limit).offset(offset)).mappings().all()
+
+
+@router.post("", response_model=ManagedUserOut, status_code=201)
+def add_user(body: CreateUserIn, db: DB):
+ user = create_user(db, body.login, body.password)
+ if user is None:
+ raise HTTPException(409, "Этот логин уже занят")
+ return user
+
+
+def employee_for_update(db: DB, user_id: int):
+ user = db.execute(select(User.id, User.role).where(User.id == user_id).with_for_update()).mappings().first()
+ if user is None:
+ raise HTTPException(404, "Пользователь не найден")
+ if user["role"] != "employee":
+ raise HTTPException(403, "Через панель можно изменять только аккаунты сотрудников")
+
+
+@router.put("/{user_id}/password", status_code=204)
+def reset_password(user_id: int, body: ResetPasswordIn, db: DB):
+ password_hash = hash_password(body.password)
+ employee_for_update(db, user_id)
+ db.execute(update(User).where(User.id == user_id).values(
+ password_hash=password_hash, token_version=User.token_version + 1))
+ db.commit()
+
+
+@router.put("/{user_id}/status", response_model=ManagedUserOut)
+def set_active(user_id: int, body: SetActiveIn, db: DB):
+ employee_for_update(db, user_id)
+ # Invalidate tokens even on repeated status updates; unblocking never revives old tokens.
+ user = db.execute(update(User).where(User.id == user_id).values(
+ is_active=body.is_active, token_version=User.token_version + 1,
+ ).returning(*PUBLIC_COLUMNS)).mappings().one()
+ db.commit()
+ return user
diff --git a/backend/app/core/login_throttle.py b/backend/app/core/login_throttle.py
new file mode 100644
index 0000000..a37d1cf
--- /dev/null
+++ b/backend/app/core/login_throttle.py
@@ -0,0 +1,45 @@
+from datetime import timedelta
+
+from fastapi import HTTPException, Request
+from sqlalchemy import case, delete, func
+from sqlalchemy.dialects.postgresql import insert
+
+from app.core.db import engine
+from app.core.security import throttle_key
+from app.models.users import LoginAttempt
+
+WINDOW_SECONDS = 15 * 60
+LOGIN_LIMIT = 10
+IP_LIMIT = 60
+
+
+def check_login_attempt(request: Request, login: str):
+ """Atomic counters shared across workers. Count all attempts, before bcrypt.
+
+ Use the actual peer address; do not trust client-supplied forwarding headers.
+ Successful login does not reset limits, which would enable a bypass.
+ """
+ identities = [("login", login, LOGIN_LIMIT),
+ ("ip", request.client.host if request.client else "unknown", IP_LIMIT)]
+ exceeded = False
+ retry_after = 1
+ with engine.begin() as db:
+ db.execute(delete(LoginAttempt).where(LoginAttempt.expires_at <= func.now()))
+ for kind, value, limit in identities:
+ statement = insert(LoginAttempt).values(
+ key=throttle_key(kind, value), count=1,
+ expires_at=func.now() + timedelta(seconds=WINDOW_SECONDS),
+ )
+ expired = LoginAttempt.expires_at <= func.now()
+ row = db.execute(statement.on_conflict_do_update(
+ index_elements=[LoginAttempt.key],
+ set_={"count": case((expired, 1), else_=LoginAttempt.count + 1),
+ "expires_at": case((expired, statement.excluded.expires_at), else_=LoginAttempt.expires_at)},
+ ).returning(LoginAttempt.count,
+ func.extract("epoch", LoginAttempt.expires_at - func.now()).label("remaining"))).one()
+ if row.count > limit:
+ exceeded = True
+ retry_after = max(retry_after, int(row.remaining) + 1)
+ if exceeded:
+ raise HTTPException(429, "Слишком много попыток входа. Повторите позже.",
+ headers={"Retry-After": str(retry_after)})
diff --git a/backend/app/core/security.py b/backend/app/core/security.py
index eef5e28..4883659 100644
--- a/backend/app/core/security.py
+++ b/backend/app/core/security.py
@@ -1,5 +1,5 @@
-import logging
-import secrets
+import hashlib
+import hmac
from datetime import UTC, datetime, timedelta
import bcrypt
@@ -7,15 +7,10 @@
from app.core.config import JWT_EXPIRE_MINUTES, JWT_SECRET
-logger = logging.getLogger("security")
-
ALGORITHM = "HS256"
-
-if JWT_SECRET:
- _secret = JWT_SECRET
-else:
- _secret = secrets.token_urlsafe(32)
- logger.warning("JWT_SECRET не задан: сгенерирован временный ключ, после перезапуска backend войти придётся заново")
+if len(JWT_SECRET.encode()) < 32:
+ raise RuntimeError("JWT_SECRET must contain at least 32 bytes; configure a persistent secret before starting the backend")
+DUMMY_HASH = bcrypt.hashpw(b"dummy-password-for-timing", bcrypt.gensalt()).decode()
def hash_password(password: str) -> str:
@@ -23,18 +18,28 @@ def hash_password(password: str) -> str:
def verify_password(password: str, password_hash: str) -> bool:
- return bcrypt.checkpw(password.encode(), password_hash.encode())
+ try:
+ return bcrypt.checkpw(password.encode(), password_hash.encode())
+ except ValueError:
+ return False
-def create_token(user_id: int) -> str:
- expires = datetime.now(UTC) + timedelta(minutes=JWT_EXPIRE_MINUTES)
- return jwt.encode({"sub": str(user_id), "exp": expires}, _secret, algorithm=ALGORITHM)
+def create_token(user_id: int, token_version: int = 0) -> str:
+ now = datetime.now(UTC)
+ return jwt.encode({"sub": str(user_id), "ver": token_version, "iat": now,
+ "exp": now + timedelta(minutes=JWT_EXPIRE_MINUTES)}, JWT_SECRET, algorithm=ALGORITHM)
-def user_id_from_token(token: str) -> int | None:
- """id пользователя из токена; None, если токен неверен или просрочен."""
+def identity_from_token(token: str) -> tuple[int, int] | None:
try:
- payload = jwt.decode(token, _secret, algorithms=[ALGORITHM], options={"require": ["exp", "sub"]})
- return int(payload["sub"])
- except (jwt.InvalidTokenError, ValueError):
+ payload = jwt.decode(token, JWT_SECRET, algorithms=[ALGORITHM],
+ options={"require": ["exp", "sub", "ver", "iat"]})
+ if type(payload["ver"]) is not int or payload["ver"] < 0:
+ return None
+ return int(payload["sub"]), payload["ver"]
+ except (jwt.InvalidTokenError, ValueError, TypeError):
return None
+
+
+def throttle_key(kind: str, value: str) -> str:
+ return hmac.new(JWT_SECRET.encode(), f"{kind}:{value}".encode(), hashlib.sha256).hexdigest()
diff --git a/backend/app/create_admin.py b/backend/app/create_admin.py
new file mode 100644
index 0000000..11f88d0
--- /dev/null
+++ b/backend/app/create_admin.py
@@ -0,0 +1,33 @@
+"""Run on the server: python -m app.create_admin (credentials are never command arguments)."""
+from getpass import getpass
+
+from pydantic import ValidationError
+
+from app.core.db import engine
+from app.schemas.auth import CreateUserIn
+from app.services.auth_service import create_user
+
+
+def main():
+ try:
+ login = input("Логин администратора: ")
+ password = getpass("Пароль (от 12 символов): ")
+ confirm = getpass("Повторите пароль: ")
+ if password != confirm:
+ raise SystemExit("Пароли не совпадают. Аккаунт не создан.")
+ try:
+ credentials = CreateUserIn(login=login, password=password)
+ except ValidationError as exc:
+ # Never print Pydantic's input values: they may include the password.
+ raise SystemExit("; ".join(error["msg"] for error in exc.errors(include_input=False))) from None
+ with engine.connect() as db:
+ user = create_user(db, credentials.login, credentials.password, role="admin")
+ if user is None:
+ raise SystemExit("Логин уже занят. Существующий аккаунт не изменён.")
+ print(f"Администратор {user['login']} создан.")
+ except (EOFError, KeyboardInterrupt):
+ raise SystemExit("Создание отменено.") from None
+
+
+if __name__ == "__main__":
+ main()
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index f153bad..deef55c 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -4,11 +4,12 @@
from .physics_predictions import PhysicsPrediction
from .sensor_catalog import SensorCatalog
from .sensor_readings import SensorReading
-from .users import User
+from .users import LoginAttempt, User
__all__ = [
"Alert",
"Equipment",
+ "LoginAttempt",
"MlPrediction",
"PhysicsPrediction",
"SensorCatalog",
diff --git a/backend/app/models/users.py b/backend/app/models/users.py
index dd90531..295030f 100644
--- a/backend/app/models/users.py
+++ b/backend/app/models/users.py
@@ -1,12 +1,37 @@
-from sqlalchemy import Column, DateTime, Integer, Text, func
+from sqlalchemy import (
+ Boolean,
+ CheckConstraint,
+ Column,
+ DateTime,
+ Integer,
+ String,
+ Text,
+ func,
+ text,
+)
from app.core.db import Base
class User(Base):
__tablename__ = "users"
+ __table_args__ = (
+ CheckConstraint("role IN ('admin', 'employee')", name="users_role_check"),
+ CheckConstraint("login ~ '^[a-z0-9._-]{3,64}$'", name="users_login_check"),
+ )
id = Column(Integer, primary_key=True)
- email = Column(Text, nullable=False, unique=True)
+ login = Column(String(64), nullable=False, unique=True)
password_hash = Column(Text, nullable=False)
+ role = Column(String(16), nullable=False, server_default="employee")
+ is_active = Column(Boolean, nullable=False, server_default=text("true"))
+ token_version = Column(Integer, nullable=False, server_default="0")
created_at = Column(DateTime, nullable=False, server_default=func.now())
+
+
+class LoginAttempt(Base):
+ __tablename__ = "login_attempts"
+
+ key = Column(String(64), primary_key=True)
+ count = Column(Integer, nullable=False)
+ expires_at = Column(DateTime(timezone=True), nullable=False, index=True)
diff --git a/backend/app/schemas/auth.py b/backend/app/schemas/auth.py
index 8506d6d..60a8983 100644
--- a/backend/app/schemas/auth.py
+++ b/backend/app/schemas/auth.py
@@ -1,35 +1,72 @@
-from pydantic import BaseModel, Field, field_validator
+from datetime import datetime
+from typing import Literal
-PASSWORD_MAX_BYTES = 72 # bcrypt не принимает пароли длиннее
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+PASSWORD_MAX_BYTES = 72
+PASSWORD_MIN = 12
-class LoginIn(BaseModel):
- email: str = Field(max_length=254, pattern=r"^[^@\s]+@[^@\s]+\.[^@\s]+$", examples=["operator@example.com"])
- password: str = Field(min_length=1)
- @field_validator("email", mode="before")
- @classmethod
- def normalize_email(cls, value):
- return value.strip().lower() if isinstance(value, str) else value
+class PasswordIn(BaseModel):
+ model_config = ConfigDict(extra="forbid")
+ password: str = Field(min_length=1, max_length=72, repr=False)
- @field_validator("password")
+ @field_validator("password", mode="before")
@classmethod
def fits_bcrypt(cls, value: str) -> str:
- if len(value.encode()) > PASSWORD_MAX_BYTES:
- raise ValueError(f"пароль длиннее {PASSWORD_MAX_BYTES} байт")
+ if not isinstance(value, str):
+ return value
+ if len(value.encode("utf-8")) > PASSWORD_MAX_BYTES:
+ size = 0
+ limit = 0
+ for character in value:
+ size += len(character.encode("utf-8"))
+ if size > PASSWORD_MAX_BYTES:
+ break
+ limit += 1
+ raise ValueError(f"Пароль слишком длинный. Сократите его до {limit} символов.")
return value
-class RegisterIn(LoginIn):
- password: str = Field(min_length=8, description="От 8 символов, не длиннее 72 байт в UTF-8")
+class LoginIn(PasswordIn):
+ login: str = Field(min_length=3, max_length=64, pattern=r"^[a-z0-9._-]+$")
+
+ @field_validator("login", mode="before")
+ @classmethod
+ def normalize_login(cls, value):
+ if not isinstance(value, str):
+ return value
+ value = value.strip()
+ if not value.isascii():
+ raise ValueError("В логине разрешены только латинские буквы, цифры, точка, дефис и подчёркивание")
+ return value.lower()
+
+
+class CreateUserIn(LoginIn):
+ password: str = Field(min_length=PASSWORD_MIN, max_length=72, repr=False)
+
+
+class ResetPasswordIn(PasswordIn):
+ password: str = Field(min_length=PASSWORD_MIN, max_length=72, repr=False)
+
+
+class SetActiveIn(BaseModel):
+ model_config = ConfigDict(extra="forbid")
+ is_active: bool = Field(strict=True)
class UserOut(BaseModel):
id: int
- email: str
+ login: str
+ role: Literal["admin", "employee"]
+ is_active: bool
+
+
+class ManagedUserOut(UserOut):
+ created_at: datetime
class AuthOut(BaseModel):
- access_token: str = Field(description="JWT для заголовка Authorization: Bearer")
+ access_token: str
token_type: str = "bearer"
user: UserOut
diff --git a/backend/app/services/auth_service.py b/backend/app/services/auth_service.py
index b826dbf..b565820 100644
--- a/backend/app/services/auth_service.py
+++ b/backend/app/services/auth_service.py
@@ -1,31 +1,30 @@
from sqlalchemy import Connection, select
from sqlalchemy.dialects.postgresql import insert
-from app.core.security import hash_password, verify_password
+from app.core.security import DUMMY_HASH, hash_password, verify_password
from app.models.users import User
+PUBLIC_COLUMNS = (User.id, User.login, User.role, User.is_active, User.created_at)
-def create_user(db: Connection, email: str, password: str) -> dict | None:
- """Новый пользователь; None, если email уже занят."""
- query = (
- insert(User)
- .values(email=email, password_hash=hash_password(password))
- .on_conflict_do_nothing(index_elements=[User.email])
- .returning(User.id, User.email)
- )
- row = db.execute(query).mappings().first()
+
+def create_user(db: Connection, login: str, password: str, *, role: str = "employee") -> dict | None:
+ row = db.execute(insert(User).values(login=login, password_hash=hash_password(password), role=role)
+ .on_conflict_do_nothing(index_elements=[User.login])
+ .returning(*PUBLIC_COLUMNS)).mappings().first()
db.commit()
return dict(row) if row else None
-def authenticate(db: Connection, email: str, password: str) -> dict | None:
- query = select(User.id, User.email, User.password_hash).where(User.email == email)
- row = db.execute(query).mappings().first()
- if row is None or not verify_password(password, row["password_hash"]):
+def authenticate(db: Connection, login: str, password: str) -> dict | None:
+ row = db.execute(select(*PUBLIC_COLUMNS, User.password_hash, User.token_version)
+ .where(User.login == login)).mappings().first()
+ # Always run bcrypt, including unknown logins and disabled accounts.
+ valid = verify_password(password, row["password_hash"] if row else DUMMY_HASH)
+ if row is None or not valid or not row["is_active"]:
return None
- return {"id": row["id"], "email": row["email"]}
+ return {key: value for key, value in row.items() if key != "password_hash"}
def get_user(db: Connection, user_id: int) -> dict | None:
- row = db.execute(select(User.id, User.email).where(User.id == user_id)).mappings().first()
+ row = db.execute(select(*PUBLIC_COLUMNS, User.token_version).where(User.id == user_id)).mappings().first()
return dict(row) if row else None
diff --git a/backend/main.py b/backend/main.py
index b687a2a..e94f6c1 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -1,18 +1,29 @@
-from app.api import alerts, auth, equipment, predict
+from app.api import alerts, auth, equipment, predict, users
from app.api.auth import UNAUTHORIZED, get_current_user
from app.core.config import CORS_ORIGINS
from fastapi import Depends, FastAPI
+from fastapi.exceptions import RequestValidationError
from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
app = FastAPI(title="OFF-Tech: оценка состояния оборудования", version="0.1.0")
app.add_middleware(CORSMiddleware, allow_origins=CORS_ORIGINS,
allow_methods=["*"], allow_headers=["*"])
-# Данные — только с токеном; /auth/register и /auth/login открыты.
+# Данные — только с токеном; публичный вход только через /auth/login.
PROTECTED = [Depends(get_current_user)]
app.include_router(auth.router)
app.include_router(equipment.router, dependencies=PROTECTED, responses=UNAUTHORIZED)
app.include_router(alerts.router, dependencies=PROTECTED, responses=UNAUTHORIZED)
app.include_router(predict.router, dependencies=PROTECTED, responses=UNAUTHORIZED)
+
+app.include_router(users.router)
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_error_handler(request, exc):
+ # Default validation responses echo submitted values, including passwords.
+ errors = [{"loc": error["loc"], "msg": error["msg"], "type": error["type"]} for error in exc.errors()]
+ return JSONResponse(status_code=422, content={"detail": errors})
diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py
index 5410b7c..39d29d9 100644
--- a/backend/tests/conftest.py
+++ b/backend/tests/conftest.py
@@ -13,7 +13,7 @@
os.environ["RUL_CLIP"] = "125"
os.environ["JWT_SECRET"] = "test-secret-for-pytest-only-0123456789"
-TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users"
+TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users, login_attempts"
@pytest.fixture
@@ -40,7 +40,7 @@ def client(db):
from app.models import User
from main import app
- statement = insert(User).values(email="operator@example.com", password_hash="-").returning(User.id)
+ statement = insert(User).values(login="operator", password_hash="-").returning(User.id)
user_id = db.execute(statement).scalar_one()
db.commit()
return TestClient(app, headers={"Authorization": f"Bearer {create_token(user_id)}"})
@@ -88,3 +88,29 @@ def add(equipment_id: int, cycle: int) -> dict[str, float]:
return sensors
return add
+
+
+@pytest.fixture(scope="session")
+def password_hash():
+ from app.core.security import hash_password
+ return hash_password("Correct-pass 123!")
+
+
+@pytest.fixture
+def account(db, password_hash):
+ from app.models import User
+
+ def add(login="worker", role="employee", is_active=True):
+ row = db.execute(insert(User).values(login=login, role=role, is_active=is_active,
+ password_hash=password_hash).returning(User.id)).scalar_one()
+ db.commit()
+ return row
+ return add
+
+
+@pytest.fixture
+def admin_client(db, account):
+ from app.core.security import create_token
+ from main import app
+ user_id = account("administrator", "admin")
+ return TestClient(app, headers={"Authorization": f"Bearer {create_token(user_id)}"})
diff --git a/backend/tests/test_auth.py b/backend/tests/test_auth.py
index d81b24b..ab9d68b 100644
--- a/backend/tests/test_auth.py
+++ b/backend/tests/test_auth.py
@@ -1,131 +1,232 @@
import re
+from concurrent.futures import ThreadPoolExecutor
from datetime import UTC, datetime, timedelta
import bcrypt
import jwt
import pytest
from fastapi.routing import APIRoute
-from sqlalchemy import text
+from sqlalchemy import insert, select, text, update
-OPEN_PATHS = {"/auth/register", "/auth/login", "/health"}
-CREDENTIALS = {"email": "operator@example.com", "password": "correct-horse"}
+PASSWORD = "Correct-pass 123!"
-def protected_routes() -> list[tuple[str, str]]:
+def protected_routes():
from main import app
+ return sorted((method, re.sub(r"\{[^}]+\}", "1", route.path))
+ for route in app.routes if isinstance(route, APIRoute) and route.path != "/auth/login"
+ for method in route.methods)
- return sorted(
- (method, re.sub(r"\{[^}]+\}", "1", route.path))
- for route in app.routes
- if isinstance(route, APIRoute) and route.path not in OPEN_PATHS
- for method in route.methods
- )
-
-def bearer(token: str) -> dict[str, str]:
+def bearer(token):
return {"Authorization": f"Bearer {token}"}
-def test_register_returns_working_token(anon_client):
- response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": " Operator@Example.COM "})
-
- assert response.status_code == 201
- body = response.json()
- assert body["token_type"] == "bearer"
- assert body["user"]["email"] == "operator@example.com"
-
- me = anon_client.get("/auth/me", headers=bearer(body["access_token"]))
- assert me.status_code == 200
- assert me.json() == body["user"]
-
-
-def test_password_is_stored_as_bcrypt_hash(anon_client, db):
- anon_client.post("/auth/register", json=CREDENTIALS)
-
- stored = db.execute(text("SELECT password_hash FROM users")).scalar_one()
-
- assert CREDENTIALS["password"] not in stored
- assert bcrypt.checkpw(CREDENTIALS["password"].encode(), stored.encode())
-
-
-def test_register_same_email_conflicts(anon_client):
- assert anon_client.post("/auth/register", json=CREDENTIALS).status_code == 201
-
- response = anon_client.post("/auth/register", json={**CREDENTIALS, "email": "OPERATOR@example.com"})
-
- assert response.status_code == 409
-
+def sign_in(client, login="worker", password=PASSWORD):
+ return client.post("/auth/login", json={"login": login, "password": password})
-@pytest.mark.parametrize("payload", [
- {"email": "not-an-email", "password": "correct-horse"},
- {"email": "operator@example.com", "password": "short"},
- {"email": "operator@example.com", "password": "я" * 37}, # 74 байта — больше лимита bcrypt
- {"email": "operator@example.com"},
-])
-def test_register_validates_input(anon_client, payload):
- assert anon_client.post("/auth/register", json=payload).status_code == 422
-
-def test_login_returns_working_token(anon_client):
- anon_client.post("/auth/register", json=CREDENTIALS)
-
- response = anon_client.post("/auth/login", json={**CREDENTIALS, "email": "Operator@example.com"})
-
- assert response.status_code == 200
- assert anon_client.get("/equipment", headers=bearer(response.json()["access_token"])).status_code == 200
-
-
-@pytest.mark.parametrize("credentials", [
- {**CREDENTIALS, "password": "wrong-password"},
- {**CREDENTIALS, "email": "nobody@example.com"},
-])
-def test_login_rejects_wrong_credentials(anon_client, credentials):
- anon_client.post("/auth/register", json=CREDENTIALS)
-
- response = anon_client.post("/auth/login", json=credentials)
-
- assert response.status_code == 401
- assert response.json()["detail"] == "Неверный email или пароль"
+def test_public_registration_removed(anon_client):
+ assert anon_client.post("/auth/register", json={"login": "worker", "password": PASSWORD}).status_code == 404
+ assert "/auth/register" not in anon_client.get("/openapi.json").json()["paths"]
@pytest.mark.parametrize(("method", "path"), protected_routes())
-def test_api_requires_token(anon_client, method, path):
+def test_every_api_requires_token(anon_client, method, path):
response = anon_client.request(method, path)
-
assert response.status_code == 401
assert response.headers["WWW-Authenticate"] == "Bearer"
-def test_protected_routes_cover_api():
- routes = protected_routes()
+@pytest.mark.parametrize(("method", "path"), [(method, path) for method, path in protected_routes()
+ if path.startswith("/admin/")])
+def test_employee_cannot_use_admin_api(client, method, path):
+ assert client.request(method, path, json={"login": "intruder", "password": PASSWORD,
+ "is_active": False}).status_code == 403
- assert ("GET", "/equipment") in routes
- assert ("GET", "/auth/me") in routes
-
-def test_signed_in_client_reaches_api(client):
- assert client.get("/equipment").status_code == 200
- assert client.get("/auth/me").json()["email"] == "operator@example.com"
+def test_create_and_login(admin_client, anon_client, db):
+ response = admin_client.post("/admin/users", json={"login": " Ivan.Petrov ", "password": PASSWORD})
+ assert response.status_code == 201
+ user = response.json()
+ assert user["login"] == "ivan.petrov" and user["role"] == "employee" and user["is_active"]
+ assert "password_hash" not in user and "password" not in user
+ hashed = db.execute(text("SELECT password_hash FROM users WHERE id=:id"), {"id": user["id"]}).scalar_one()
+ assert hashed != PASSWORD and bcrypt.checkpw(PASSWORD.encode(), hashed.encode())
+ login = sign_in(anon_client, "IVAN.PETROV")
+ assert login.status_code == 200
+ token = login.json()["access_token"]
+ assert anon_client.get("/auth/me", headers=bearer(token)).json()["login"] == "ivan.petrov"
+ assert anon_client.get("/equipment", headers=bearer(token)).status_code == 200
+ assert anon_client.get("/alerts", headers=bearer(token)).status_code == 200
+ assert anon_client.get("/admin/users", headers=bearer(token)).status_code == 403
+
+
+def test_admin_can_use_working_sections(admin_client, add_equipment, add_prediction, add_reading):
+ equipment_id = add_equipment()
+ add_reading(equipment_id, 1)
+ add_prediction(equipment_id, 1, 100)
+ for path in ("/equipment", f"/equipment/{equipment_id}", f"/equipment/{equipment_id}/history",
+ f"/equipment/{equipment_id}/forecast", "/alerts", "/auth/me", "/admin/users"):
+ assert admin_client.get(path).status_code == 200, path
+ assert admin_client.get("/auth/me").json()["role"] == "admin"
+
+
+def test_duplicate_login_normalization(admin_client):
+ assert admin_client.post("/admin/users", json={"login": "Employee", "password": PASSWORD}).status_code == 201
+ assert admin_client.post("/admin/users", json={"login": " employee ", "password": PASSWORD}).status_code == 409
+
+
+@pytest.mark.parametrize("login", ["", "ab", "a" * 65, "иван", "a b", "a@b.com", "adm\nin", "Kelvin", "foo/bar"])
+def test_invalid_logins(admin_client, login):
+ assert admin_client.post("/admin/users", json={"login": login, "password": PASSWORD}).status_code == 422
+
+
+@pytest.mark.parametrize("password", ["Qx7!", "я" * 37, "a" * 73])
+def test_invalid_passwords_never_echoed(admin_client, password):
+ response = admin_client.post("/admin/users", json={"login": "worker", "password": password})
+ assert response.status_code == 422
+ assert password not in response.text
+ assert all("input" not in error for error in response.json()["detail"])
+
+
+def test_password_preserves_spaces_case_and_symbols(admin_client, anon_client):
+ password = " My Str0ng! Пароль "
+ assert admin_client.post("/admin/users", json={"login": "worker", "password": password}).status_code == 201
+ assert sign_in(anon_client, password=password).status_code == 200
+ assert sign_in(anon_client, password=password.strip()).status_code == 401
+ assert sign_in(anon_client, password=password.lower()).status_code == 401
+
+
+def test_cannot_inject_admin_role(admin_client, db):
+ response = admin_client.post("/admin/users", json={"login": "worker", "password": PASSWORD, "role": "admin"})
+ assert response.status_code == 422
+ assert db.execute(text("SELECT count(*) FROM users WHERE login='worker'")).scalar_one() == 0
+
+
+def test_bad_credentials_and_blocked_users_look_same(anon_client, account):
+ account()
+ account("disabled", is_active=False)
+ responses = [sign_in(anon_client, login, password) for login, password in
+ [("worker", "wrong"), ("missing", PASSWORD), ("disabled", PASSWORD)]]
+ assert all(response.status_code == 401 for response in responses)
+ assert all(response.json() == {"detail": "Неверный логин или пароль"} for response in responses)
+
+
+def test_reset_invalidates_all_old_tokens(admin_client, anon_client, account):
+ user_id = account()
+ old_tokens = [sign_in(anon_client).json()["access_token"] for _ in range(2)]
+ response = admin_client.put(f"/admin/users/{user_id}/password", json={"password": "New password 456!"})
+ assert response.status_code == 204
+ assert sign_in(anon_client).status_code == 401
+ for token in old_tokens:
+ assert anon_client.get("/equipment", headers=bearer(token)).status_code == 401
+ new_token = sign_in(anon_client, password="New password 456!").json()["access_token"]
+ assert anon_client.get("/equipment", headers=bearer(new_token)).status_code == 200
+
+
+def test_block_unblock_does_not_revive_token(admin_client, anon_client, account):
+ user_id = account()
+ old_token = sign_in(anon_client).json()["access_token"]
+ assert admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": False}).status_code == 200
+ assert sign_in(anon_client).status_code == 401
+ assert anon_client.get("/equipment", headers=bearer(old_token)).status_code == 401
+ assert admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": True}).status_code == 200
+ assert anon_client.get("/equipment", headers=bearer(old_token)).status_code == 401
+ assert sign_in(anon_client).status_code == 200
+
+
+def test_reset_does_not_unblock(admin_client, anon_client, account):
+ user_id = account(is_active=False)
+ assert admin_client.put(f"/admin/users/{user_id}/password", json={"password": "New password 456!"}).status_code == 204
+ assert sign_in(anon_client, password="New password 456!").status_code == 401
+
+
+def test_admin_accounts_cannot_be_modified_from_panel(admin_client):
+ user_id = admin_client.get("/auth/me").json()["id"]
+ assert admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": False}).status_code == 403
+ assert admin_client.put(f"/admin/users/{user_id}/password", json={"password": PASSWORD}).status_code == 403
+ assert admin_client.get("/admin/users").status_code == 200
+
+
+def test_missing_account(admin_client):
+ assert admin_client.put("/admin/users/999/password", json={"password": PASSWORD}).status_code == 404
+ assert admin_client.put("/admin/users/999/status", json={"is_active": False}).status_code == 404
-def _token(secret: str, sub: str = "1", minutes: int = 5) -> str:
- expires = datetime.now(UTC) + timedelta(minutes=minutes)
- return jwt.encode({"sub": sub, "exp": expires}, secret, algorithm="HS256")
+def test_role_loaded_from_database(admin_client, db):
+ from app.models import User
+ user_id = admin_client.get("/auth/me").json()["id"]
+ db.execute(update(User).where(User.id == user_id).values(role="employee"))
+ db.commit()
+ assert admin_client.get("/admin/users").status_code == 403
+ assert admin_client.get("/equipment").status_code == 200
-def test_rejects_bad_tokens(client):
+def test_bad_and_legacy_tokens(anon_client, account):
from app.core.config import JWT_SECRET
-
- user_token = client.headers["Authorization"].removeprefix("Bearer ")
- user_id = jwt.decode(user_token, JWT_SECRET, algorithms=["HS256"])["sub"]
- bad = {
- "garbage": bearer("garbage"),
- "foreign secret": bearer(_token("another-secret-another-secret-0123", user_id)),
- "expired": bearer(_token(JWT_SECRET, user_id, minutes=-1)),
- "unknown user": bearer(_token(JWT_SECRET, "999")),
- "basic scheme": {"Authorization": f"Basic {user_token}"},
- }
-
- for name, headers in bad.items():
- response = client.get("/equipment", headers=headers)
- assert response.status_code == 401, name
+ user_id = account()
+ payload = {"sub": str(user_id), "ver": 0, "iat": datetime.now(UTC), "exp": datetime.now(UTC) + timedelta(minutes=5)}
+ tokens = ["garbage", jwt.encode(payload, "different-secret-for-test-0000000", algorithm="HS256"),
+ jwt.encode({**payload, "exp": datetime.now(UTC) - timedelta(minutes=1)}, JWT_SECRET, algorithm="HS256"),
+ jwt.encode({**payload, "sub": "999"}, JWT_SECRET, algorithm="HS256"),
+ jwt.encode({k: v for k, v in payload.items() if k != "ver"}, JWT_SECRET, algorithm="HS256"),
+ jwt.encode({**payload, "ver": True}, JWT_SECRET, algorithm="HS256")]
+ for token in tokens:
+ assert anon_client.get("/equipment", headers=bearer(token)).status_code == 401
+
+
+def test_login_throttle_and_expiry(anon_client, db):
+ from app.core.login_throttle import LOGIN_LIMIT
+ for _ in range(LOGIN_LIMIT):
+ assert sign_in(anon_client, password="wrong").status_code == 401
+ blocked = sign_in(anon_client, "WORKER", "wrong")
+ assert blocked.status_code == 429 and int(blocked.headers["Retry-After"]) > 0
+ db.execute(text("UPDATE login_attempts SET expires_at=now() - interval '1 second'"))
+ db.commit()
+ assert sign_in(anon_client, password="wrong").status_code == 401
+
+
+def test_ip_limit_even_for_different_logins(anon_client, db):
+ from app.core.login_throttle import IP_LIMIT
+ from app.core.security import throttle_key
+ from app.models.users import LoginAttempt
+ db.execute(insert(LoginAttempt).values(key=throttle_key("ip", "testclient"), count=IP_LIMIT,
+ expires_at=datetime.now(UTC) + timedelta(minutes=10)))
+ db.commit()
+ assert sign_in(anon_client, "another").status_code == 429
+
+
+def test_concurrent_duplicate_creation(admin_client, db):
+ def create(_):
+ return admin_client.post("/admin/users", json={"login": "concurrent", "password": PASSWORD}).status_code
+ with ThreadPoolExecutor(max_workers=2) as pool:
+ assert sorted(pool.map(create, range(2))) == [201, 409]
+ assert db.execute(text("SELECT count(*) FROM users WHERE login='concurrent'")).scalar_one() == 1
+
+
+def test_concurrent_reset_and_block_preserve_both_changes(admin_client, account, db):
+ from app.models import User
+ user_id = account()
+ def reset():
+ return admin_client.put(f"/admin/users/{user_id}/password", json={"password": "New password 456!"}).status_code
+ def block():
+ return admin_client.put(f"/admin/users/{user_id}/status", json={"is_active": False}).status_code
+ with ThreadPoolExecutor(max_workers=2) as pool:
+ futures = [pool.submit(reset), pool.submit(block)]
+ assert [future.result() for future in futures] == [204, 200]
+ user = db.execute(select(User).where(User.id == user_id)).mappings().one()
+ assert not user["is_active"] and user["token_version"] == 2
+ assert bcrypt.checkpw(b"New password 456!", user["password_hash"].encode())
+
+
+def test_admin_cli(monkeypatch, anon_client, db):
+ from app import create_admin
+ monkeypatch.setattr("builtins.input", lambda _: "Bootstrap.Admin")
+ monkeypatch.setattr(create_admin, "getpass", lambda _: PASSWORD)
+ create_admin.main()
+ login = sign_in(anon_client, "bootstrap.admin")
+ assert login.status_code == 200 and login.json()["user"]["role"] == "admin"
+ with pytest.raises(SystemExit, match="Логин уже занят"):
+ create_admin.main()
+ assert db.execute(text("SELECT count(*) FROM users")).scalar_one() == 1
diff --git a/docker-compose.yml b/docker-compose.yml
index 26f1c6a..dd67d2f 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -25,7 +25,7 @@ services:
build: ./backend
<<: *app-env
ports:
- - "8000:8000"
+ - "${BACKEND_PORT:-8000}:8000"
depends_on:
db:
condition: service_healthy
@@ -76,7 +76,7 @@ services:
frontend:
build: ./frontend
ports:
- - "5173:80"
+ - "${FRONTEND_PORT:-5173}:80"
depends_on:
backend:
condition: service_healthy
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 564e879..5202fe2 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -1,56 +1,71 @@
-import { Navigate, NavLink, Outlet, Route, Routes, useLocation } from "react-router-dom";
+import { useEffect, useState } from "react";
+import { Navigate, NavLink, Outlet, Route, Routes } from "react-router-dom";
+import { api } from "./api";
import { Alerts } from "./pages/Alerts";
import { AuthPage } from "./pages/Auth";
+import { Users } from "./pages/Users";
import { EquipmentCard } from "./pages/EquipmentCard";
import { EquipmentList } from "./pages/EquipmentList";
-import { setSession, useSession } from "./session";
+import { getToken, setSession, useSession } from "./session";
export function App() {
const session = useSession();
+ const token = session?.token;
+ const [verifiedToken, setVerifiedToken] = useState(null);
+ const [error, setError] = useState("");
+ const [retry, setRetry] = useState(0);
- return (
- <>
-
+ useEffect(() => {
+ let cancelled = false;
+ setError("");
+ if (!token) { setVerifiedToken(null); return; }
+ // Check the stored session with the server before rendering protected pages.
+ api.me().then(user => {
+ if (cancelled || getToken() !== token) return;
+ setSession({ token, login: user.login, role: user.role });
+ setVerifiedToken(token);
+ }).catch(() => {
+ if (!cancelled && getToken() === token) setError("Не удалось проверить сессию. Проверьте соединение с сервером.");
+ });
+ return () => { cancelled = true; };
+ }, [token, retry]);
-
-
- } />
- } />
- }>
- } />
- } />
- } />
- Страница не найдена} />
-
-
-
- >
- );
+ if (token && verifiedToken !== token) return
+ {error ? {error}
+
+ : Проверяем сессию…
}
+ ;
+
+ return <>
+
+
+
+ } />
+ }>
+ } />
+ } />
+ } />
+ : } />
+
+ Страница не найдена} />
+
+
+ >;
}
function RequireAuth() {
- const session = useSession();
- const location = useLocation();
-
- if (!session) return ;
- return ;
+ return useSession() ? : ;
}
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index 6572e7a..aad576f 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -53,7 +53,13 @@ export interface Alert {
export interface User {
id: number;
- email: string;
+ login: string;
+ role: "admin" | "employee";
+ is_active: boolean;
+}
+
+export interface ManagedUser extends User {
+ created_at: string;
}
export interface AuthResponse {
@@ -87,10 +93,11 @@ async function request(path: string, init?: RequestInit): Promise {
try {
const body = await res.json();
if (typeof body.detail === "string") detail = body.detail;
- else if (Array.isArray(body.detail)) detail = body.detail.map((d: { msg: string }) => d.msg).join("; ");
+ else if (Array.isArray(body.detail)) detail = body.detail.map((d: { msg: string }) => d.msg.replace(/^Value error, /, "")).join("; ");
} catch {}
throw new ApiError(res.status, detail);
}
+ if (res.status === 204) return undefined as T;
return res.json() as Promise;
}
@@ -106,7 +113,13 @@ export const api = {
listAlerts: (limit = 100) => request(`/alerts?limit=${limit}`),
alertsByEquipment: (id: number, limit = 50) => request(`/alerts/${id}?limit=${limit}`),
predict: (id: number) => request("/predict", postJson({ equipment_id: id })),
- login: (email: string, password: string) => request("/auth/login", postJson({ email, password })),
- register: (email: string, password: string) =>
- request("/auth/register", postJson({ email, password })),
+ login: (login: string, password: string) => request("/auth/login", postJson({ login, password })),
+ me: () => request("/auth/me"),
+ listUsers: (offset = 0) => request(`/admin/users?limit=50&offset=${offset}`),
+ createUser: (login: string, password: string) =>
+ request("/admin/users", postJson({ login, password })),
+ resetPassword: (id: number, password: string) =>
+ request(`/admin/users/${id}/password`, { ...postJson({ password }), method: "PUT" }),
+ setUserActive: (id: number, is_active: boolean) =>
+ request(`/admin/users/${id}/status`, { ...postJson({ is_active }), method: "PUT" }),
};
diff --git a/frontend/src/components/PasswordField.tsx b/frontend/src/components/PasswordField.tsx
new file mode 100644
index 0000000..a777a0a
--- /dev/null
+++ b/frontend/src/components/PasswordField.tsx
@@ -0,0 +1,22 @@
+import { type InputHTMLAttributes, useId, useState } from "react";
+
+type PasswordFieldProps = Omit, "type" | "id"> & {
+ label: string;
+};
+
+export function PasswordField({ label, ...inputProps }: PasswordFieldProps) {
+ const id = useId();
+ const [visible, setVisible] = useState(false);
+
+ return
+
+
+
+
+
+
;
+}
diff --git a/frontend/src/index.css b/frontend/src/index.css
index fd4a7fa..734501d 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -258,7 +258,7 @@ h2 {
color: #d1d5db;
font-size: 14px;
}
-.user-email {
+.user-login {
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
@@ -298,3 +298,37 @@ h2 {
.auth .muted {
text-align: center;
}
+
+.account-form { max-width: 600px; margin: 20px 0; }
+.account-form form, .account-form label { display: flex; flex-direction: column; gap: 8px; }
+.account-form form { margin-top: 16px; gap: 16px; }
+.account-form input { padding: 10px; border: 1px solid #d1d5db; border-radius: 6px; font: inherit; }
+.account-form input:focus { outline: 2px solid #93c5fd; }
+.actions { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
+.success { padding: 12px; color: #166534; background: #dcfce7; border-radius: 6px; }
+.table-scroll { overflow-x: auto; margin-top: 20px; }
+.pagination { margin-top: 16px; }
+@media (max-width: 720px) {
+ .header { height: auto; min-height: 56px; flex-wrap: wrap; gap: 12px; padding: 12px; }
+ .header nav { flex-wrap: wrap; }
+ .main { padding: 16px; }
+ .page-head { gap: 12px; flex-wrap: wrap; }
+}
+
+.password-field { display: flex; flex-direction: column; gap: 6px; }
+.password-control { display: flex; align-items: stretch; gap: 8px; }
+.password-control input { flex: 1; width: 0; min-width: 0; }
+.password-toggle {
+ flex-shrink: 0;
+ padding: 8px 12px;
+ border: 1px solid #d1d5db;
+ border-radius: 6px;
+ background: #f9fafb;
+ color: #374151;
+ font: inherit;
+ font-size: 14px;
+ cursor: pointer;
+}
+.password-toggle:hover { background: #e5e7eb; }
+.password-toggle:focus-visible { outline: 2px solid #2563eb; outline-offset: 2px; }
+.password-toggle:disabled { opacity: 0.6; cursor: default; }
diff --git a/frontend/src/pages/Auth.tsx b/frontend/src/pages/Auth.tsx
index fc51e61..381c522 100644
--- a/frontend/src/pages/Auth.tsx
+++ b/frontend/src/pages/Auth.tsx
@@ -1,97 +1,42 @@
import { type FormEvent, useState } from "react";
-import { Link, Navigate, useLocation } from "react-router-dom";
+import { Navigate } from "react-router-dom";
import { ApiError, api } from "../api";
+import { PasswordField } from "../components/PasswordField";
import { setSession, useSession } from "../session";
-const PASSWORD_MIN = 8;
-const PASSWORD_MAX_BYTES = 72;
-
-const MODES = {
- login: {
- title: "Вход",
- submit: "Войти",
- send: api.login,
- other: { question: "Нет аккаунта?", link: "Зарегистрироваться", to: "/register" },
- },
- register: {
- title: "Регистрация",
- submit: "Зарегистрироваться",
- send: api.register,
- other: { question: "Уже есть аккаунт?", link: "Войти", to: "/login" },
- },
-};
-
-export function AuthPage({ mode }: { mode: keyof typeof MODES }) {
+export function AuthPage() {
const session = useSession();
- const location = useLocation();
const [error, setError] = useState(null);
const [busy, setBusy] = useState(false);
- const page = MODES[mode];
- const register = mode === "register";
- if (session) {
- const from = (location.state as { from?: string } | null)?.from ?? "/";
- return ;
- }
+ if (session) return ;
- async function onSubmit(e: FormEvent) {
- e.preventDefault();
- const form = new FormData(e.currentTarget);
- const email = String(form.get("email"));
+ async function onSubmit(event: FormEvent) {
+ event.preventDefault();
+ const form = new FormData(event.currentTarget);
+ const login = String(form.get("login"));
const password = String(form.get("password"));
- if (register && password !== form.get("confirm")) return setError("Пароли не совпадают");
- if (register && new TextEncoder().encode(password).length > PASSWORD_MAX_BYTES) {
- return setError(`Пароль слишком длинный: не больше ${PASSWORD_MAX_BYTES} байт`);
- }
-
setBusy(true);
setError(null);
try {
- const res = await page.send(email, password);
- setSession({ token: res.access_token, email: res.user.email });
+ const res = await api.login(login, password);
+ setSession({ token: res.access_token, login: res.user.login, role: res.user.role });
} catch (err) {
setError(err instanceof ApiError ? err.detail : "Нет связи с сервером");
+ } finally {
setBusy(false);
}
}
- return (
-
- {page.title}
-
-
- {page.other.question}{" "}
-
- {page.other.link}
-
-
-
- );
+ return
+ Вход
+
+ Для получения аккаунта или сброса пароля обратитесь к администратору.
+ ;
}
diff --git a/frontend/src/pages/Users.tsx b/frontend/src/pages/Users.tsx
new file mode 100644
index 0000000..d78c8e3
--- /dev/null
+++ b/frontend/src/pages/Users.tsx
@@ -0,0 +1,131 @@
+import { type FormEvent, useEffect, useState } from "react";
+import { api, ApiError, type ManagedUser } from "../api";
+
+import { PasswordField } from "../components/PasswordField";
+
+const PAGE_SIZE = 50;
+const PASSWORD_HINT = "От 12 символов.";
+function message(error: unknown) {
+ return error instanceof ApiError ? error.detail : "Нет связи с сервером";
+}
+
+export function Users() {
+ const [users, setUsers] = useState([]);
+ const [offset, setOffset] = useState(0);
+ const [loading, setLoading] = useState(true);
+ const [reload, setReload] = useState(0);
+ const [error, setError] = useState("");
+ const [notice, setNotice] = useState("");
+ const [busy, setBusy] = useState(false);
+ const [editing, setEditing] = useState(null);
+ const [statusTarget, setStatusTarget] = useState(null);
+
+ useEffect(() => {
+ let cancelled = false;
+ setLoading(true);
+ setError("");
+ api.listUsers(offset).then(rows => { if (!cancelled) setUsers(rows); })
+ .catch(err => { if (!cancelled) setError(message(err)); })
+ .finally(() => { if (!cancelled) setLoading(false); });
+ return () => { cancelled = true; };
+ }, [offset, reload]);
+
+ async function save(event: FormEvent) {
+ event.preventDefault();
+ const form = new FormData(event.currentTarget);
+ const password = String(form.get("password"));
+ if (password !== form.get("confirm")) { setError("Пароли не совпадают"); return; }
+ if (new TextEncoder().encode(password).length > 72) {
+ let bytes = 0;
+ let limit = 0;
+ for (const character of password) {
+ bytes += new TextEncoder().encode(character).length;
+ if (bytes > 72) break;
+ limit++;
+ }
+ setError(`Пароль слишком длинный. Сократите его до ${limit} символов.`);
+ return;
+ }
+ if (!editing) return;
+ setBusy(true); setError(""); setNotice("");
+ try {
+ if (editing === "new") {
+ const user = await api.createUser(String(form.get("login")), password);
+ setNotice(`Пользователь ${user.login} создан.`);
+ } else {
+ await api.resetPassword(editing.id, password);
+ setNotice(`Пароль пользователя ${editing.login} изменён.`);
+ }
+ setEditing(null); // Unmount the form and discard password values.
+ setReload(n => n + 1);
+ } catch (err) { setError(message(err)); }
+ finally { setBusy(false); }
+ }
+
+ async function changeStatus() {
+ if (!statusTarget) return;
+ setBusy(true); setError(""); setNotice("");
+ try {
+ const user = await api.setUserActive(statusTarget.id, !statusTarget.is_active);
+ setNotice(user.is_active ? `Пользователь ${user.login} разблокирован.`
+ : `Пользователь ${user.login} заблокирован.`);
+ setStatusTarget(null); setReload(n => n + 1);
+ } catch (err) { setError(message(err)); }
+ finally { setBusy(false); }
+ }
+
+ return <>
+ Пользователи
+
+
+ {error && {error}
}
+ {notice && {notice}
}
+ {editing && }
+ {statusTarget &&
+ {statusTarget.is_active ? "Заблокировать" : "Разблокировать"} {statusTarget.login}?
+ {statusTarget.is_active ? "Пользователь потеряет доступ к системе."
+ : "Пользователь снова сможет войти с текущим паролем."}
+
+
+ }
+ {loading ? Загружаем пользователей…
: <>
+
+ | Логин | Роль | Состояние | Действия |
+ {users.map(user =>
+ | {user.login} | {user.role === "admin" ? "Администратор" : "Пользователь"} |
+ {user.is_active ? "Активен" : "Заблокирован"} |
+ {user.role === "employee" ?
+
+
+ : Управление через сервер} |
+
)}
+
+ {users.length === 0 && На этой странице нет аккаунтов.
}
+ >}
+
+
+ Страница {offset / PAGE_SIZE + 1}
+
+
+
+ >;
+}
diff --git a/frontend/src/session.ts b/frontend/src/session.ts
index bd7fa76..8338730 100644
--- a/frontend/src/session.ts
+++ b/frontend/src/session.ts
@@ -2,7 +2,8 @@ import { useSyncExternalStore } from "react";
export interface Session {
token: string;
- email: string;
+ login: string;
+ role: "admin" | "employee";
}
const KEY = "offtech.session";
@@ -11,7 +12,7 @@ const listeners = new Set<() => void>();
function read(): Session | null {
try {
const value = JSON.parse(localStorage.getItem(KEY) ?? "null");
- return typeof value?.token === "string" && typeof value?.email === "string" ? value : null;
+ return typeof value?.token === "string" && typeof value?.login === "string" && (value.role === "admin" || value.role === "employee") ? value : null;
} catch {
return null;
}
From 15b9f2b187aa273569c6d4c7914ac4925b80c204 Mon Sep 17 00:00:00 2001
From: mqudiee
Date: Wed, 11 Nov 2026 03:37:48 +0300
Subject: [PATCH 3/3] ci: rerun checks with updated PR description