diff --git a/.env.example b/.env.example index ecde501..06e852b 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 @@ -14,3 +16,6 @@ WEATHER_LATITUDE=55.7558 WEATHER_LONGITUDE=37.6173 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 26ca58c..3329582 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -74,6 +74,12 @@ jobs: working-directory: backend run: alembic check + - name: Test backend including authorization and physics + working-directory: backend + env: + TEST_DATABASE_URL: postgresql+psycopg://pdm:pdm@localhost:5432/pdm + run: pytest -q + model: runs-on: ubuntu-latest timeout-minutes: 10 @@ -217,6 +223,7 @@ jobs: echo "RUL_WARNING=75" echo "RUL_CRITICAL=30" echo "RUL_CLIP=125" + python3 -c 'import secrets; print("JWT_SECRET=" + secrets.token_urlsafe(48))' } > .env - name: Validate docker-compose.yml @@ -234,6 +241,22 @@ jobs: - name: Frontend is served run: curl -fsS -o /dev/null http://localhost:5173/ + - name: Create account for API smoke + run: | + SMOKE_PASSWORD=$(python3 -c 'import secrets; print(secrets.token_urlsafe(24))') + echo "::add-mask::$SMOKE_PASSWORD" + echo "SMOKE_PASSWORD=$SMOKE_PASSWORD" >> "$GITHUB_ENV" + export SMOKE_PASSWORD + docker compose exec -T -e SMOKE_PASSWORD backend python - <<'PYTHON' + import os + from app.core.db import engine + from app.services.auth_service import create_user + with engine.connect() as db: + user = create_user(db, "ci.smoke", os.environ["SMOKE_PASSWORD"]) + if user is None: + raise SystemExit("Smoke-test login already exists") + PYTHON + - name: API smoke run: python3 scripts/api_smoke.py http://localhost:8000 240 diff --git a/README.md b/README.md index 2661cab..a40151b 100644 --- a/README.md +++ b/README.md @@ -116,7 +116,57 @@ api/v1 (эндпоинты, валидация) → services (бизнес-ло ## Контракты API -Все эндпоинты — с префиксом `/api/v1`. Документация OpenAPI: `/docs`. +Ниже указаны пути backend. Frontend обращается к ним через прокси `/api` (например, `/api/auth/login`). Документация OpenAPI backend: `/docs`. + +### Авторизация и управление аккаунтами + +Публичной регистрации нет. Аккаунты выдаёт администратор; он вручную задаёт логин и постоянный пароль. Почтовая отправка не используется. + +- `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. ### Оборудование @@ -228,9 +278,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/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 new file mode 100644 index 0000000..54ad6c9 --- /dev/null +++ b/backend/app/api/auth.py @@ -0,0 +1,50 @@ +from typing import Annotated + +from fastapi import APIRouter, Depends, HTTPException, Request +from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer + +from app.core.db import DB +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") +UNAUTHORIZED = {401: {"description": "Требуется действующий токен активного пользователя"}} + + +def _unauthorized(detail: str) -> HTTPException: + return HTTPException(401, detail, headers={"WWW-Authenticate": "Bearer"}) + + +def get_current_user(db: DB, credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(bearer)]) -> dict: + 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 + + +CurrentUser = Annotated[dict, Depends(get_current_user)] + + +def require_admin(user: CurrentUser) -> dict: + if user["role"] != "admin": + raise HTTPException(403, "Доступ разрешён только администратору") + return user + + +@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("Неверный логин или пароль") + 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: 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/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/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 new file mode 100644 index 0000000..4883659 --- /dev/null +++ b/backend/app/core/security.py @@ -0,0 +1,45 @@ +import hashlib +import hmac +from datetime import UTC, datetime, timedelta + +import bcrypt +import jwt + +from app.core.config import JWT_EXPIRE_MINUTES, JWT_SECRET + +ALGORITHM = "HS256" +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: + return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode() + + +def verify_password(password: str, password_hash: str) -> bool: + try: + return bcrypt.checkpw(password.encode(), password_hash.encode()) + except ValueError: + return False + + +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 identity_from_token(token: str) -> tuple[int, int] | None: + try: + 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 9041430..deef55c 100644 --- a/backend/app/models/__init__.py +++ b/backend/app/models/__init__.py @@ -4,12 +4,15 @@ from .physics_predictions import PhysicsPrediction from .sensor_catalog import SensorCatalog from .sensor_readings import SensorReading +from .users import LoginAttempt, User __all__ = [ "Alert", "Equipment", + "LoginAttempt", "MlPrediction", "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..295030f --- /dev/null +++ b/backend/app/models/users.py @@ -0,0 +1,37 @@ +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) + 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 new file mode 100644 index 0000000..60a8983 --- /dev/null +++ b/backend/app/schemas/auth.py @@ -0,0 +1,72 @@ +from datetime import datetime +from typing import Literal + +from pydantic import BaseModel, ConfigDict, Field, field_validator + +PASSWORD_MAX_BYTES = 72 +PASSWORD_MIN = 12 + + +class PasswordIn(BaseModel): + model_config = ConfigDict(extra="forbid") + password: str = Field(min_length=1, max_length=72, repr=False) + + @field_validator("password", mode="before") + @classmethod + def fits_bcrypt(cls, value: str) -> str: + 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 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 + login: str + role: Literal["admin", "employee"] + is_active: bool + + +class ManagedUserOut(UserOut): + created_at: datetime + + +class AuthOut(BaseModel): + 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 new file mode 100644 index 0000000..b565820 --- /dev/null +++ b/backend/app/services/auth_service.py @@ -0,0 +1,30 @@ +from sqlalchemy import Connection, select +from sqlalchemy.dialects.postgresql import insert + +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, 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, 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 {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(*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 b3376de..e94f6c1 100644 --- a/backend/main.py +++ b/backend/main.py @@ -1,13 +1,29 @@ -from app.api import alerts, 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 FastAPI +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=["*"]) -app.include_router(equipment.router) -app.include_router(alerts.router) -app.include_router(predict.router) +# Данные — только с токеном; публичный вход только через /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/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 index 13285c2..39d29d9 100644 --- a/backend/tests/conftest.py +++ b/backend/tests/conftest.py @@ -11,8 +11,9 @@ 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" +TABLES = "alerts, ml_predictions, physics_predictions, sensor_readings, equipment, users, login_attempts" @pytest.fixture @@ -26,12 +27,25 @@ def db(): @pytest.fixture -def client(db): +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(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)}"}) + + @pytest.fixture def add_equipment(db): from app.models import Equipment @@ -74,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 new file mode 100644 index 0000000..ab9d68b --- /dev/null +++ b/backend/tests/test_auth.py @@ -0,0 +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 insert, select, text, update + +PASSWORD = "Correct-pass 123!" + + +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) + + +def bearer(token): + return {"Authorization": f"Bearer {token}"} + + +def sign_in(client, login="worker", password=PASSWORD): + return client.post("/auth/login", json={"login": login, "password": password}) + + +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_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" + + +@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 + + +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 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_bad_and_legacy_tokens(anon_client, account): + from app.core.config import JWT_SECRET + 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 cb460a0..5202fe2 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -1,30 +1,71 @@ -import { NavLink, Route, Routes } 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 { getToken, setSession, useSession } from "./session"; export function App() { - return ( - <> -
- OFF-Tech -
+
+ + } /> + }> } /> } /> } /> - Страница не найдена

} /> -
-
- - ); + : } /> + + Страница не найдена

} /> + + + ; +} + +function RequireAuth() { + return useSession() ? : ; } diff --git a/frontend/src/api.ts b/frontend/src/api.ts index b1cda21..674b04a 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 { @@ -56,21 +58,60 @@ export interface Alert { message: string; } +export interface User { + id: number; + login: string; + role: "admin" | "employee"; + is_active: boolean; +} + +export interface ManagedUser extends User { + created_at: 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.replace(/^Value error, /, "")).join("; "); } catch {} - throw new Error(`${res.status}: ${detail}`); + throw new ApiError(res.status, detail); } + if (res.status === 204) return undefined as T; 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}`), @@ -79,10 +120,14 @@ export const api = { getPhysics: (id: number, limit = 500) => request(`/equipment/${id}/physics?limit=${limit}`), 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: (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 843f5c4..669a57f 100644 --- a/frontend/src/index.css +++ b/frontend/src/index.css @@ -237,3 +237,87 @@ 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-login { + 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; +} + +.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 new file mode 100644 index 0000000..381c522 --- /dev/null +++ b/frontend/src/pages/Auth.tsx @@ -0,0 +1,42 @@ +import { type FormEvent, useState } from "react"; +import { Navigate } from "react-router-dom"; + +import { ApiError, api } from "../api"; +import { PasswordField } from "../components/PasswordField"; +import { setSession, useSession } from "../session"; + +export function AuthPage() { + const session = useSession(); + const [error, setError] = useState(null); + const [busy, setBusy] = useState(false); + + if (session) return ; + + 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")); + setBusy(true); + setError(null); + try { + 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
+

Вход

+
+ + + {error &&

{error}

} + + +

Для получения аккаунта или сброса пароля обратитесь к администратору.

+
; +} 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 &&
+

{editing === "new" ? "Новый пользователь" : `Новый пароль: ${editing.login}`}

+
+ {editing === "new" && } + +

{PASSWORD_HINT}

+ + {editing !== "new" &&

После смены пароля пользователю потребуется войти заново.

} +
+
+ +
} + {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 new file mode 100644 index 0000000..8338730 --- /dev/null +++ b/frontend/src/session.ts @@ -0,0 +1,57 @@ +import { useSyncExternalStore } from "react"; + +export interface Session { + token: string; + login: string; + role: "admin" | "employee"; +} + +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?.login === "string" && (value.role === "admin" || value.role === "employee") ? 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, + ); +} diff --git a/scripts/api_smoke.py b/scripts/api_smoke.py index 20f3a2e..ea31f05 100644 --- a/scripts/api_smoke.py +++ b/scripts/api_smoke.py @@ -1,4 +1,5 @@ import json +import os import re import sys import time @@ -7,6 +8,7 @@ BASE = (sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8000").rstrip("/") WAIT = int(sys.argv[2]) if len(sys.argv) > 2 else 240 +TOKEN = None CONTRACT = [ ("GET", "/equipment"), @@ -14,14 +16,21 @@ ("GET", "/equipment/{id}/status"), ("GET", "/equipment/{id}/history"), ("GET", "/equipment/{id}/forecast"), + ("GET", "/equipment/{id}/physics"), ("GET", "/alerts"), ("GET", "/alerts/{id}"), ("POST", "/predict"), ] -def call(method, path): - req = urllib.request.Request(BASE + path, method=method, headers={"Accept": "application/json"}) +def call(method, path, data=None, *, authenticated=True): + headers = {"Accept": "application/json"} + if authenticated and TOKEN: + headers["Authorization"] = f"Bearer {TOKEN}" + if data is not None: + headers["Content-Type"] = "application/json" + req = urllib.request.Request(BASE + path, method=method, headers=headers, + data=json.dumps(data).encode() if data is not None else None) try: with urllib.request.urlopen(req, timeout=15) as r: return r.status, json.loads(r.read().decode() or "null") @@ -52,8 +61,12 @@ def norm(path): def main(): - schema = wait_for(lambda: (lambda r: r[1] if r[0] == 200 and isinstance(r[1], dict) else None)( - call("GET", "/openapi.json")), "ответа /openapi.json") + global TOKEN + def get_schema(): + code, body = call("GET", "/openapi.json") + return body if code == 200 and isinstance(body, dict) else None + + schema = wait_for(get_schema, "ответа /openapi.json") paths = {norm(p): {m.upper() for m in methods} for p, methods in schema.get("paths", {}).items()} prefix = next((p[: -len("/equipment")] for p in schema["paths"] if norm(p).endswith("/equipment")), None) @@ -65,8 +78,30 @@ def main(): fail("в API нет эндпоинтов из контракта README:\n " + "\n ".join(missing)) print(f"OK контракт README: {len(CONTRACT)} эндпоинтов найдено (префикс {prefix or '—'!r})") - items = wait_for(lambda: (lambda r: r[1] if r[0] == 200 and isinstance(r[1], list) and r[1] else None)( - call("GET", prefix + "/equipment")), "непустого списка оборудования (работают ли симулятор и воркер?)") + password = os.getenv("SMOKE_PASSWORD") + if not password: + fail("задайте SMOKE_PASSWORD для отдельного тестового аккаунта ci.smoke") + code, session = call("POST", "/auth/login", {"login": "ci.smoke", "password": password}, authenticated=False) + if code != 200 or not isinstance(session, dict) or not session.get("access_token"): + fail(f"вход тестового пользователя: ожидали 200, получили {code}") + TOKEN = session["access_token"] + for method, path in CONTRACT: + code, _ = call(method, prefix + path.replace("{id}", "1"), authenticated=False) + if code != 401: + fail(f"API без токена: ожидали 401 от {method} {path}, получили {code}") + code, _ = call("GET", "/admin/users") + if code != 403: + fail(f"админка для сотрудника: ожидали 403, получили {code}") + code, _ = call("POST", "/auth/register", {"login": "forbidden", "password": password}, authenticated=False) + if code != 404: + fail(f"публичная регистрация: ожидали 404, получили {code}") + print("OK вход, защита API, права сотрудника и отсутствие публичной регистрации") + + def get_equipment(): + code, body = call("GET", prefix + "/equipment") + return body if code == 200 and isinstance(body, list) and body else None + + items = wait_for(get_equipment, "непустого списка оборудования (работают ли симулятор и воркер?)") if not isinstance(items[0], dict) or "id" not in items[0]: fail("у элементов /equipment нет поля id") eq_id = items[0]["id"]