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 (
- <>
-
Для получения аккаунта или сброса пароля обратитесь к администратору.
+{error}
} + {notice &&{notice}
} + {editing &&{statusTarget.is_active ? "Пользователь потеряет доступ к системе." + : "Пользователь снова сможет войти с текущим паролем."}
+Загружаем пользователей…
: <> +| Логин | Роль | Состояние | Действия |
|---|---|---|---|
| {user.login} | {user.role === "admin" ? "Администратор" : "Пользователь"} | +{user.is_active ? "Активен" : "Заблокирован"} | +{user.role === "employee" ?
+
+
+ : Управление через сервер} |
+
На этой странице нет аккаунтов.
} + >} +