admin_ruspet/communication_system_front.txt

4581 lines
144 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

├── .env
├── .env.example
├── .gitea
│ ├── workflows
│ │ ├── deploy-frontend.yml
├── .gitignore
├── README.md
├── eslint.config.js
├── index.html
├── package-lock.json
├── package.json
├── public
│ ├── favicon.svg
│ ├── icons.svg
├── react_code.txt
├── src
│ ├── App.css
│ ├── App.tsx
│ ├── api
│ │ ├── adminLogs.ts
│ │ ├── admins.ts
│ │ ├── approvalTasks.ts
│ │ ├── approvals.ts
│ │ ├── auth.ts
│ │ ├── categories.ts
│ │ ├── client.ts
│ │ ├── dashboard.ts
│ │ ├── departments.ts
│ │ ├── flowNodes.ts
│ │ ├── hierarchies.ts
│ │ ├── notifications.ts
│ │ ├── permissions.ts
│ │ ├── roles.ts
│ │ ├── time.ts
│ │ ├── topicExecutors.ts
│ │ ├── topics.ts
│ │ ├── userRoles.ts
│ │ ├── users.ts
│ ├── assets
│ │ ├── hero.png
│ │ ├── react.svg
│ │ ├── vite.svg
│ ├── components
│ │ ├── CopyRolesModal.tsx
│ │ ├── DiagnosticErrorBoundary.tsx
│ │ ├── Layout
│ │ │ ├── Header.tsx
│ │ │ ├── MainLayout.tsx
│ │ │ ├── Sidebar.tsx
│ │ ├── TopicGapsModal.tsx
│ │ ├── UserEditModal.tsx
│ ├── features
│ │ ├── adminLogs
│ │ │ ├── hooks
│ │ │ │ ├── useAdminLogs.ts
│ │ ├── admins
│ │ │ ├── hooks
│ │ │ │ ├── useAdmins.ts
│ │ ├── approvalTasks
│ │ │ ├── const.ts
│ │ │ ├── hooks
│ │ │ │ ├── useApprovalTasks.ts
│ │ ├── approvals
│ │ │ ├── hooks
│ │ │ │ ├── useApprovals.ts
│ │ ├── categories
│ │ │ ├── hooks
│ │ │ │ ├── useCategories.ts
│ │ ├── departments
│ │ │ ├── components
│ │ │ │ ├── DepartmentEditModal.tsx
│ │ │ ├── hooks
│ │ │ │ ├── useDepartments.ts
│ │ ├── flowNodes
│ │ │ ├── hooks
│ │ │ │ ├── useFlowNodes.ts
│ │ │ ├── utils
│ │ │ │ ├── flattenTree.ts
│ │ │ │ ├── treeWalk.ts
│ │ ├── hierarchies
│ │ │ ├── hooks
│ │ │ │ ├── useHierarchies.ts
│ │ │ │ ├── useSystemOptions.ts
│ │ │ ├── utils.ts
│ │ ├── notifications
│ │ │ ├── hooks
│ │ │ │ ├── useNotifications.ts
│ │ │ ├── utils
│ │ │ │ ├── telegramHtml.ts
│ │ ├── permissions
│ │ │ ├── constants.ts
│ │ │ ├── hooks
│ │ │ │ ├── usePermissions.ts
│ │ ├── roles
│ │ │ ├── hooks
│ │ │ │ ├── useAllRoles.ts
│ │ │ │ ├── useRoles.ts
│ │ ├── topicExecutors
│ │ │ ├── hooks
│ │ │ │ ├── useTopicExecutors.ts
│ │ │ ├── utils.ts
│ │ ├── topics
│ │ │ ├── constants.ts
│ │ │ ├── hooks
│ │ │ │ ├── useTopics.ts
│ │ ├── users
│ │ │ ├── hooks
│ │ │ │ ├── useDepartments.ts
│ │ │ │ ├── useRoles.ts
│ │ │ │ ├── useUserRoles.ts
│ │ │ │ ├── useUsers.ts
│ ├── hooks
│ │ ├── useAuth.ts
│ ├── index.css
│ ├── main.tsx
│ ├── pages
│ │ ├── Dashboard.tsx
│ │ ├── DepartmentsPage.tsx
│ │ ├── Login.tsx
│ │ ├── adminLogs
│ │ │ ├── AdminLogsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── AdminLogDetailModal.tsx
│ │ ├── admins
│ │ │ ├── AdminsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── CreateAdminModal.tsx
│ │ │ │ ├── EditAdminModal.tsx
│ │ ├── approvalTasks
│ │ │ ├── ApprovalTasksPage.tsx
│ │ │ ├── components
│ │ │ │ ├── ApprovalTaskDetailsModal.tsx
│ │ ├── approvals
│ │ │ ├── ApprovalsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── ApprovalDetailsModal.tsx
│ │ │ │ ├── FilePreviewModal.tsx
│ │ ├── categories
│ │ │ ├── CategoriesPage.tsx
│ │ │ ├── components
│ │ │ │ ├── CategoryEditModal.tsx
│ │ ├── flowNodes
│ │ │ ├── FlowTreeGuidePage.tsx
│ │ │ ├── FlowTreePage.tsx
│ │ │ ├── components
│ │ │ │ ├── CategoryCreateModal.tsx
│ │ │ │ ├── DataFlowExplainer.tsx
│ │ │ │ ├── FlowNodeEditModal.tsx
│ │ │ │ ├── SortableFlowTree.tsx
│ │ │ │ ├── TreeHealthPanel.tsx
│ │ ├── hierarchies
│ │ │ ├── HierarchiesPage.tsx
│ │ │ ├── components
│ │ │ │ ├── ChainDuplicateModal.tsx
│ │ │ │ ├── ChainVisualization.tsx
│ │ │ │ ├── HierarchyEditModal.tsx
│ │ │ │ ├── PersonDuplicateModal.tsx
│ │ ├── notifications
│ │ │ ├── NotificationsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── NotificationDetailsModal.tsx
│ │ │ │ ├── NotificationsHistoryTable.tsx
│ │ │ │ ├── SendNotificationForm.tsx
│ │ ├── permissions
│ │ │ ├── PermissionsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── PermissionEditModal.tsx
│ │ ├── roles
│ │ │ ├── RolesPage.tsx
│ │ │ ├── components
│ │ │ │ ├── RoleEditModal.tsx
│ │ ├── settings
│ │ │ ├── SettingsPage.tsx
│ │ ├── topicExecutors
│ │ │ ├── TopicExecutorsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── TopicExecutorEditModal.tsx
│ │ │ │ ├── TopicExecutorsCard.tsx
│ │ ├── topics
│ │ │ ├── TopicsPage.tsx
│ │ │ ├── components
│ │ │ │ ├── TopicEditModal.tsx
│ │ ├── users
│ │ │ ├── UsersPage.tsx
│ ├── theme.ts
│ ├── types
│ │ ├── api.ts
│ ├── utils
│ │ ├── date.ts
│ ├── vite-env.d.ts
├── tsconfig.app.json
├── tsconfig.json
├── tsconfig.node.json
├── vite.config.ts
File: eslint.config.js
Lines: 22
-----BEGIN eslint.config.js-----
import js from '@eslint/js'
import globals from 'globals'
import reactHooks from 'eslint-plugin-react-hooks'
import reactRefresh from 'eslint-plugin-react-refresh'
import tseslint from 'typescript-eslint'
import { defineConfig, globalIgnores } from 'eslint/config'
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{ts,tsx}'],
extends: [
js.configs.recommended,
tseslint.configs.recommended,
reactHooks.configs.flat.recommended,
reactRefresh.configs.vite,
],
languageOptions: {
globals: globals.browser,
},
},
])
-----END eslint.config.js-----
File: index.html
Lines: 13
-----BEGIN index.html-----
<!doctype html>
<html lang="ru">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Административная панель РусПЭТ</title>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
-----END index.html-----
File: src/App.css
Lines: 184
-----BEGIN src/App.css-----
.counter {
font-size: 16px;
padding: 5px 10px;
border-radius: 5px;
color: var(--accent);
background: var(--accent-bg);
border: 2px solid transparent;
transition: border-color 0.3s;
margin-bottom: 24px;
&:hover {
border-color: var(--accent-border);
}
&:focus-visible {
outline: 2px solid var(--accent);
outline-offset: 2px;
}
}
.hero {
position: relative;
.base,
.framework,
.vite {
inset-inline: 0;
margin: 0 auto;
}
.base {
width: 170px;
position: relative;
z-index: 0;
}
.framework,
.vite {
position: absolute;
}
.framework {
z-index: 1;
top: 34px;
height: 28px;
transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
scale(1.4);
}
.vite {
z-index: 0;
top: 107px;
height: 26px;
width: auto;
transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
scale(0.8);
}
}
#center {
display: flex;
flex-direction: column;
gap: 25px;
place-content: center;
place-items: center;
flex-grow: 1;
@media (max-width: 1024px) {
padding: 32px 20px 24px;
gap: 18px;
}
}
#next-steps {
display: flex;
border-top: 1px solid var(--border);
text-align: left;
& > div {
flex: 1 1 0;
padding: 32px;
@media (max-width: 1024px) {
padding: 24px 20px;
}
}
.icon {
margin-bottom: 16px;
width: 22px;
height: 22px;
}
@media (max-width: 1024px) {
flex-direction: column;
text-align: center;
}
}
#docs {
border-right: 1px solid var(--border);
@media (max-width: 1024px) {
border-right: none;
border-bottom: 1px solid var(--border);
}
}
#next-steps ul {
list-style: none;
padding: 0;
display: flex;
gap: 8px;
margin: 32px 0 0;
.logo {
height: 18px;
}
a {
color: var(--text-h);
font-size: 16px;
border-radius: 6px;
background: var(--social-bg);
display: flex;
padding: 6px 12px;
align-items: center;
gap: 8px;
text-decoration: none;
transition: box-shadow 0.3s;
&:hover {
box-shadow: var(--shadow);
}
.button-icon {
height: 18px;
width: 18px;
}
}
@media (max-width: 1024px) {
margin-top: 20px;
flex-wrap: wrap;
justify-content: center;
li {
flex: 1 1 calc(50% - 8px);
}
a {
width: 100%;
justify-content: center;
box-sizing: border-box;
}
}
}
#spacer {
height: 88px;
border-top: 1px solid var(--border);
@media (max-width: 1024px) {
height: 48px;
}
}
.ticks {
position: relative;
width: 100%;
&::before,
&::after {
content: '';
position: absolute;
top: -4.5px;
border: 5px solid transparent;
}
&::before {
left: 0;
border-left-color: var(--border);
}
&::after {
right: 0;
border-right-color: var(--border);
}
}
-----END src/App.css-----
File: src/api/adminLogs.ts
Lines: 34
-----BEGIN src/api/adminLogs.ts-----
import apiClient from './client'
import type { ApiResponse } from '@/types/api'
export interface AdminActionLog {
id: number
admin_id: number
admin_login: string
action: 'create' | 'update' | 'delete'
entity_type: string
entity_id?: number
description: string
metadata?: string
created_at: string
}
export interface AdminLogsListParams {
offset?: number
limit?: number
admin_id?: number
admin_login?: string
action?: string
entity_type?: string
entity_id?: number
date_from?: string
date_to?: string
search?: string
}
export const adminLogsApi = {
getList: (params: AdminLogsListParams = {}) =>
apiClient.get<ApiResponse<AdminActionLog[]>>('/admin-logs', { params }),
delete: (id: number) =>
apiClient.delete<boolean>(`/admin-logs/${id}`),
}
-----END src/api/adminLogs.ts-----
File: src/api/admins.ts
Lines: 39
-----BEGIN src/api/admins.ts-----
import apiClient from './client'
import type { Admin, ApiResponse } from '@/types/api'
export interface AdminsListParams {
offset?: number
limit?: number
is_blocked?: boolean
login?: string
}
export interface CreateAdminRequest {
login: string
name?: string
is_root?: boolean
is_observer?: boolean // 🆕
telegram_id?: number // 🆕
}
export interface UpdateAdminRequest {
id: number
name?: string
is_blocked?: boolean
is_root?: boolean
is_observer?: boolean // 🆕
telegram_id?: number | null // 🆕
}
export const adminsApi = {
getList: (params: AdminsListParams = {}) =>
apiClient.get<ApiResponse<Admin[]>>('/admin', { params }),
create: (data: CreateAdminRequest) =>
apiClient.post<Admin>('/admin', data),
update: (data: UpdateAdminRequest) =>
apiClient.put<Admin>('/admin', data),
delete: (id: number) =>
apiClient.delete<boolean>('/admin', { data: { id } }),
}
-----END src/api/admins.ts-----
File: src/api/approvalTasks.ts
Lines: 31
-----BEGIN src/api/approvalTasks.ts-----
import apiClient from './client'
import type { ApprovalTask, ApiResponse } from '@/types/api'
export interface ApprovalTasksListParams {
offset?: number
limit?: number
status?: string
executor_id?: number
approval_id?: number
require_file?: boolean
}
export interface UpdateApprovalTaskRequest {
id: number
status?: string
task_text?: string
require_file?: boolean
}
export const approvalTasksApi = {
getList: (params: ApprovalTasksListParams = {}) =>
apiClient.get<ApiResponse<ApprovalTask[]>>('/approval-tasks', { params }),
getById: (id: number) =>
apiClient.get<ApprovalTask>(`/approval-tasks/${id}`),
update: (data: UpdateApprovalTaskRequest) =>
apiClient.put<ApprovalTask>('/approval-tasks', data),
delete: (id: number) =>
apiClient.delete<boolean>('/approval-tasks', { data: { id } }),
}
-----END src/api/approvalTasks.ts-----
File: src/api/approvals.ts
Lines: 199
-----BEGIN src/api/approvals.ts-----
import apiClient from './client'
import type { Approval, ApiResponse } from '@/types/api'
export interface PlannedTask {
id: number
task_text: string
executor_name?: string
step_order: number
}
export interface ApprovalTaskItem {
id: number
task_text: string
executor_name: string
status: 'pending' | 'waiting' | 'completed' | 'cancelled' | 'cancellation'
completed_at?: string
}
export interface ApprovalTasksResponse {
topic_executors: PlannedTask[]
tasks: ApprovalTaskItem[]
has_task_error: boolean
}
export interface ApprovalsListParams {
offset?: number
limit?: number
id?: number
status?: string
initiator_id?: number
topic_id?: number // одиночный (для обратной совместимости)
topic_ids?: number[] // 🆕 множественный выбор тем
category_ids?: number[] // 🆕 множественный выбор категорий
department_id?: number
date_from?: string // 🆕 YYYY-MM-DD
date_to?: string // 🆕 YYYY-MM-DD
content?: string
}
export interface ApprovalsReportParams {
user_id?: number
date_from?: string // YYYY-MM-DD
date_to?: string // YYYY-MM-DD
all_access?: boolean
}
export interface UpdateApprovalRequest {
id: number
status?: string
revision_comment?: string
}
export const approvalsApi = {
getList: (params: ApprovalsListParams = {}) => {
// Формируем query-параметры, корректно сериализуя массивы
const query: Record<string, any> = {}
if (params.offset !== undefined) query.offset = params.offset
if (params.limit !== undefined) query.limit = params.limit
if (params.status) query.status = params.status
if (params.initiator_id) query.initiator_id = params.initiator_id
if (params.topic_id) query.topic_id = params.topic_id
if (params.id) query.id = params.id
if (params.department_id) query.department_id = params.department_id
if (params.content) query.content = params.content
if (params.date_from) query.date_from = params.date_from
if (params.date_to) query.date_to = params.date_to
// 🆕 Массивы передаём через запятую: "1,2,3"
if (params.topic_ids && params.topic_ids.length > 0) {
query.topic_ids = params.topic_ids.join(',')
}
if (params.category_ids && params.category_ids.length > 0) {
query.category_ids = params.category_ids.join(',')
}
return apiClient.get<ApiResponse<Approval[]>>('/approvals', { params: query })
},
getById: (id: number) =>
apiClient.get<Approval>(`/approvals/${id}`),
update: (data: UpdateApprovalRequest) =>
apiClient.put<Approval>('/approvals', data),
delete: (id: number) =>
apiClient.delete<boolean>('/approvals', { data: { id } }),
getTasks: (approvalId: number) =>
apiClient.get<ApiResponse<ApprovalTasksResponse>>(`/approvals/${approvalId}/tasks`),
getForReport: (params: ApprovalsReportParams = {}) =>
apiClient.get<ApiResponse<Approval[]>>('/approvals/report', { params }),
downloadReport: (params: ApprovalsReportParams = {}) =>
apiClient.get('/approvals/report/download', {
params,
responseType: 'blob',
}),
getAdditionalApprovers: (approvalId: number) =>
apiClient.get<ApiResponse<AdditionalApprover[]>>(`/approvals/${approvalId}/additional-approvers`),
getComments: (approvalId: number) =>
apiClient.get<ApiResponse<ApprovalComment[]>>(`/approvals/${approvalId}/comments`),
getObservers: (approvalId: number) =>
apiClient.get<ApiResponse<ApprovalObserver[]>>(`/approvals/${approvalId}/observers`),
getRevocationRequest: (approvalId: number) =>
apiClient.get<ApiResponse<RevocationRequest | null>>(`/approvals/${approvalId}/revocation-request`),
getFile: (approvalId: number, fileId: number) =>
apiClient.get(`/approvals/${approvalId}/files/${fileId}`, {
responseType: 'blob',
}),
downloadFile: (approvalId: number, fileId: number, fileName: string) => {
const token = localStorage.getItem('token')
const timestamp = Math.floor(Date.now() / 1000).toString()
const deviceId = localStorage.getItem('device_id') || 'admin-panel'
const publicKey = import.meta.env.VITE_API_PUBLIC_KEY
const privateKey = import.meta.env.VITE_API_PRIVATE_KEY
const message = publicKey + ":" + timestamp
const signature = CryptoJS.HmacSHA256(message, privateKey).toString(CryptoJS.enc.Hex)
const url = `${apiClient.defaults.baseURL}/approvals/${approvalId}/files/${fileId}/download`
const link = document.createElement('a')
link.href = `${url}?_t=${timestamp}`
link.setAttribute('download', fileName)
fetch(url, {
method: 'GET',
headers: {
'Authorization': `Bearer ${token}`,
'ApiKey': signature,
'X-Timestamp': timestamp,
'x-device-id': deviceId,
},
})
.then(response => response.blob())
.then(blob => {
const blobUrl = window.URL.createObjectURL(blob)
link.href = blobUrl
document.body.appendChild(link)
link.click()
link.remove()
window.URL.revokeObjectURL(blobUrl)
})
.catch(error => {
console.error('Download error:', error)
throw error
})
},
}
// ДОБАВИТЬ в src/api/approvals.ts (по образцу остальных методов approvalsApi
// в этом файле — замените apiClient.get на ваш реальный вызов, если он
// называется иначе):
export interface AdditionalApprover {
id: number
approver_id: number
approver_name: string
status: 'pending' | 'approved' | 'rejected'
comment?: string
acted_at?: string
}
export interface ApprovalComment {
id: number
user_id: number
user_name: string
comment: string
created_at?: string
}
export interface ApprovalObserver {
id: number
full_name: string
}
export interface RevocationApprover {
approver_id: number
approver_name: string
status: 'pending' | 'approved' | 'rejected'
}
export interface RevocationRequest {
id: number
status: 'pending' | 'approved' | 'rejected'
reason?: string
requested_by_id: number
requested_by_name: string
approvers: RevocationApprover[]
}
-----END src/api/approvals.ts-----
File: src/api/auth.ts
Lines: 21
-----BEGIN src/api/auth.ts-----
import apiClient from './client'
import type { LoginRequest, LoginResponse, Admin } from '@/types/api'
export interface UpdateProfileRequest {
password?: string
login?: string
}
export const authApi = {
login: (data: LoginRequest) =>
apiClient.post<LoginResponse>('/auth/login', data),
getProfile: () =>
apiClient.get<Admin>('/admin/profile'),
logout: () =>
apiClient.post('/auth/logout'),
// 🆕 Смена пароля через существующий endpoint
updateProfile: (data: UpdateProfileRequest) =>
apiClient.put<Admin>('/admin/profile', data),
}
-----END src/api/auth.ts-----
File: src/api/categories.ts
Lines: 41
-----BEGIN src/api/categories.ts-----
import apiClient from './client'
import type { ApprovalTopicCategory, ApiResponse } from '@/types/api'
export interface CategoriesListParams {
offset?: number
limit?: number
is_active?: boolean
name?: string
code?: string
}
export interface CreateCategoryRequest {
name: string
code: string
description?: string
is_active?: boolean
}
export interface UpdateCategoryRequest {
id: number
name?: string
code?: string
description?: string
is_active?: boolean
}
export const categoriesApi = {
getList: (params: CategoriesListParams = {}) =>
apiClient.get<ApiResponse<ApprovalTopicCategory[]>>('/categories', { params }),
getById: (id: number) =>
apiClient.get<ApprovalTopicCategory>(`/categories/${id}`),
create: (data: CreateCategoryRequest) =>
apiClient.post<ApprovalTopicCategory>('/categories', data),
update: (data: UpdateCategoryRequest) =>
apiClient.put<ApprovalTopicCategory>('/categories', data),
delete: (id: number) =>
apiClient.delete<boolean>('/categories', { data: { id } }),
}
-----END src/api/categories.ts-----
File: src/api/client.ts
Lines: 166
-----BEGIN src/api/client.ts-----
import axios from 'axios'
import CryptoJS from 'crypto-js'
import { timeApi } from './time'
// 🔄 Offset между клиентом и сервером (в секундах)
let serverTimeOffset = 0
let isSyncing = false
let syncPromise: Promise<void> | null = null
// Функция генерации HMAC подписи
function generateHmacSignature(publicKey: string, timestamp: string, privateKey: string): string {
const message = publicKey + ":" + timestamp
const hash = CryptoJS.HmacSHA256(message, privateKey)
return hash.toString(CryptoJS.enc.Hex)
}
// 🆕 Функция для получения или создания device_id
function getOrCreateDeviceId(): string {
let deviceId = localStorage.getItem('device_id')
if (!deviceId) {
deviceId = crypto.randomUUID()
localStorage.setItem('device_id', deviceId)
}
return deviceId
}
// 🆕 Синхронизация времени с сервером
async function syncTimeWithServer(): Promise<void> {
if (isSyncing && syncPromise) {
return syncPromise
}
isSyncing = true
syncPromise = (async () => {
try {
const serverTime = await timeApi.getServerTime()
const clientTimestamp = Math.floor(Date.now() / 1000)
serverTimeOffset = serverTime.timestamp - clientTimestamp
console.log('[Time] ✅ Synced with server', {
serverTime: serverTime.iso,
serverTimestamp: serverTime.timestamp,
clientTimestamp,
offset: serverTimeOffset,
})
} catch (error) {
console.warn('[Time] ⚠️ Failed to sync with server:', error)
// При ошибке сбрасываем offset
serverTimeOffset = 0
} finally {
isSyncing = false
syncPromise = null
}
})()
return syncPromise
}
// 🆕 Получение timestamp с учётом offset
function getCorrectedTimestamp(): string {
return Math.floor(Date.now() / 1000 + serverTimeOffset).toString()
}
const apiClient = axios.create({
baseURL: '/api',
headers: {
'Content-Type': 'application/json',
},
})
// Interceptor для добавления токена и HMAC подписи
apiClient.interceptors.request.use(async (config) => {
console.log('[API] === Request interceptor started ===')
// Добавляем JWT токен, если есть
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
console.log('[API] ✅ Added JWT token')
}
// Генерируем HMAC подпись с скорректированным timestamp
const publicKey = import.meta.env.VITE_API_PUBLIC_KEY
const privateKey = import.meta.env.VITE_API_PRIVATE_KEY
const timestamp = getCorrectedTimestamp()
if (!publicKey || !privateKey) {
console.error('[API] ❌ Missing API keys in .env!')
} else {
const signature = generateHmacSignature(publicKey, timestamp, privateKey)
config.headers.ApiKey = signature
console.log('[API] ✅ Added HMAC signature')
}
config.headers['X-Timestamp'] = timestamp
// Получаем или создаём device_id
const deviceId = getOrCreateDeviceId()
config.headers['x-device-id'] = deviceId
console.log('[API] ✅ Added device_id:', deviceId)
console.log('[API] 🕐 Using timestamp:', timestamp, 'offset:', serverTimeOffset)
console.log('[API] === Request interceptor finished ===')
return config
})
// Interceptor для обработки ошибок
apiClient.interceptors.response.use(
(response) => {
console.log('[API] ✅ Response success:', response.config.url)
return response
},
async (error) => {
console.error('[API] ❌ Response error:', {
status: error.response?.status,
statusText: error.response?.statusText,
data: error.response?.data,
url: error.config?.url,
})
// 🆕 При ошибке "Timestamp expired" — синхронизируем время и повторяем запрос
if (
error.response?.status === 401 &&
error.response?.data === 'Timestamp expired\n' &&
!error.config._retry
) {
console.warn('[API] ⚠️ Timestamp expired, syncing with server...')
error.config._retry = true
await syncTimeWithServer()
// Пересоздаём подпись с новым timestamp
const publicKey = import.meta.env.VITE_API_PUBLIC_KEY
const privateKey = import.meta.env.VITE_API_PRIVATE_KEY
const newTimestamp = getCorrectedTimestamp()
error.config.headers['X-Timestamp'] = newTimestamp
error.config.headers['ApiKey'] = generateHmacSignature(
publicKey,
newTimestamp,
privateKey
)
return apiClient(error.config)
}
if (error.response?.status === 401) {
console.warn('[API] ⚠️ Unauthorized, redirecting to login')
localStorage.removeItem('token')
window.location.href = '/login'
}
return Promise.reject(error)
}
)
// 🆕 Синхронизируем время при загрузке модуля
syncTimeWithServer()
// 🆕 Периодическая синхронизация каждые 5 минут
setInterval(() => {
syncTimeWithServer()
}, 5 * 60 * 1000)
export default apiClient
-----END src/api/client.ts-----
File: src/api/dashboard.ts
Lines: 56
-----BEGIN src/api/dashboard.ts-----
import apiClient from './client'
export interface DashboardStats {
users: { total: number; active: number; blocked: number }
approvals: { total: number; pending: number; revision: number; today: number }
topics: { total: number; active: number }
categories: number
departments: number
roles: number
executors: number
statusData: Array<{ status: string; count: number }>
dailyData: Array<{ date: string; created: number; approved: number }>
categoryBreakdown: Array<{
id: number
name: string
total_count: number
pending_count: number
}>
bottleneckApprovers: Array<{
user_id: number
full_name: string
department_name: string
pending_total: number
overdue_count: number
}>
oldPendingCount: number
// 🆕 Сколько дней считается "просрочкой" — приходит с бэкенда, чтобы
// не дублировать магическое число 7 ещё и на фронте.
oldPendingDays: number
// 🆕 Задачи: тот же формат, что statusData/dailyData у заявок
taskStatusData: Array<{ status: string; count: number }>
taskDailyData: Array<{ date: string; created: number; completed: number }>
// 🆕 Кто отсутствует сегодня (отгул/отпуск/больничный)
absentToday: Array<{ name: string; description: string }>
// 🆕 Точечные пробелы: право создавать заявку по теме есть, но
// порядок согласования для этого пользователя по ней не настроен.
topicGaps: Array<{
user_id: number
full_name: string
department_name: string
topic_id: number
topic_name: string
category_name: string
}>
// 🆕 Более базовый случай: у пользователя вообще нет ни одной
// строки иерархии для его отдела (даже глобального правила).
usersWithoutHierarchy: Array<{
user_id: number
full_name: string
department_name: string
}>
}
export const dashboardApi = {
// 🆕 Один endpoint — все данные сразу
getStats: () => apiClient.get<DashboardStats>('/dashboard/stats'),
}
-----END src/api/dashboard.ts-----
File: src/api/departments.ts
Lines: 46
-----BEGIN src/api/departments.ts-----
import apiClient from './client'
import type { Department, ApiResponse } from '@/types/api'
export interface DepartmentsListParams {
offset?: number
limit?: number
is_active?: boolean
name?: string
code?: string
}
export interface CreateDepartmentRequest {
name: string
code: string
description?: string
is_active?: boolean
}
export interface UpdateDepartmentRequest {
id: number
name?: string
code?: string
description?: string
is_active?: boolean
}
export const departmentsApi = {
// Получить список отделов с пагинацией и фильтрами
getList: (params: DepartmentsListParams = {}) =>
apiClient.get<ApiResponse<Department[]>>('/departments', { params }),
// Получить отдел по ID
getById: (id: number) =>
apiClient.get<Department>(`/departments/${id}`),
// Создать отдел
create: (data: CreateDepartmentRequest) =>
apiClient.post<Department>('/departments', data),
// Обновить отдел
update: (data: UpdateDepartmentRequest) =>
apiClient.put<Department>('/departments', data),
// Удалить отдел
delete: (id: number) =>
apiClient.delete<boolean>('/departments', { data: { id } }),
}
-----END src/api/departments.ts-----
File: src/api/flowNodes.ts
Lines: 99
-----BEGIN src/api/flowNodes.ts-----
import apiClient from './client'
import type { ApprovalFlowNode, ApiResponse } from '@/types/api'
export interface CreateFlowNodeRequest {
category_id: number
parent_id?: number | null
key: string
label: string
data_key?: string | null
data_value?: string | null
is_input?: boolean
input_key?: string | null
input_hint?: string | null
is_multi_select?: boolean
multi_select_key?: string | null
multi_select_value?: string | null
topic_code?: string | null
message_template?: string | null
code_template?: string | null
sort_order?: number
}
export interface UpdateFlowNodeRequest {
id: number
category_id?: number
parent_id?: number | null
key?: string
label?: string
data_key?: string | null
data_value?: string | null
is_input?: boolean
input_key?: string | null
input_hint?: string | null
is_multi_select?: boolean
multi_select_key?: string | null
multi_select_value?: string | null
topic_code?: string | null
message_template?: string | null
code_template?: string | null
sort_order?: number
}
export interface MoveFlowNodeRequest {
new_parent_id?: number | null
new_sort_order?: number
}
export interface SaveTreeRequest {
nodes: ApprovalFlowNode[]
}
// Живой предпросмотр: код темы + текст сообщения согласующему для
// конкретного набора ответов (collected: data_key -> data_value),
// посчитанные тем же движком, что использует боевой бот.
export interface PreviewFlowRequest {
collected: Record<string, string>
initiator_name?: string
}
export interface PreviewFlowResponse {
code: string
message: string
incomplete: boolean
topic_exists: boolean
topic_id?: number
topic_name?: string
}
export const flowNodesApi = {
getTree: (categoryId: number) =>
apiClient.get<ApiResponse<ApprovalFlowNode[]>>(`/flow-nodes/category/${categoryId}?limit=1000`),
getById: (id: number) =>
apiClient.get<ApprovalFlowNode>(`/flow-nodes/${id}`),
create: (data: CreateFlowNodeRequest) =>
apiClient.post<ApprovalFlowNode>('/flow-nodes/', data),
update: (data: UpdateFlowNodeRequest) =>
apiClient.put<ApprovalFlowNode>('/flow-nodes/', data),
delete: (id: number) =>
apiClient.delete<boolean>('/flow-nodes/', { data: { id } }),
saveTree: (categoryId: number, data: SaveTreeRequest) =>
apiClient.post<boolean>(`/flow-nodes/category/${categoryId}/tree`, data),
move: (id: number, data: MoveFlowNodeRequest) =>
apiClient.post<ApprovalFlowNode>(`/flow-nodes/${id}/move`, data),
duplicate: (id: number) =>
apiClient.post<ApprovalFlowNode>(`/flow-nodes/${id}/duplicate`, {}),
// НОВОЕ
preview: (categoryId: number, data: PreviewFlowRequest) =>
apiClient.post<PreviewFlowResponse>(`/flow-nodes/category/${categoryId}/preview`, data),
// НОВОЕ: форсировать обновление Registry в процессе бота (без перезапуска)
reloadBot: () => apiClient.post<boolean>('/flow-nodes/reload-bot', {}),
}
-----END src/api/flowNodes.ts-----
File: src/api/hierarchies.ts
Lines: 50
-----BEGIN src/api/hierarchies.ts-----
import apiClient from './client'
import type { UserHierarchy, ApiResponse } from '@/types/api'
export interface HierarchiesListParams {
offset?: number
limit?: number
subordinate_id?: number
approver_id?: number
department_id?: number
topic_category_id?: number
topic_id?: number
target_system?: string | null
}
export interface CreateHierarchyRequest {
subordinate_id: number
approver_id: number
department_id: number
topic_category_id?: number | null
topic_id?: number | null
priority?: number
target_system?: string | null
}
export interface UpdateHierarchyRequest {
id: number
subordinate_id?: number
approver_id?: number
department_id?: number
topic_category_id?: number | null
topic_id?: number | null
priority?: number
target_system?: string | null
}
export const hierarchiesApi = {
getList: (params: HierarchiesListParams = {}) =>
apiClient.get<ApiResponse<UserHierarchy[]>>('/hierarchies', { params }),
getById: (id: number) =>
apiClient.get<UserHierarchy>(`/hierarchies/${id}`),
create: (data: CreateHierarchyRequest) =>
apiClient.post<UserHierarchy>('/hierarchies', data),
update: (data: UpdateHierarchyRequest) =>
apiClient.put<UserHierarchy>('/hierarchies', data),
delete: (id: number) =>
apiClient.delete<boolean>('/hierarchies', { data: { id } }),
}
-----END src/api/hierarchies.ts-----
File: src/api/notifications.ts
Lines: 26
-----BEGIN src/api/notifications.ts-----
import apiClient from './client'
import type { Notification, ApiResponse, TargetFilters } from '@/types/api'
export interface NotificationsListParams {
offset?: number
limit?: number
status?: string
}
export interface CreateNotificationRequest {
title: string
message_html: string
photo_base64?: string
photo_file_name?: string
targets: TargetFilters
}
export const notificationsApi = {
getList: (params: NotificationsListParams = {}) =>
apiClient.get<ApiResponse<Notification[]>>('/notifications', { params }),
getById: (id: number) =>
apiClient.get<Notification>(`/notifications/${id}`),
create: (data: CreateNotificationRequest) =>
apiClient.post<Notification>('/notifications', data),
}
-----END src/api/notifications.ts-----
File: src/api/permissions.ts
Lines: 42
-----BEGIN src/api/permissions.ts-----
import apiClient from './client'
import type { Permission, ApiResponse } from '@/types/api'
export interface PermissionsListParams {
offset?: number
limit?: number
role_id?: number
action?: string
topic_category_id?: number
topic_id?: number
}
export interface CreatePermissionRequest {
role_id: number
topic_category_id?: number | null
topic_id?: number | null
action: string
}
export interface UpdatePermissionRequest {
id: number
role_id?: number
topic_category_id?: number | null
topic_id?: number | null
action?: string
}
export const permissionsApi = {
getList: (params: PermissionsListParams = {}) =>
apiClient.get<ApiResponse<Permission[]>>('/permissions', { params }),
getById: (id: number) =>
apiClient.get<Permission>(`/permissions/${id}`),
create: (data: CreatePermissionRequest) =>
apiClient.post<Permission>('/permissions', data),
update: (data: UpdatePermissionRequest) =>
apiClient.put<Permission>('/permissions', data),
delete: (id: number) =>
apiClient.delete<boolean>('/permissions', { data: { id } }),
}
-----END src/api/permissions.ts-----
File: src/api/roles.ts
Lines: 61
-----BEGIN src/api/roles.ts-----
import apiClient from './client'
import type { Role, ApiResponse } from '@/types/api'
export interface RolesListParams {
offset?: number
limit?: number
is_default?: boolean
is_director?: boolean
is_approver?: boolean
is_observer?: boolean
is_executor?: boolean
is_controller?: boolean
name?: string
code?: string
}
export interface CreateRoleRequest {
name: string
code: string
description?: string
is_default?: boolean
is_director?: boolean
is_approver?: boolean
is_observer?: boolean
is_executor?: boolean
is_controller?: boolean
}
export interface UpdateRoleRequest {
id: number
name?: string
code?: string
description?: string
is_default?: boolean
is_director?: boolean
is_approver?: boolean
is_observer?: boolean
is_executor?: boolean
is_controller?: boolean
}
export const rolesApi = {
// Получить список ролей с пагинацией и фильтрами
getList: (params: RolesListParams = {}) =>
apiClient.get<ApiResponse<Role[]>>('/roles', { params }),
// Получить роль по ID
getById: (id: number) =>
apiClient.get<Role>(`/roles/${id}`),
// Создать роль
create: (data: CreateRoleRequest) =>
apiClient.post<Role>('/roles', data),
// Обновить роль
update: (data: UpdateRoleRequest) =>
apiClient.put<Role>('/roles', data),
// Удалить роль
delete: (id: number) =>
apiClient.delete<boolean>('/roles', { data: { id } }),
}
-----END src/api/roles.ts-----
File: src/api/time.ts
Lines: 19
-----BEGIN src/api/time.ts-----
import axios from 'axios'
const publicApiClient = axios.create({
baseURL: '/api',
headers: {
'Content-Type': 'application/json',
},
})
export interface ServerTimeResponse {
timestamp: number
iso: string
}
export const timeApi = {
getServerTime: async (): Promise<ServerTimeResponse> => {
const response = await publicApiClient.get<ServerTimeResponse>('/time')
return response.data
},
}
-----END src/api/time.ts-----
File: src/api/topicExecutors.ts
Lines: 48
-----BEGIN src/api/topicExecutors.ts-----
import apiClient from './client'
import type { ApprovalTopicExecutor, ApiResponse } from '@/types/api'
export interface TopicExecutorsListParams {
offset?: number
limit?: number
topic_id?: number
user_id?: number
is_active?: boolean
target_system?: string
}
export interface CreateTopicExecutorRequest {
topic_id: number
user_id: number
step_order?: number
require_file?: boolean
task_text?: string | null
is_active?: boolean
target_system?: string
}
export interface UpdateTopicExecutorRequest {
id: number
topic_id?: number
user_id?: number
step_order?: number
require_file?: boolean
task_text?: string | null
is_active?: boolean
target_system?: string
}
export const topicExecutorsApi = {
getList: (params: TopicExecutorsListParams = {}) =>
apiClient.get<ApiResponse<ApprovalTopicExecutor[]>>('/topic-executors', { params }),
getById: (id: number) =>
apiClient.get<ApprovalTopicExecutor>(`/topic-executors/${id}`),
create: (data: CreateTopicExecutorRequest) =>
apiClient.post<ApprovalTopicExecutor>('/topic-executors', data),
update: (data: UpdateTopicExecutorRequest) =>
apiClient.put<ApprovalTopicExecutor>('/topic-executors', data),
delete: (id: number) =>
apiClient.delete<boolean>('/topic-executors', { data: { id } }),
}
-----END src/api/topicExecutors.ts-----
File: src/api/topics.ts
Lines: 78
-----BEGIN src/api/topics.ts-----
import apiClient from './client'
import type { ApprovalTopic, ApiResponse } from '@/types/api'
export interface TopicsListParams {
offset?: number
limit?: number
category_id?: number
is_active?: boolean
name?: string
code?: string
is_tree_root?: boolean
}
export interface CreateTopicRequest {
category_id: number
name: string
code: string
duration_type?: string
time_type?: string
is_tree_root?: boolean
payment_type?: string
template?: string | null
allows_file?: boolean
is_active?: boolean
allow_approver_selection?: boolean
first_approver_role_code?: string | null
allow_observer_selection?: boolean
allow_delegation_selection?: boolean
approval_mode?: string
require_approver_comment?: boolean
requires_file?: boolean
require_observer_selection?: boolean
instructions?: string | null
message_template?: string | null
code_template?: string | null
}
export interface UpdateTopicRequest {
id: number
category_id?: number
name?: string
code?: string
duration_type?: string
time_type?: string
payment_type?: string
is_tree_root?: boolean
template?: string | null
allows_file?: boolean
is_active?: boolean
allow_approver_selection?: boolean
first_approver_role_code?: string | null
allow_observer_selection?: boolean
// 🆕 см. CreateTopicRequest.allow_delegation_selection
allow_delegation_selection?: boolean
approval_mode?: string
require_approver_comment?: boolean
requires_file?: boolean
require_observer_selection?: boolean
instructions?: string | null
message_template?: string | null
code_template?: string | null
}
export const topicsApi = {
getList: (params: TopicsListParams = {}) =>
apiClient.get<ApiResponse<ApprovalTopic[]>>('/topics', { params }),
getById: (id: number) =>
apiClient.get<ApprovalTopic>(`/topics/${id}`),
create: (data: CreateTopicRequest) =>
apiClient.post<ApprovalTopic>('/topics', data),
update: (data: UpdateTopicRequest) =>
apiClient.put<ApprovalTopic>('/topics', data),
delete: (id: number) =>
apiClient.delete<boolean>('/topics', { data: { id } }),
}
-----END src/api/topics.ts-----
File: src/api/userRoles.ts
Lines: 16
-----BEGIN src/api/userRoles.ts-----
import apiClient from './client'
import type { UserRole, ApiResponse } from '@/types/api'
export interface BulkAssignRolesRequest {
user_id: number
role_ids: number[]
}
export const userRolesApi = {
// Получить роли пользователя
getByUserId: (userId: number) =>
apiClient.get<ApiResponse<UserRole[]>>(`/users/${userId}/roles`),
// Массовое назначение ролей (полная замена)
bulkAssign: (data: BulkAssignRolesRequest) =>
apiClient.post<ApiResponse<UserRole[]>>('/user-roles/bulk', data),
}
-----END src/api/userRoles.ts-----
File: src/api/users.ts
Lines: 33
-----BEGIN src/api/users.ts-----
import apiClient from './client'
import type { User, ApiResponse } from '@/types/api'
export interface UsersListParams {
offset?: number
limit?: number
is_blocked?: boolean
is_fired?: boolean
department_id?: number
full_name?: string
role_ids?: number[]
}
export interface UpdateUserRequest {
id: number
full_name?: string
department_id?: number | null
is_blocked?: boolean
is_fired?: boolean
}
export const usersApi = {
getList: (params: UsersListParams = {}) =>
apiClient.get<ApiResponse<User[]>>('/users', { params }),
getById: (id: number) =>
apiClient.get<User>(`/users/${id}`),
update: (data: UpdateUserRequest) =>
apiClient.put<User>('/users', data),
delete: (id: number) =>
apiClient.delete(`/users/${id}`),
}
-----END src/api/users.ts-----
File: src/features/adminLogs/hooks/useAdminLogs.ts
Lines: 37
-----BEGIN src/features/adminLogs/hooks/useAdminLogs.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { adminLogsApi, type AdminLogsListParams } from '@/api/adminLogs'
import { notifications } from '@mantine/notifications'
export const ADMIN_LOGS_QUERY_KEY = 'admin-logs'
export function useAdminLogs(params: AdminLogsListParams = {}) {
return useQuery({
queryKey: [ADMIN_LOGS_QUERY_KEY, params],
queryFn: async () => {
const response = await adminLogsApi.getList(params)
return response.data
},
})
}
export function useDeleteAdminLog() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => adminLogsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ADMIN_LOGS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Запись журнала удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить запись (доступно только root-администратору)',
color: 'red',
})
},
})
}
-----END src/features/adminLogs/hooks/useAdminLogs.ts-----
File: src/features/admins/hooks/useAdmins.ts
Lines: 116
-----BEGIN src/features/admins/hooks/useAdmins.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { adminsApi, type AdminsListParams, type CreateAdminRequest, type UpdateAdminRequest } from '@/api/admins'
import { notifications } from '@mantine/notifications'
export const ADMINS_QUERY_KEY = 'admins'
export function useAdmins(params: AdminsListParams = {}) {
return useQuery({
queryKey: [ADMINS_QUERY_KEY, params],
queryFn: async () => {
const response = await adminsApi.getList(params)
return response.data
},
})
}
export function useCreateAdmin() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: async (data: CreateAdminRequest) => {
const response = await adminsApi.create(data)
return response.data
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ADMINS_QUERY_KEY] })
},
onError: (error: any) => {
const errorMsg = error.response?.data?.error_description || ''
let message = 'Не удалось создать администратора'
if (errorMsg === 'admin_is_not_available') {
message = 'Администратор с таким логином уже существует'
} else if (errorMsg === 'only_root_can_create_admins') {
message = 'Только root-администратор может создавать новых администраторов'
} else if (errorMsg === 'telegram_id_required_for_observer') {
message = 'Для наблюдателя необходимо указать Telegram-аккаунт'
} else if (errorMsg === 'telegram_user_not_found') {
message = 'Пользователь с таким Telegram ID не найден в боте'
}
notifications.show({
title: 'Ошибка',
message,
color: 'red',
})
},
})
}
export function useUpdateAdmin() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateAdminRequest) => adminsApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ADMINS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Администратор обновлен',
color: 'green',
})
},
onError: (error: any) => {
const errorMsg = error.response?.data?.error_description || ''
let message = 'Не удалось обновить администратора'
if (errorMsg === 'cannot_block_root') {
message = 'Нельзя заблокировать root-администратора'
} else if (errorMsg === 'cannot_block_self') {
message = 'Нельзя заблокировать свой собственный аккаунт'
} else if (errorMsg === 'telegram_id_required_for_observer') {
message = 'Для наблюдателя необходимо указать Telegram-аккаунт'
} else if (errorMsg === 'telegram_user_not_found') {
message = 'Пользователь с таким Telegram ID не найден в боте'
}
notifications.show({
title: 'Ошибка',
message,
color: 'red',
})
},
})
}
export function useDeleteAdmin() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => adminsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ADMINS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Администратор удален',
color: 'green',
})
},
onError: (error: any) => {
const errorMsg = error.response?.data?.error_description || ''
let message = 'Не удалось удалить администратора'
if (errorMsg === 'cannot_delete_self') {
message = 'Нельзя удалить свой собственный аккаунт'
} else if (errorMsg === 'cannot_delete_root') {
message = 'Нельзя удалить root-администратора'
}
notifications.show({
title: 'Ошибка',
message,
color: 'red',
})
},
})
}
-----END src/features/admins/hooks/useAdmins.ts-----
File: src/features/approvalTasks/const.ts
Lines: 19
-----BEGIN src/features/approvalTasks/const.ts-----
export const TASK_STATUSES = [
{ value: 'pending', label: 'В ожидании', color: 'blue', icon: 'clock' },
{ value: 'waiting', label: 'Ожидает', color: 'orange', icon: 'hourglass' },
{ value: 'completed', label: 'Выполнена', color: 'green', icon: 'check' },
{ value: 'cancelled', label: 'Отменена', color: 'gray', icon: 'x' },
] as const
export const STATUS_COLORS: Record<string, string> = {
pending: 'blue',
waiting: 'orange',
completed: 'green',
cancelled: 'gray',
}
export const STATUS_LABELS: Record<string, string> = {
pending: 'В ожидании',
waiting: 'Ожидает',
completed: 'Выполнена',
cancelled: 'Отменена',
}
-----END src/features/approvalTasks/const.ts-----
File: src/features/approvalTasks/hooks/useApprovalTasks.ts
Lines: 76
-----BEGIN src/features/approvalTasks/hooks/useApprovalTasks.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
approvalTasksApi,
type ApprovalTasksListParams,
type UpdateApprovalTaskRequest
} from '@/api/approvalTasks'
import { notifications } from '@mantine/notifications'
export const APPROVAL_TASKS_QUERY_KEY = 'approval-tasks'
export function useApprovalTasks(params: ApprovalTasksListParams = {}) {
return useQuery({
queryKey: [APPROVAL_TASKS_QUERY_KEY, params],
queryFn: async () => {
const response = await approvalTasksApi.getList(params)
return response.data
},
})
}
export function useApprovalTask(id: number | null) {
return useQuery({
queryKey: ['approval-task', id],
queryFn: async () => {
if (!id) return null
const response = await approvalTasksApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useUpdateApprovalTask() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateApprovalTaskRequest) => approvalTasksApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [APPROVAL_TASKS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Задача обновлена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить задачу',
color: 'red',
})
},
})
}
export function useDeleteApprovalTask() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => approvalTasksApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [APPROVAL_TASKS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Задача удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить задачу',
color: 'red',
})
},
})
}
-----END src/features/approvalTasks/hooks/useApprovalTasks.ts-----
File: src/features/approvals/hooks/useApprovals.ts
Lines: 150
-----BEGIN src/features/approvals/hooks/useApprovals.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
approvalsApi,
type ApprovalsListParams,
type ApprovalsReportParams,
type UpdateApprovalRequest
} from '@/api/approvals'
import { notifications } from '@mantine/notifications'
export const APPROVALS_QUERY_KEY = 'approvals'
export function useApprovals(params: ApprovalsListParams = {}) {
return useQuery({
queryKey: [APPROVALS_QUERY_KEY, params],
queryFn: async () => {
const response = await approvalsApi.getList(params)
return response.data
},
})
}
export function useApprovalTasks(approvalId: number | null) {
return useQuery({
queryKey: ['approval-tasks', approvalId],
queryFn: async () => {
if (!approvalId) return null
const response = await approvalsApi.getTasks(approvalId)
return response.data
},
enabled: !!approvalId,
})
}
export function useApproval(id: number | null) {
return useQuery({
queryKey: ['approval', id],
queryFn: async () => {
if (!id) return null
const response = await approvalsApi.getById(id)
return response.data
},
enabled: !!id,
})
}
// 🆕 Хук для получения заявок по отчёту (с фильтрами по датам)
export function useApprovalsReport(params: ApprovalsReportParams = {}) {
return useQuery({
queryKey: ['approvals-report', params],
queryFn: async () => {
const response = await approvalsApi.getForReport(params)
return response.data.data || []
},
enabled: false, // Запускаем вручную
})
}
export function useUpdateApproval() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateApprovalRequest) => approvalsApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [APPROVALS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Заявка обновлена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить заявку',
color: 'red',
})
},
})
}
export function useDeleteApproval() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => approvalsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [APPROVALS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Заявка удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить заявку',
color: 'red',
})
},
})
}
export function useAdditionalApprovers(approvalId: number | null) {
return useQuery({
queryKey: ['approval-additional-approvers', approvalId],
queryFn: async () => {
if (!approvalId) return null
const response = await approvalsApi.getAdditionalApprovers(approvalId)
return response.data
},
enabled: !!approvalId,
})
}
export function useApprovalComments(approvalId: number | null) {
return useQuery({
queryKey: ['approval-comments', approvalId],
queryFn: async () => {
if (!approvalId) return null
const response = await approvalsApi.getComments(approvalId)
return response.data
},
enabled: !!approvalId,
})
}
export function useApprovalObservers(approvalId: number | null) {
return useQuery({
queryKey: ['approval-observers', approvalId],
queryFn: async () => {
if (!approvalId) return null
const response = await approvalsApi.getObservers(approvalId)
return response.data
},
enabled: !!approvalId,
})
}
export function useRevocationRequest(approvalId: number | null) {
return useQuery({
queryKey: ['approval-revocation-request', approvalId],
queryFn: async () => {
if (!approvalId) return null
const response = await approvalsApi.getRevocationRequest(approvalId)
return response.data
},
enabled: !!approvalId,
})
}
-----END src/features/approvals/hooks/useApprovals.ts-----
File: src/features/categories/hooks/useCategories.ts
Lines: 100
-----BEGIN src/features/categories/hooks/useCategories.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
categoriesApi,
type CategoriesListParams,
type CreateCategoryRequest,
type UpdateCategoryRequest
} from '@/api/categories'
import { notifications } from '@mantine/notifications'
export const CATEGORIES_QUERY_KEY = 'categories'
export function useCategories(params: CategoriesListParams = {}) {
return useQuery({
queryKey: [CATEGORIES_QUERY_KEY, params],
queryFn: async () => {
const response = await categoriesApi.getList(params)
return response.data
},
})
}
export function useCategory(id: number | null) {
return useQuery({
queryKey: ['category', id],
queryFn: async () => {
if (!id) return null
const response = await categoriesApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useCreateCategory() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateCategoryRequest) => categoriesApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [CATEGORIES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Категория создана',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось создать категорию',
color: 'red',
})
},
})
}
export function useUpdateCategory() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateCategoryRequest) => categoriesApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [CATEGORIES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Категория обновлена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить категорию',
color: 'red',
})
},
})
}
export function useDeleteCategory() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => categoriesApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [CATEGORIES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Категория удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить категорию',
color: 'red',
})
},
})
}
-----END src/features/categories/hooks/useCategories.ts-----
File: src/features/departments/hooks/useDepartments.ts
Lines: 100
-----BEGIN src/features/departments/hooks/useDepartments.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
departmentsApi,
type DepartmentsListParams,
type CreateDepartmentRequest,
type UpdateDepartmentRequest
} from '@/api/departments'
import { notifications } from '@mantine/notifications'
export const DEPARTMENTS_QUERY_KEY = 'departments'
export function useDepartments(params: DepartmentsListParams = {}) {
return useQuery({
queryKey: [DEPARTMENTS_QUERY_KEY, params],
queryFn: async () => {
const response = await departmentsApi.getList(params)
return response.data
},
})
}
export function useDepartment(id: number | null) {
return useQuery({
queryKey: ['department', id],
queryFn: async () => {
if (!id) return null
const response = await departmentsApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useCreateDepartment() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateDepartmentRequest) => departmentsApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [DEPARTMENTS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Отдел создан',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось создать отдел',
color: 'red',
})
},
})
}
export function useUpdateDepartment() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateDepartmentRequest) => departmentsApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [DEPARTMENTS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Отдел обновлен',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить отдел',
color: 'red',
})
},
})
}
export function useDeleteDepartment() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => departmentsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [DEPARTMENTS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Отдел удален',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить отдел',
color: 'red',
})
},
})
}
-----END src/features/departments/hooks/useDepartments.ts-----
File: src/features/flowNodes/hooks/useFlowNodes.ts
Lines: 179
-----BEGIN src/features/flowNodes/hooks/useFlowNodes.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
flowNodesApi,
type CreateFlowNodeRequest,
type UpdateFlowNodeRequest,
type MoveFlowNodeRequest,
type PreviewFlowRequest,
} from '@/api/flowNodes'
import { notifications } from '@mantine/notifications'
export const FLOW_NODES_QUERY_KEY = 'flowNodes'
export function useFlowNodesTree(categoryId: number | null) {
return useQuery({
queryKey: [FLOW_NODES_QUERY_KEY, categoryId],
queryFn: async () => {
if (!categoryId) return null
const response = await flowNodesApi.getTree(categoryId)
return response.data
},
enabled: !!categoryId,
})
}
export function useCreateFlowNode() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateFlowNodeRequest) => flowNodesApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
notifications.show({ title: 'Готово', message: 'Кнопка/шаг добавлены', color: 'green' })
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message: error.response?.data?.error_description || 'Не удалось сохранить',
color: 'red',
})
},
})
}
export function useUpdateFlowNode() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateFlowNodeRequest) => flowNodesApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
notifications.show({ title: 'Готово', message: 'Изменения сохранены', color: 'green' })
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message: error.response?.data?.error_description || 'Не удалось сохранить изменения',
color: 'red',
})
},
})
}
export function useDeleteFlowNode() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => flowNodesApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
notifications.show({ title: 'Готово', message: 'Шаг удалён', color: 'green' })
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message: error.response?.data?.error_description || 'Не удалось удалить',
color: 'red',
})
},
})
}
// Перемещение узла — используется для ↑/↓ среди соседей и для
// "поднять/опустить уровень" точечно (см. treeWalk.ts).
export function useMoveFlowNode() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: ({ id, data }: { id: number; data: MoveFlowNodeRequest }) => flowNodesApi.move(id, data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message: error.response?.data?.error_description || 'Не удалось переместить',
color: 'red',
})
},
})
}
// НОВОЕ: пакетное перемещение для drag&drop — план из buildReorderPlan
// (см. treeFlatten.ts) может включать несколько узлов сразу (переиндексация
// старой и новой групп соседей). Отправляем всё параллельно и обновляем
// дерево ОДНИМ инвалидейтом в конце, а не на каждый отдельный вызов —
// иначе список будет дёргаться на каждом промежуточном ответе.
export function useReorderNodes() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: async (ops: { id: number; new_parent_id: number | null; new_sort_order: number }[]) => {
await Promise.all(
ops.map((op) =>
flowNodesApi.move(op.id, { new_parent_id: op.new_parent_id, new_sort_order: op.new_sort_order })
)
)
},
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message:
error.response?.data?.error_description || 'Не удалось переместить шаг — дерево вернётся к прежнему виду',
color: 'red',
})
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
},
})
}
export function useDuplicateFlowNode() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => flowNodesApi.duplicate(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [FLOW_NODES_QUERY_KEY] })
notifications.show({ title: 'Готово', message: 'Шаг скопирован', color: 'green' })
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message: error.response?.data?.error_description || 'Не удалось скопировать',
color: 'red',
})
},
})
}
// НОВОЕ: живой предпросмотр — код темы + текст сообщения согласующему
// для конкретного набора выборов. Не мутирует данные, поэтому это
// useMutation, вызываемый вручную (а не useQuery), чтобы не дёргать
// сервер на каждое нажатие клавиши, а только по явному запросу/дебаунсу.
// НОВОЕ: кнопка "Обновить бота" — форсирует у бота перечитывание дерева тем
// из БД, не дожидаясь фонового тика (см. reload_watcher.go в telegram_service).
export function useReloadBot() {
return useMutation({
mutationFn: () => flowNodesApi.reloadBot(),
onSuccess: () => {
notifications.show({
title: 'Готово',
message: 'Бот обновит список тем в течение нескольких секунд',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Не получилось',
message: error.response?.data?.error_description || 'Не удалось обновить бота',
color: 'red',
})
},
})
}
export function usePreviewFlow(categoryId: number | null) {
return useMutation({
mutationFn: async (data: PreviewFlowRequest) => {
if (!categoryId) throw new Error('categoryId is required')
const response = await flowNodesApi.preview(categoryId, data)
return response.data // разворачиваем AxiosResponse -> PreviewFlowResponse
},
})
}
-----END src/features/flowNodes/hooks/useFlowNodes.ts-----
File: src/features/flowNodes/utils/flattenTree.ts
Lines: 127
-----BEGIN src/features/flowNodes/utils/flattenTree.ts-----
import { arrayMove } from '@dnd-kit/sortable'
import type { ApprovalFlowNode } from '@/types/api'
export interface FlatFlowNode extends ApprovalFlowNode {
depth: number
}
// Разворачивает дерево в плоский список для отображения в виде сортируемого
// списка. parent_id уже есть на каждом узле (приходит с бэкенда) — отдельно
// его не вычисляем.
export function flattenTree(nodes: ApprovalFlowNode[], collapsed: Set<number>): FlatFlowNode[] {
const result: FlatFlowNode[] = []
const walk = (list: ApprovalFlowNode[], depth: number) => {
for (const node of list) {
result.push({ ...node, depth })
if (node.children?.length && node.id != null && !collapsed.has(node.id)) {
walk(node.children, depth + 1)
}
}
}
walk(nodes, 0)
return result
}
export interface Projection {
depth: number
parentId: number | null
}
// Классический алгоритм проекции для sortable-дерева (как в примере
// "Sortable Tree" из документации dnd-kit): по горизонтальному смещению
// курсора во время перетаскивания решаем, на какую глубину и к какому
// родителю попадёт узел, если отпустить его над overId прямо сейчас.
//
// ВАЖНО: глубина никогда не может быть 0 — на верхнем уровне дерева
// категории всегда должен быть ровно один узел (корень с ключом, равным
// коду раздела), и он не участвует в перетаскивании.
export function getProjection(
items: FlatFlowNode[],
activeId: number,
overId: number,
dragOffsetX: number,
indentationWidth: number
): Projection {
const activeItemIndex = items.findIndex((n) => n.id === activeId)
const overItemIndex = items.findIndex((n) => n.id === overId)
if (activeItemIndex === -1 || overItemIndex === -1) {
return { depth: 1, parentId: null }
}
const activeItem = items[activeItemIndex]
const newItems = arrayMove(items, activeItemIndex, overItemIndex)
const previousItem = newItems[overItemIndex - 1]
const nextItem = newItems[overItemIndex + 1]
const dragDepthDelta = Math.round(dragOffsetX / indentationWidth)
const projectedDepth = activeItem.depth + dragDepthDelta
const maxDepth = Math.max(previousItem ? previousItem.depth + 1 : 1, 1)
const minDepth = Math.max(nextItem ? nextItem.depth : 1, 1)
let depth = projectedDepth
if (depth > maxDepth) depth = maxDepth
if (depth < minDepth) depth = minDepth
let parentId: number | null = null
if (previousItem) {
if (depth === previousItem.depth) {
parentId = previousItem.parent_id ?? null
} else if (depth > previousItem.depth) {
parentId = previousItem.id ?? null
} else {
const newParent = [...newItems]
.slice(0, overItemIndex)
.reverse()
.find((n) => n.depth === depth)
parentId = newParent?.parent_id ?? null
}
}
return { depth, parentId }
}
export interface MoveOp {
id: number
new_parent_id: number | null
new_sort_order: number
}
// Строит план обновлений после drag&drop одного узла: полностью
// переиндексирует группу соседей, откуда узел ушёл, и группу, куда он
// попал (несколько лишних вызовов API по сравнению со строгим минимумом,
// зато гарантированно нет дублей/дыр в sort_order).
export function buildReorderPlan(
tree: ApprovalFlowNode[],
activeId: number,
newParentId: number | null,
overId: number
): MoveOp[] {
const flat = flattenTree(tree, new Set())
const active = flat.find((n) => n.id === activeId)
if (!active) return []
const oldParentId = active.parent_id ?? null
const oldSiblings = flat.filter((n) => (n.parent_id ?? null) === oldParentId && n.id !== activeId)
const newSiblingsWithoutActive = flat.filter((n) => (n.parent_id ?? null) === newParentId && n.id !== activeId)
const overIdx = newSiblingsWithoutActive.findIndex((n) => n.id === overId)
const insertAt = overIdx === -1 ? newSiblingsWithoutActive.length : overIdx
const newSiblings = [...newSiblingsWithoutActive]
newSiblings.splice(insertAt, 0, active)
const ops: MoveOp[] = newSiblings.map((n, idx) => ({
id: n.id!,
new_parent_id: newParentId,
new_sort_order: idx,
}))
if (oldParentId !== newParentId) {
oldSiblings.forEach((n, idx) => {
ops.push({ id: n.id!, new_parent_id: oldParentId, new_sort_order: idx })
})
}
return ops
}
-----END src/features/flowNodes/utils/flattenTree.ts-----
File: src/features/flowNodes/utils/treeWalk.ts
Lines: 222
-----BEGIN src/features/flowNodes/utils/treeWalk.ts-----
import type { ApprovalFlowNode } from '@/types/api'
// ============================================================
// Базовый обход дерева
// ============================================================
export function findParent(
nodes: ApprovalFlowNode[],
targetId: number,
parent: ApprovalFlowNode | null = null
): ApprovalFlowNode | null {
for (const node of nodes) {
if (node.id === targetId) return parent
if (node.children) {
const found = findParent(node.children, targetId, node)
if (found) return found
}
}
return null
}
export function findNodeById(nodes: ApprovalFlowNode[], targetId: number): ApprovalFlowNode | null {
for (const node of nodes) {
if (node.id === targetId) return node
if (node.children) {
const found = findNodeById(node.children, targetId)
if (found) return found
}
}
return null
}
// Путь от корня дерева категории до узла (включительно). Нужен, чтобы
// посчитать, какие data_key/data_value уже "накопились" на этом пути —
// именно так реальный бот собирает `collected` при прохождении сценария.
export function getPathToNode(tree: ApprovalFlowNode[], targetId: number): ApprovalFlowNode[] {
const path: ApprovalFlowNode[] = []
const walk = (nodes: ApprovalFlowNode[]): boolean => {
for (const n of nodes) {
path.push(n)
if (n.id === targetId) return true
if (n.children && walk(n.children)) return true
path.pop()
}
return false
}
walk(tree)
return path
}
// Собирает collected (data_key -> data_value) по цепочке узлов пути.
// Мультиселект-узлы на одном пути объединяются через запятую — это
// приближение (реальный пользователь может выбрать несколько узлов
// мультиселекта одновременно), для целей предпросмотра/проверки этого
// достаточно.
export function collectFromPath(path: ApprovalFlowNode[]): Record<string, string> {
const collected: Record<string, string> = {}
for (const n of path) {
if (n.data_key && n.data_value) {
collected[n.data_key] = n.data_value
}
if (n.multi_select_key && n.multi_select_value) {
collected[n.multi_select_key] = collected[n.multi_select_key]
? `${collected[n.multi_select_key]},${n.multi_select_value}`
: n.multi_select_value
}
}
return collected
}
// Все пути от корня до "концов" дерева (узел без детей ИЛИ узел
// текстового ввода — именно на нём сценарий завершается и определяется
// тема заявки).
export function collectLeafPaths(tree: ApprovalFlowNode[]): ApprovalFlowNode[][] {
const leaves: ApprovalFlowNode[][] = []
const walk = (nodes: ApprovalFlowNode[], path: ApprovalFlowNode[]) => {
for (const n of nodes) {
const nextPath = [...path, n]
if (n.is_input || !n.children || n.children.length === 0) {
leaves.push(nextPath)
} else {
walk(n.children, nextPath)
}
}
}
walk(tree, [])
return leaves
}
export function pathLabel(path: ApprovalFlowNode[]): string {
return path.map((n) => n.label).join(' → ')
}
// ============================================================
// Перемещение по уровням ("поднять/опустить уровень")
// ============================================================
export interface MoveTarget {
new_parent_id: number | null
new_sort_order: number
}
// "Поднять уровень": узел становится соседом своего текущего родителя
// (переходит на уровень выше), а не остаётся его ребёнком.
export function getPromoteMove(tree: ApprovalFlowNode[], node: ApprovalFlowNode): MoveTarget | null {
if (!node.id) return null
const parent = findParent(tree, node.id)
if (!parent || !parent.id) return null // узел уже на самом верхнем уровне
const grandParent = findParent(tree, parent.id)
const grandSiblings = grandParent ? grandParent.children || [] : tree
const parentIndex = grandSiblings.findIndex((n) => n.id === parent.id)
return {
new_parent_id: grandParent?.id ?? null,
new_sort_order: parentIndex + 1,
}
}
// "Опустить уровень": узел становится последним ребёнком своего
// предыдущего соседа (вкладывается на уровень ниже).
export function getDemoteMove(tree: ApprovalFlowNode[], node: ApprovalFlowNode): MoveTarget | null {
if (!node.id) return null
const parent = findParent(tree, node.id)
const siblings = parent ? parent.children || [] : tree
const index = siblings.findIndex((n) => n.id === node.id)
if (index <= 0) return null // нет предыдущего соседа, чтобы вложиться в него
const newParent = siblings[index - 1]
if (!newParent.id) return null
return {
new_parent_id: newParent.id,
new_sort_order: newParent.children?.length ?? 0,
}
}
// ============================================================
// Черновик шаблона сообщения
// ============================================================
// Бэкенд теперь умеет подставлять "{{.key_label}}" для ЛЮБОГО DataKey — не
// только для зашитого в addLabelMappings списка (см. DYNAMIC_TOPIC_PATCH.txt:
// addTreeLabelMappings берёт подпись прямо из Label узла дерева, с приоритетом
// над старым хардкодом). Поэтому черновик сообщения теперь всегда предлагает
// "_label"-версию — она либо подставится из названия соответствующей кнопки,
// либо (для совсем старых зашитых значений) из старой карты addLabelMappings.
function placeholderFor(key: string): string {
return `{{.${key}_label}}`
}
// Собирает ВСЕ DataKey/MultiSelectKey по всему дереву, а не только у
// прямых детей корня — на любой глубине вложенности.
export function collectAllDataKeys(node: ApprovalFlowNode): string[] {
const acc: string[] = []
const walk = (n: ApprovalFlowNode) => {
for (const child of n.children || []) {
if (child.data_key) acc.push(child.data_key)
if (child.multi_select_key) acc.push(child.multi_select_key)
if (child.children?.length) walk(child)
}
}
walk(node)
return Array.from(new Set(acc))
}
// Ищет DataKey/MultiSelectKey, которые реально встречаются в дереве, но не
// упомянуты в шаблоне кода темы. Эвристика: ищем подстроку ".ключ" —
// покрывает и {{.branch}}, и {{if .branch}}, и {{if eq .branch "..."}}.
// Пустой шаблон означает автосборку кода (см. TopicCodeFromCollected на
// бэкенде) — она и так подхватывает любые ключи сама, предупреждать не о чем.
export function findMissingKeysInCodeTemplate(root: ApprovalFlowNode, codeTemplate: string): string[] {
if (!codeTemplate) return []
return collectAllDataKeys(root).filter((k) => !codeTemplate.includes(`.${k}`))
}
// Строит кусок шаблона для одного "потерянного" ключа — оборачиваем в
// {{if}}, чтобы не сломать ветки, где этого ключа нет вообще (например,
// более старые темы категории, у которых на один уровень вложенности
// меньше).
export function buildMissingKeySegment(key: string): string {
return `{{if .${key}}}_{{.${key}}}{{end}}`
}
// Генерирует ЧЕРНОВИК Go-шаблона сообщения согласующему. Это стартовая
// точка, а не готовое решение — админ должен проверить результат через
// живой предпросмотр и доработать формулировки при необходимости.
//
// Заголовок строится по первому уровню развилок (как раньше) — это
// обычно самое важное различие между ветками, поэтому его выносим в
// заголовок сообщения. А дальше — отдельной строкой на каждый DataKey,
// который вообще встречается в дереве, НА ЛЮБОЙ глубине. Каждая такая
// строка обёрнута в {{if .key}}...{{end}} и поэтому появляется в
// сообщении, только если сотрудник реально прошёл через тот шаг, где
// этот ключ собирается — остальные строки просто не покажутся, это
// нормально для дерева с разными по длине ветками.
export function generateDraftMessageTemplate(root: ApprovalFlowNode): string {
const children = root.children || []
const withDataKey = children.filter((c) => c.data_key && c.data_value)
let titleKey: string | undefined
let title = root.label
if (withDataKey.length > 0) {
const dataKey = withDataKey[0].data_key
const uniform = withDataKey.every((c) => c.data_key === dataKey)
if (uniform && dataKey) {
titleKey = dataKey
let chain = ''
withDataKey.forEach((c, i) => {
const cond = `eq .${dataKey} "${c.data_value}"`
chain += i === 0 ? `{{if ${cond}}}${c.label}` : `{{else if ${cond}}}${c.label}`
})
chain += `{{else}}${root.label}{{end}}`
title = chain
}
}
const bodyKeys = collectAllDataKeys(root).filter((k) => k !== titleKey)
const bodyLines = bodyKeys.map((k) => `{{if .${k}}}${k}: ${placeholderFor(k)}\n{{end}}`).join('')
return `📋 <b>${title}</b>\n${bodyLines}\n<b>{{.initiator_name}}</b>:\n{{.content}}`
}
-----END src/features/flowNodes/utils/treeWalk.ts-----
File: src/features/hierarchies/hooks/useHierarchies.ts
Lines: 88
-----BEGIN src/features/hierarchies/hooks/useHierarchies.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
hierarchiesApi,
type HierarchiesListParams,
type CreateHierarchyRequest,
type UpdateHierarchyRequest
} from '@/api/hierarchies'
import { notifications } from '@mantine/notifications'
export const HIERARCHIES_QUERY_KEY = 'hierarchies'
export function useHierarchies(params: HierarchiesListParams = {}) {
return useQuery({
queryKey: [HIERARCHIES_QUERY_KEY, params],
queryFn: async () => {
const response = await hierarchiesApi.getList({ limit: 1000, ...params })
return response.data
},
})
}
export function useCreateHierarchy() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateHierarchyRequest) => hierarchiesApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [HIERARCHIES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Связь создана',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось создать связь',
color: 'red',
})
},
})
}
export function useUpdateHierarchy() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateHierarchyRequest) => hierarchiesApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [HIERARCHIES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Связь обновлена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить связь',
color: 'red',
})
},
})
}
export function useDeleteHierarchy() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => hierarchiesApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [HIERARCHIES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Связь удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить связь',
color: 'red',
})
},
})
}
-----END src/features/hierarchies/hooks/useHierarchies.ts-----
File: src/features/hierarchies/hooks/useSystemOptions.ts
Lines: 72
-----BEGIN src/features/hierarchies/hooks/useSystemOptions.ts-----
import { useQuery } from '@tanstack/react-query'
import { useCategories } from '@/features/categories/hooks/useCategories'
import { useFlowNodesTree } from '@/features/flowNodes/hooks/useFlowNodes'
import { flowNodesApi } from '@/api/flowNodes'
import type { ApprovalFlowNode } from '@/types/api'
export interface SystemOption {
value: string
label: string
}
function extractSystemOptions(nodes: ApprovalFlowNode[] | null | undefined): SystemOption[] {
if (!nodes) return []
const seen = new Map<string, string>()
// Рекурсивный обход всех вложенностей
function traverse(nodeList: ApprovalFlowNode[]) {
for (const n of nodeList) {
// Ищем мультиселект с ключом systems
if (n.is_multi_select && n.multi_select_key === 'systems' && n.multi_select_value) {
if (!seen.has(n.multi_select_value)) {
seen.set(n.multi_select_value, n.label || n.multi_select_value)
}
}
// Погружаемся в дочерние узлы
if (n.children && n.children.length > 0) {
traverse(n.children)
}
}
}
traverse(nodes)
return Array.from(seen.entries()).map(([value, label]) => ({ value, label }))
}
export function useCategorySystemOptions(categoryId: number | null) {
const { data, isLoading } = useFlowNodesTree(categoryId)
const options = extractSystemOptions(data?.data)
return { options, isLoading: categoryId ? isLoading : false }
}
export function useAllSystemOptions(enabled: boolean = true) {
const { data: categories } = useCategories({ limit: 1000 })
const categoryIds = (categories?.data ?? [])
.map((c) => c.id)
.filter((id): id is number => !!id)
// Используем один запрос и последовательно опрашиваем категории, чтобы избежать 429 Too Many Requests
const { data: options = [], isLoading } = useQuery({
queryKey: ['all-systems-scan', categoryIds],
queryFn: async () => {
const seen = new Map<string, string>()
for (const id of categoryIds) {
try {
const response = await flowNodesApi.getTree(id)
const opts = extractSystemOptions(response.data?.data)
opts.forEach(o => {
if (!seen.has(o.value)) seen.set(o.value, o.label)
})
} catch (e) {
console.warn(`[useAllSystemOptions] Ошибка загрузки дерева для категории ${id}`, e)
}
}
return Array.from(seen.entries()).map(([value, label]) => ({ value, label }))
},
enabled: enabled && categoryIds.length > 0,
})
return { options, isLoading }
}
export const ALL_SYSTEMS_VALUE = 'all'
-----END src/features/hierarchies/hooks/useSystemOptions.ts-----
File: src/features/hierarchies/utils.ts
Lines: 85
-----BEGIN src/features/hierarchies/utils.ts-----
import type { UserHierarchy } from '@/types/api'
// Тип области действия
export type ScopeType = 'global' | 'category' | 'topic'
// Группа цепочек (по подчинённому + отделу + области действия)
export interface ChainGroup {
key: string
subordinateId: number
subordinateName: string
departmentId: number
departmentName: string
scopeType: ScopeType
scopeObjectId: number | null
scopeObjectName: string
steps: UserHierarchy[] // Отсортированы по priority
}
// Определяем тип области действия
export function getScopeType(h: UserHierarchy): ScopeType {
if (h.topic_id) return 'topic'
if (h.topic_category_id) return 'category'
return 'global'
}
// Группируем иерархии по цепочкам
export function groupHierarchiesIntoChains(
hierarchies: UserHierarchy[]
): ChainGroup[] {
const groups = new Map<string, ChainGroup>()
for (const h of hierarchies) {
if (!h.subordinate_id || !h.department_id) continue
const scopeType = getScopeType(h)
const scopeObjectId = scopeType === 'topic' ? h.topic_id :
scopeType === 'category' ? h.topic_category_id : null
// Формируем ключ группы (добавляем target_system)
const targetSystemPart = h.target_system || 'all'
const key = `${h.subordinate_id}-${h.department_id}-${scopeType}-${scopeObjectId || 'null'}-${targetSystemPart}`
if (!groups.has(key)) {
let scopeObjectName = 'Все темы'
if (scopeType === 'category' && h.subordinate) {
scopeObjectName = `Категория #${scopeObjectId}`
} else if (scopeType === 'topic') {
scopeObjectName = `Тема #${scopeObjectId}`
}
groups.set(key, <ChainGroup>{
key,
subordinateId: h.subordinate_id,
subordinateName: h.subordinate?.full_name || `Пользователь #${h.subordinate_id}`,
departmentId: h.department_id,
departmentName: h.department?.name || `Отдел #${h.department_id}`,
scopeType,
scopeObjectId,
scopeObjectName,
steps: [],
})
}
groups.get(key)!.steps.push(h)
}
// Сортируем шаги по priority внутри каждой группы
for (const group of groups.values()) {
group.steps.sort((a, b) => (a.priority || 0) - (b.priority || 0))
}
return Array.from(groups.values())
}
// Цвета для scope types
export const SCOPE_COLORS: Record<ScopeType, string> = {
global: 'violet',
category: 'blue',
topic: 'orange',
}
export const SCOPE_LABELS: Record<ScopeType, string> = {
global: 'Глобальное',
category: 'Категория',
topic: 'Тема',
}
-----END src/features/hierarchies/utils.ts-----
File: src/features/notifications/hooks/useNotifications.ts
Lines: 55
-----BEGIN src/features/notifications/hooks/useNotifications.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
notificationsApi,
type NotificationsListParams,
type CreateNotificationRequest,
} from '@/api/notifications'
import { notifications as mantineNotifications } from '@mantine/notifications'
export const NOTIFICATIONS_QUERY_KEY = 'notifications'
export function useNotifications(params: NotificationsListParams = {}) {
return useQuery({
queryKey: [NOTIFICATIONS_QUERY_KEY, params],
queryFn: async () => {
const response = await notificationsApi.getList(params)
return response.data
},
})
}
export function useNotification(id: number | null) {
return useQuery({
queryKey: ['notification', id],
queryFn: async () => {
if (!id) return null
const response = await notificationsApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useCreateNotification() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateNotificationRequest) => notificationsApi.create(data),
onSuccess: (response) => {
queryClient.invalidateQueries({ queryKey: [NOTIFICATIONS_QUERY_KEY] })
const n = response.data
const hasFailed = (n.failed_count ?? 0) > 0
mantineNotifications.show({
title: hasFailed ? 'Отправлено с ошибками' : 'Отправлено',
message: `Доставлено: ${n.sent_count ?? 0} из ${n.total_count ?? 0}`,
color: hasFailed ? 'yellow' : 'green',
})
},
onError: (error: any) => {
mantineNotifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось отправить уведомление',
color: 'red',
})
},
})
}
-----END src/features/notifications/hooks/useNotifications.ts-----
File: src/features/notifications/utils/telegramHtml.ts
Lines: 30
-----BEGIN src/features/notifications/utils/telegramHtml.ts-----
// Приводит HTML из Tiptap-редактора к набору тегов, которые понимает Telegram ParseMode=HTML.
// Разрешённые теги: b, i, u, s, a, code, pre, tg-spoiler
const ALLOWED_TAGS = new Set(['b', 'i', 'u', 's', 'a', 'code', 'pre', 'tg-spoiler'])
export function convertHtmlToTelegram(html: string): string {
let result = html
// Абзацы и переносы строк -> двойной/одинарный \n
result = result.replace(/<\/p>\s*<p>/gi, '\n\n')
result = result.replace(/<\/?p>/gi, '')
result = result.replace(/<br\s*\/?>/gi, '\n')
// Синонимы тегов из Tiptap -> Telegram-теги
result = result
.replace(/<strong>/gi, '<b>').replace(/<\/strong>/gi, '</b>')
.replace(/<em>/gi, '<i>').replace(/<\/em>/gi, '</i>')
.replace(/<strike>/gi, '<s>').replace(/<\/strike>/gi, '</s>')
// Ссылки: сохраняем только href, убираем target/rel/class и т.п.
result = result.replace(/<a\s+[^>]*href="([^"]*)"[^>]*>/gi, '<a href="$1">')
// Убираем все теги, не входящие в белый список Telegram
result = result.replace(/<(\/?)([a-zA-Z0-9-]+)([^>]*)>/g, (match, closing, rawTag) => {
const tag = rawTag.toLowerCase()
if (!ALLOWED_TAGS.has(tag)) return ''
if (tag === 'a' && !closing) return match // href уже нормализован выше
return closing ? `</${tag}>` : `<${tag}>`
})
return result.trim()
}
-----END src/features/notifications/utils/telegramHtml.ts-----
File: src/features/permissions/constants.ts
Lines: 28
-----BEGIN src/features/permissions/constants.ts-----
export const PERMISSION_ACTIONS = [
{ value: 'create', label: 'Создание', description: 'Создание заявок по теме', color: 'blue' },
{ value: 'read', label: 'Просмотр', description: 'Просмотр заявок', color: 'gray' },
{ value: 'update', label: 'Редактирование', description: 'Редактирование заявок', color: 'cyan' },
{ value: 'delete', label: 'Удаление', description: 'Удаление заявок', color: 'red' },
{ value: 'approve', label: 'Согласование', description: 'Согласование заявок', color: 'green' },
{ value: 'revoke', label: 'Отзыв', description: 'Отзыв заявок', color: 'orange' },
{ value: 'observe', label: 'Наблюдение', description: 'Наблюдение за заявками', color: 'violet' },
] as const
export const ACTION_COLORS: Record<string, string> = {
create: 'blue',
read: 'gray',
update: 'cyan',
delete: 'red',
approve: 'green',
revoke: 'orange',
observe: 'violet',
}
export const ACTION_LABELS: Record<string, string> = {
create: 'Создание',
read: 'Просмотр',
update: 'Редактирование',
delete: 'Удаление',
approve: 'Согласование',
revoke: 'Отзыв',
observe: 'Наблюдение',
}
-----END src/features/permissions/constants.ts-----
File: src/features/permissions/hooks/usePermissions.ts
Lines: 100
-----BEGIN src/features/permissions/hooks/usePermissions.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
permissionsApi,
type PermissionsListParams,
type CreatePermissionRequest,
type UpdatePermissionRequest
} from '@/api/permissions'
import { notifications } from '@mantine/notifications'
export const PERMISSIONS_QUERY_KEY = 'permissions'
export function usePermissions(params: PermissionsListParams = {}) {
return useQuery({
queryKey: [PERMISSIONS_QUERY_KEY, params],
queryFn: async () => {
const response = await permissionsApi.getList(params)
return response.data
},
})
}
export function usePermission(id: number | null) {
return useQuery({
queryKey: ['permission', id],
queryFn: async () => {
if (!id) return null
const response = await permissionsApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useCreatePermission() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreatePermissionRequest) => permissionsApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [PERMISSIONS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Право создано',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось создать право',
color: 'red',
})
},
})
}
export function useUpdatePermission() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdatePermissionRequest) => permissionsApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [PERMISSIONS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Право обновлено',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить право',
color: 'red',
})
},
})
}
export function useDeletePermission() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => permissionsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [PERMISSIONS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Право удалено',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить право',
color: 'red',
})
},
})
}
-----END src/features/permissions/hooks/usePermissions.ts-----
File: src/features/roles/hooks/useAllRoles.ts
Lines: 14
-----BEGIN src/features/roles/hooks/useAllRoles.ts-----
import { useQuery } from '@tanstack/react-query'
import { rolesApi } from '@/api/roles.ts'
import type { Role } from '@/types/api'
export const ALL_ROLES_QUERY_KEY = 'roles-all'
export function useAllRoles() {
return useQuery({
queryKey: [ALL_ROLES_QUERY_KEY],
queryFn: async (): Promise<Role[]> => {
const response = await rolesApi.getList({ limit: 1000 })
return response.data.data || []
},
})
}
-----END src/features/roles/hooks/useAllRoles.ts-----
File: src/features/roles/hooks/useRoles.ts
Lines: 102
-----BEGIN src/features/roles/hooks/useRoles.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
rolesApi,
type RolesListParams,
type CreateRoleRequest,
type UpdateRoleRequest
} from '@/api/roles'
import { notifications } from '@mantine/notifications'
export const ROLES_QUERY_KEY = 'roles'
export function useRoles(params: RolesListParams = {}) {
return useQuery({
queryKey: [ROLES_QUERY_KEY, params],
queryFn: async () => {
const response = await rolesApi.getList(params)
return response.data
},
})
}
export function useRole(id: number | null) {
return useQuery({
queryKey: ['role', id],
queryFn: async () => {
if (!id) return null
const response = await rolesApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useCreateRole() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateRoleRequest) => rolesApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ROLES_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Роль создана',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось создать роль',
color: 'red',
})
},
})
}
export function useUpdateRole() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateRoleRequest) => rolesApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ROLES_QUERY_KEY] })
queryClient.invalidateQueries({ queryKey: ['users'] }) // Обновляем пользователей, т.к. у них есть роли
notifications.show({
title: 'Успешно',
message: 'Роль обновлена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить роль',
color: 'red',
})
},
})
}
export function useDeleteRole() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => rolesApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [ROLES_QUERY_KEY] })
queryClient.invalidateQueries({ queryKey: ['users'] })
notifications.show({
title: 'Успешно',
message: 'Роль удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить роль',
color: 'red',
})
},
})
}
-----END src/features/roles/hooks/useRoles.ts-----
File: src/features/topicExecutors/hooks/useTopicExecutors.ts
Lines: 88
-----BEGIN src/features/topicExecutors/hooks/useTopicExecutors.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
topicExecutorsApi,
type TopicExecutorsListParams,
type CreateTopicExecutorRequest,
type UpdateTopicExecutorRequest
} from '@/api/topicExecutors'
import { notifications } from '@mantine/notifications'
export const TOPIC_EXECUTORS_QUERY_KEY = 'topic-executors'
export function useTopicExecutors(params: TopicExecutorsListParams = {}) {
return useQuery({
queryKey: [TOPIC_EXECUTORS_QUERY_KEY, params],
queryFn: async () => {
const response = await topicExecutorsApi.getList({ limit: 1000, ...params })
return response.data
},
})
}
export function useCreateTopicExecutor() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateTopicExecutorRequest) => topicExecutorsApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [TOPIC_EXECUTORS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Исполнитель добавлен',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось добавить исполнителя',
color: 'red',
})
},
})
}
export function useUpdateTopicExecutor() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateTopicExecutorRequest) => topicExecutorsApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [TOPIC_EXECUTORS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Исполнитель обновлен',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить исполнителя',
color: 'red',
})
},
})
}
export function useDeleteTopicExecutor() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => topicExecutorsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [TOPIC_EXECUTORS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Исполнитель удален',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить исполнителя',
color: 'red',
})
},
})
}
-----END src/features/topicExecutors/hooks/useTopicExecutors.ts-----
File: src/features/topicExecutors/utils.ts
Lines: 58
-----BEGIN src/features/topicExecutors/utils.ts-----
import type { ApprovalTopicExecutor } from '@/types/api'
// Группа исполнителей по теме
export interface TopicExecutorsGroup {
topicId: number
topicName: string
topicCode: string
categoryName?: string
executors: ApprovalTopicExecutor[] // Отсортированы по step_order
}
// Константы для целевых систем
export const TARGET_SYSTEMS = [
{ value: 'all', label: 'Все системы', color: 'blue' },
{ value: 'okb', label: 'ОКБ', color: 'green' },
{ value: '1c', label: '1С', color: 'orange' },
] as const
export const TARGET_SYSTEM_LABELS: Record<string, string> = {
all: 'Все системы',
okb: 'ОКБ',
'1c': '1С',
}
export const TARGET_SYSTEM_COLORS: Record<string, string> = {
all: 'blue',
okb: 'green',
'1c': 'orange',
}
// Группируем исполнителей по темам
export function groupExecutorsByTopic(
executors: ApprovalTopicExecutor[]
): TopicExecutorsGroup[] {
const groups = new Map<number, TopicExecutorsGroup>()
for (const executor of executors) {
if (!executor.topic_id) continue
if (!groups.has(executor.topic_id)) {
groups.set(executor.topic_id, {
topicId: executor.topic_id,
topicName: executor.topic?.name || `Тема #${executor.topic_id}`,
topicCode: executor.topic?.code || '',
categoryName: executor.topic?.category?.name,
executors: [],
})
}
groups.get(executor.topic_id)!.executors.push(executor)
}
// Сортируем исполнителей по step_order внутри каждой группы
for (const group of groups.values()) {
group.executors.sort((a, b) => (a.step_order || 0) - (b.step_order || 0))
}
return Array.from(groups.values())
}
-----END src/features/topicExecutors/utils.ts-----
File: src/features/topics/constants.ts
Lines: 37
-----BEGIN src/features/topics/constants.ts-----
export const DURATION_TYPES = [
{ value: 'single_day', label: 'Один день' },
{ value: 'multi_day', label: 'Несколько дней' },
{ value: 'date_range', label: 'Диапазон дат' },
]
export const TIME_TYPES = [
{ value: 'partial', label: 'Частично (с указанием времени)' },
{ value: 'full_day', label: 'Весь день' },
]
export const PAYMENT_TYPES = [
{ value: 'own_expense', label: 'За свой счёт' },
{ value: 'vacation_account', label: 'В счёт отпуска' },
{ value: 'official', label: 'Официально (больничный)' },
]
export const APPROVAL_MODES = [
{ value: 'sequential', label: 'Последовательное' },
{ value: 'parallel', label: 'Параллельное' },
]
export const DURATION_LABELS: Record<string, string> = {
single_day: 'Один день',
multi_day: 'Несколько дней',
date_range: 'Диапазон',
}
export const TIME_LABELS: Record<string, string> = {
partial: 'Частично',
full_day: 'Весь день',
}
export const PAYMENT_LABELS: Record<string, string> = {
own_expense: 'За свой счёт',
vacation_account: 'В счёт отпуска',
official: 'Официально',
}
-----END src/features/topics/constants.ts-----
File: src/features/topics/hooks/useTopics.ts
Lines: 100
-----BEGIN src/features/topics/hooks/useTopics.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import {
topicsApi,
type TopicsListParams,
type CreateTopicRequest,
type UpdateTopicRequest
} from '@/api/topics'
import { notifications } from '@mantine/notifications'
export const TOPICS_QUERY_KEY = 'topics'
export function useTopics(params: TopicsListParams = {}) {
return useQuery({
queryKey: [TOPICS_QUERY_KEY, params],
queryFn: async () => {
const response = await topicsApi.getList(params)
return response.data
},
})
}
export function useTopic(id: number | null) {
return useQuery({
queryKey: ['topic', id],
queryFn: async () => {
if (!id) return null
const response = await topicsApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useCreateTopic() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: CreateTopicRequest) => topicsApi.create(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [TOPICS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Тема создана',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось создать тему',
color: 'red',
})
},
})
}
export function useUpdateTopic() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateTopicRequest) => topicsApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [TOPICS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Тема обновлена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить тему',
color: 'red',
})
},
})
}
export function useDeleteTopic() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => topicsApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [TOPICS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Тема удалена',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить тему',
color: 'red',
})
},
})
}
-----END src/features/topics/hooks/useTopics.ts-----
File: src/features/users/hooks/useDepartments.ts
Lines: 13
-----BEGIN src/features/users/hooks/useDepartments.ts-----
import { useQuery } from '@tanstack/react-query'
import { departmentsApi } from '@/api/departments.ts'
export const DEPARTMENTS_QUERY_KEY = 'departments'
export function useDepartments() {
return useQuery({
queryKey: [DEPARTMENTS_QUERY_KEY],
queryFn: async () => {
const response = await departmentsApi.getList()
return response.data.data || []
},
})
}
-----END src/features/users/hooks/useDepartments.ts-----
File: src/features/users/hooks/useRoles.ts
Lines: 13
-----BEGIN src/features/users/hooks/useRoles.ts-----
import { useQuery } from '@tanstack/react-query'
import { rolesApi } from '@/api/roles.ts'
export const ROLES_QUERY_KEY = 'roles'
export function useRoles(params: import('@/api/roles').RolesListParams = {}) {
return useQuery({
queryKey: [ROLES_QUERY_KEY, params],
queryFn: async () => {
const response = await rolesApi.getList(params)
return response.data.data || []
},
})
}
-----END src/features/users/hooks/useRoles.ts-----
File: src/features/users/hooks/useUserRoles.ts
Lines: 39
-----BEGIN src/features/users/hooks/useUserRoles.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { userRolesApi } from '@/api/userRoles.ts'
import { notifications } from '@mantine/notifications'
import { USERS_QUERY_KEY } from './useUsers.ts'
export function useUserRoles(userId: number | null) {
return useQuery({
queryKey: ['user-roles', userId],
queryFn: async () => {
if (!userId) return []
const response = await userRolesApi.getByUserId(userId)
return response.data.data || []
},
enabled: !!userId,
})
}
export function useBulkAssignRoles() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: userRolesApi.bulkAssign,
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [USERS_QUERY_KEY] })
queryClient.invalidateQueries({ queryKey: ['user-roles'] })
notifications.show({
title: 'Успешно',
message: 'Роли обновлены',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить роли',
color: 'red',
})
},
})
}
-----END src/features/users/hooks/useUserRoles.ts-----
File: src/features/users/hooks/useUsers.ts
Lines: 73
-----BEGIN src/features/users/hooks/useUsers.ts-----
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
import { usersApi, type UsersListParams, type UpdateUserRequest } from '@/api/users.ts'
import { notifications } from '@mantine/notifications'
export const USERS_QUERY_KEY = 'users'
export function useUsers(params: UsersListParams = {}) {
return useQuery({
queryKey: [USERS_QUERY_KEY, params],
queryFn: async () => {
const response = await usersApi.getList(params)
return response.data
},
})
}
export function useUser(id: number | null) {
return useQuery({
queryKey: ['user', id],
queryFn: async () => {
if (!id) return null
const response = await usersApi.getById(id)
return response.data
},
enabled: !!id,
})
}
export function useUpdateUser() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (data: UpdateUserRequest) => usersApi.update(data),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [USERS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Пользователь обновлен',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось обновить пользователя',
color: 'red',
})
},
})
}
// ✅ Новый хук для удаления пользователя
export function useDeleteUser() {
const queryClient = useQueryClient()
return useMutation({
mutationFn: (id: number) => usersApi.delete(id),
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: [USERS_QUERY_KEY] })
notifications.show({
title: 'Успешно',
message: 'Пользователь удален',
color: 'green',
})
},
onError: (error: any) => {
notifications.show({
title: 'Ошибка',
message: error.response?.data?.error_description || 'Не удалось удалить пользователя',
color: 'red',
})
},
})
}
-----END src/features/users/hooks/useUsers.ts-----
File: src/hooks/useAuth.ts
Lines: 57
-----BEGIN src/hooks/useAuth.ts-----
import { useState, useEffect } from 'react'
import { useNavigate } from 'react-router-dom'
import { authApi } from '@/api/auth'
import type { Admin } from '@/types/api'
export function useAuth() {
const [user, setUser] = useState<Admin | null>(null)
const [loading, setLoading] = useState(true)
const navigate = useNavigate()
useEffect(() => {
const token = localStorage.getItem('token')
if (token) {
loadUser()
} else {
setLoading(false)
}
}, [])
const loadUser = async () => {
try {
const response = await authApi.getProfile()
setUser(response.data)
} catch (error) {
console.error('Failed to load user:', error)
localStorage.removeItem('token')
} finally {
setLoading(false)
}
}
const login = async (login: string, password: string) => {
const response = await authApi.login({ login, password })
localStorage.setItem('token', response.data.token)
// ✅ НЕ создаём новый device_id здесь!
// Он уже создан в client.ts и сохранён в localStorage
// localStorage.setItem('device_id', crypto.randomUUID()) // ← УДАЛЕНО
await loadUser()
navigate('/')
}
const logout = async () => {
try {
await authApi.logout()
} catch (error) {
console.error('Logout error:', error)
} finally {
localStorage.removeItem('token')
localStorage.removeItem('user')
setUser(null)
navigate('/login')
}
}
return { user, loading, login, logout, isAuthenticated: !!user }
}
-----END src/hooks/useAuth.ts-----
File: src/index.css
Lines: 111
-----BEGIN src/index.css-----
:root {
--text: #6b6375;
--text-h: #08060d;
--bg: #fff;
--border: #e5e4e7;
--code-bg: #f4f3ec;
--accent: #aa3bff;
--accent-bg: rgba(170, 59, 255, 0.1);
--accent-border: rgba(170, 59, 255, 0.5);
--social-bg: rgba(244, 243, 236, 0.5);
--shadow:
rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
--sans: system-ui, 'Segoe UI', Roboto, sans-serif;
--heading: system-ui, 'Segoe UI', Roboto, sans-serif;
--mono: ui-monospace, Consolas, monospace;
font: 18px/145% var(--sans);
letter-spacing: 0.18px;
color-scheme: light dark;
color: var(--text);
background: var(--bg);
font-synthesis: none;
text-rendering: optimizeLegibility;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
@media (max-width: 1024px) {
font-size: 16px;
}
}
@media (prefers-color-scheme: dark) {
:root {
--text: #9ca3af;
--text-h: #f3f4f6;
--bg: #16171d;
--border: #2e303a;
--code-bg: #1f2028;
--accent: #c084fc;
--accent-bg: rgba(192, 132, 252, 0.15);
--accent-border: rgba(192, 132, 252, 0.5);
--social-bg: rgba(47, 48, 58, 0.5);
--shadow:
rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
}
#social .button-icon {
filter: invert(1) brightness(2);
}
}
#root {
width: 1126px;
max-width: 100%;
margin: 0 auto;
text-align: center;
border-inline: 1px solid var(--border);
min-height: 100svh;
display: flex;
flex-direction: column;
box-sizing: border-box;
}
body {
margin: 0;
}
h1,
h2 {
font-family: var(--heading);
font-weight: 500;
color: var(--text-h);
}
h1 {
font-size: 56px;
letter-spacing: -1.68px;
margin: 32px 0;
@media (max-width: 1024px) {
font-size: 36px;
margin: 20px 0;
}
}
h2 {
font-size: 24px;
line-height: 118%;
letter-spacing: -0.24px;
margin: 0 0 8px;
@media (max-width: 1024px) {
font-size: 20px;
}
}
p {
margin: 0;
}
code,
.counter {
font-family: var(--mono);
display: inline-flex;
border-radius: 4px;
color: var(--text-h);
}
code {
font-size: 15px;
line-height: 135%;
padding: 4px 8px;
background: var(--code-bg);
}
-----END src/index.css-----
File: src/theme.ts
Lines: 17
-----BEGIN src/theme.ts-----
import { createTheme } from '@mantine/core'
export const theme = createTheme({
primaryColor: 'blue',
fontFamily: '-apple-system, BlinkMacSystemFont, Segoe UI, Roboto, sans-serif',
components: {
Button: {
defaultProps: {
size: 'sm',
},
},
Table: {
defaultProps: {
fontSize: 'sm',
},
},
},
})
-----END src/theme.ts-----
File: src/types/api.ts
Lines: 333
-----BEGIN src/types/api.ts-----
export interface User {
id?: number
telegram_id?: number
username?: string
full_name: string
language_code?: string
department_id?: number
is_blocked?: boolean
is_fired?: boolean
blocked_at?: string
last_login?: string
created_at?: string
updated_at?: string
department?: Department
user_roles?: UserRole[]
}
export interface Department {
id?: number
name: string
code: string
description?: string
is_active?: boolean
created_at?: string
updated_at?: string
}
export interface Role {
id?: number
name: string
code: string
is_default?: boolean
is_director?: boolean
is_approver?: boolean
is_controller?: boolean
is_observer?: boolean
is_executor?: boolean
description?: string
created_at?: string
updated_at?: string
}
export interface UserRole {
id?: number
user_id: number
role_id: number
created_at?: string
updated_at?: string
role?: Role
}
export interface Admin {
id?: number
login: string
name?: string
is_root?: boolean
is_observer?: boolean // 🆕
telegram_id?: number // 🆕
telegram_user?: User // 🆕
created_at?: string
last_login?: string
last_ip_login?: string
is_blocked?: boolean
password?: string
}
// 🆕 Типы для заявок
export interface ApprovalFile {
id?: number
approval_id?: number
file_base64?: string
file_name?: string
attached_by_id?: number
created_at?: string
}
export interface ApprovalStep {
id?: number
approval_id?: number
approver_id?: number
step_order?: number
status?: string
comment?: string
approver_name_snapshot?: string
approver_department_snapshot?: string
acted_at?: string
created_at?: string
updated_at?: string
returned_at?: string
approver?: User
}
export interface ApprovalTopicCategory {
id?: number
name: string
code: string
description?: string
is_active?: boolean
created_at?: string
updated_at?: string
topics?: ApprovalTopic[]
}
export interface ApprovalTopic {
id?: number
category_id?: number
name: string
code: string
approval_mode?: string
duration_type?: string
time_type?: string
payment_type?: string
template?: string
first_approver_role_code?: string
allows_file?: boolean
allow_approver_selection?: boolean
allow_observer_selection?: boolean
require_approver_comment?: boolean
requires_file?: boolean
require_observer_selection?: boolean
is_active?: boolean
created_at?: string
updated_at?: string
instructions?: string
category?: ApprovalTopicCategory
}
export interface Approval {
id?: number
initiator_id?: number
topic_id?: number
department_id?: number
content?: string
status?: string
revoked_by_id?: number
revoked_at?: string
created_at?: string
updated_at?: string
metadata?: string
revision_comment?: string
revision_by_id?: number
revision_at?: string
revision_count?: number
files?: ApprovalFile[]
initiator?: User
topic?: ApprovalTopic
department?: Department
revoked_by?: User
steps?: ApprovalStep[]
}
export interface ApiResponse<T> {
data: T
total_count?: number
}
export interface LoginRequest {
login: string
password: string
}
export interface LoginResponse {
token: string
}
export interface Permission {
id?: number
role_id?: number
topic_category_id?: number | null
topic_id?: number | null
action?: string
created_at?: string
updated_at?: string
role?: Role
topic_category?: ApprovalTopicCategory
topic?: ApprovalTopic
}
export interface UserHierarchy {
id?: number
subordinate_id?: number
approver_id?: number
department_id?: number
topic_category_id?: number | null
topic_id?: number | null
priority?: number
created_at?: string
updated_at?: string
subordinate?: User
approver?: User
department?: Department
target_system?: string | null
}
export interface ApprovalTopicExecutor {
id?: number
topic_id?: number
user_id?: number
step_order?: number
require_file?: boolean
task_text?: string
is_active?: boolean
target_system?: string
created_at?: string
updated_at?: string
topic?: ApprovalTopic
user?: User
}
export interface ApprovalTopic {
id?: number
category_id?: number
name: string
code: string
duration_type?: string
time_type?: string
payment_type?: string
template?: string
allows_file?: boolean
is_active?: boolean
allow_approver_selection?: boolean
first_approver_role_code?: string
allow_observer_selection?: boolean
approval_mode?: string
allow_delegation_selection?: boolean
require_approver_comment?: boolean
requires_file?: boolean
require_observer_selection?: boolean
instructions?: string
created_at?: string
updated_at?: string
category?: ApprovalTopicCategory
}
export interface Admin {
id?: number
login: string
name?: string
is_root?: boolean
created_at?: string
last_login?: string
last_ip_login?: string
is_blocked?: boolean
password?: string
}
export interface ApprovalFile {
id?: number
approval_id?: number
file_base64?: string
file_name?: string
attached_by_id?: number
task_id?: number
created_at?: string
}
export interface ApprovalTask {
id?: number
approval_id?: number
executor_id?: number
task_text?: string
status?: string
step_order?: number
require_file?: boolean
topic_executor_id?: number
completed_at?: string
created_at?: string
updated_at?: string
approval?: Approval
executor?: User
files?: ApprovalFile[]
}
export interface ApprovalFlowNode {
id?: number
topic_id?: number
parent_id?: number | null
key: string
category_id: number
message_template?: string | null
code_template?: string | null
label: string
data_key?: string | null
data_value?: string | null
is_input?: boolean
input_key?: string | null
input_hint?: string | null
is_multi_select?: boolean
multi_select_key?: string | null
multi_select_value?: string | null
topic_code?: string | null
sort_order?: number
created_at?: string
updated_at?: string
children?: ApprovalFlowNode[]
}
export interface TargetFilters {
user_ids?: number[]
role_ids?: number[]
role_type_flags?: string[] // 'director' | 'approver' | 'observer' | 'executor' | 'controller'
department_ids?: number[]
}
export interface NotificationRecipient {
id?: number
notification_id?: number
user_id?: number
status?: string // pending | sent | failed
error_message?: string
telegram_message_id?: number
sent_at?: string
created_at?: string
user?: User
}
export interface Notification {
id?: number
title: string
message_html: string
photo_base64?: string
photo_file_name?: string
target_filters?: string // JSON-строка от бэкенда
status?: string // pending | sending | completed | failed
total_count?: number
sent_count?: number
failed_count?: number
created_by_id?: number
created_at?: string
updated_at?: string
sent_at?: string
recipients?: NotificationRecipient[]
}
-----END src/types/api.ts-----
File: src/utils/date.ts
Lines: 26
-----BEGIN src/utils/date.ts-----
import dayjs from 'dayjs'
import utc from 'dayjs/plugin/utc'
import timezone from 'dayjs/plugin/timezone'
import 'dayjs/locale/ru'
dayjs.extend(utc)
dayjs.extend(timezone)
dayjs.locale('ru')
export const MSK_TZ = 'Europe/Moscow'
// Даты с бэкенда обычно приходят в UTC (ISO-строка с 'Z') — если форматировать
// их через голый dayjs(date).format(...), время покажется в часовом поясе
// БРАУЗЕРА администратора, а не по МСК. Эта функция всегда приводит к
// Europe/Moscow независимо от того, где физически находится админ.
export function formatMsk(
date: string | Date | null | undefined,
fmt: string = 'DD.MM.YYYY HH:mm'
): string {
if (!date) return '—'
return dayjs(date).tz(MSK_TZ).format(fmt)
}
// Текущее время по МСК — например, для имени скачиваемого файла отчёта.
export function mskNow() {
return dayjs().tz(MSK_TZ)
}
-----END src/utils/date.ts-----
File: src/vite-env.d.ts
Lines: 11
-----BEGIN src/vite-env.d.ts-----
/// <reference types="vite/client" />
interface ImportMetaEnv {
readonly VITE_API_BASE_URL: string
readonly VITE_API_KEY: string
readonly VITE_APP_NAME: string
readonly VITE_APP_VERSION: string
}
interface ImportMeta {
readonly env: ImportMetaEnv
}
-----END src/vite-env.d.ts-----
File: vite.config.ts
Lines: 50
-----BEGIN vite.config.ts-----
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import path from 'path'
export default defineConfig({
plugins: [react()],
resolve: {
alias: {
'@': path.resolve(__dirname, './src'),
},
},
server: {
port: 3000,
allowedHosts: true,
proxy: {
'/api': {
target: 'http://0.0.0.0:1726', // Порт твоего бэкенда
changeOrigin: true,
secure: false,
// Раскомментируй, если нужно видеть реальные запросы:
// configure: (proxy, options) => {
// proxy.on('proxyReq', (proxyReq, req, res) => {
// console.log('Proxying:', req.method, req.url)
// })
// },
},
},
},
build: {
outDir: 'dist',
sourcemap: false,
rollupOptions: {
output: {
manualChunks(id) {
if (id.includes('node_modules')) {
if (id.includes('react') || id.includes('react-dom') || id.includes('react-router-dom')) {
return 'vendor'
}
if (id.includes('@mantine')) {
return 'ui'
}
if (id.includes('@tanstack') || id.includes('axios')) {
return 'query'
}
return 'vendor-misc'
}
},
},
},
},
})
-----END vite.config.ts-----