19592 lines
839 KiB
Plaintext
19592 lines
839 KiB
Plaintext
├── .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
|
||
├── 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: 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/App.tsx
|
||
Lines: 78
|
||
-----BEGIN src/App.tsx-----
|
||
import { Routes, Route, Navigate } from 'react-router-dom'
|
||
import MainLayout from './components/Layout/MainLayout'
|
||
import Login from './pages/Login'
|
||
import Dashboard from './pages/Dashboard'
|
||
import UsersPage from './pages/users/UsersPage'
|
||
import RolesPage from './pages/roles/RolesPage'
|
||
import ApprovalsPage from './pages/approvals/ApprovalsPage'
|
||
import { useAuth } from './hooks/useAuth'
|
||
import { Loader, Center, Text } from '@mantine/core'
|
||
import DepartmentsPage from "@/pages/DepartmentsPage.tsx"
|
||
import PermissionsPage from './pages/permissions/PermissionsPage'
|
||
import HierarchiesPage from './pages/hierarchies/HierarchiesPage'
|
||
import TopicExecutorsPage from "@/pages/topicExecutors/TopicExecutorsPage.tsx"
|
||
import CategoriesPage from "@/pages/categories/CategoriesPage.tsx"
|
||
import React from "react"
|
||
import TopicsPage from "@/pages/topics/TopicsPage.tsx"
|
||
import SettingsPage from './pages/settings/SettingsPage'
|
||
import AdminsPage from './pages/admins/AdminsPage'
|
||
import ApprovalTasksPage from './pages/approvalTasks/ApprovalTasksPage'
|
||
import FlowTreePage from "@/pages/flowNodes/FlowTreePage.tsx"
|
||
import FlowTreeGuidePage from './pages/flowNodes/FlowTreeGuidePage'
|
||
import NotificationsPage from "@/pages/notifications/NotificationsPage.tsx"
|
||
import AdminLogsPage from './pages/adminLogs/AdminLogsPage'
|
||
|
||
const Placeholder = ({ title }: { title: string }) => (
|
||
<div style={{ padding: 40 }}>
|
||
<Text size="xl" fw={700} mb="md">{title}</Text>
|
||
<Text c="dimmed">Страница в разработке...</Text>
|
||
</div>
|
||
)
|
||
|
||
function ProtectedRoute({ children }: { children: React.ReactNode }) {
|
||
const { isAuthenticated, loading } = useAuth()
|
||
|
||
if (loading) {
|
||
return (
|
||
<Center h="100vh">
|
||
<Loader />
|
||
</Center>
|
||
)
|
||
}
|
||
|
||
if (!isAuthenticated) {
|
||
return <Navigate to="/login" replace />
|
||
}
|
||
|
||
return <>{children}</>
|
||
}
|
||
|
||
function App() {
|
||
return (
|
||
<Routes>
|
||
<Route path="/login" element={<Login />} />
|
||
|
||
<Route element={<ProtectedRoute><MainLayout /></ProtectedRoute>}>
|
||
<Route path="/" element={<Placeholder title="Главная" />} />
|
||
<Route path="/notifications" element={<NotificationsPage />} />
|
||
<Route path="/approval-dash" element={<Dashboard />} />
|
||
<Route path="/nodes" element={<FlowTreePage />} />
|
||
<Route path="/users" element={<UsersPage />} />
|
||
<Route path="/departments" element={<DepartmentsPage />} />
|
||
<Route path="/roles" element={<RolesPage />} />
|
||
<Route path="/approvals" element={<ApprovalsPage />} />
|
||
<Route path="/permissions" element={<PermissionsPage />} />
|
||
<Route path="/categories" element={<CategoriesPage />} />
|
||
<Route path="/topics" element={<TopicsPage />} />
|
||
<Route path="/executors" element={<TopicExecutorsPage />} />
|
||
<Route path="/hierarchies" element={<HierarchiesPage />} />
|
||
<Route path="/settings" element={<SettingsPage />} />
|
||
<Route path="/admins" element={<AdminsPage />} />
|
||
<Route path="/logs" element={<AdminLogsPage />} />
|
||
<Route path="/approval-tasks" element={<ApprovalTasksPage />} />
|
||
<Route path="/guide/flow-trees" element={<FlowTreeGuidePage />} />
|
||
</Route>
|
||
</Routes>
|
||
)
|
||
}
|
||
|
||
export default App
|
||
-----END src/App.tsx-----
|
||
|
||
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: 197
|
||
-----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
|
||
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.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/components/CopyRolesModal.tsx
|
||
Lines: 122
|
||
-----BEGIN src/components/CopyRolesModal.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Text,
|
||
Button,
|
||
Group,
|
||
Loader,
|
||
Center,
|
||
Paper,
|
||
Badge,
|
||
ScrollArea,
|
||
Box,
|
||
} from '@mantine/core'
|
||
import { IconSearch, IconCopy } from '@tabler/icons-react'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
|
||
interface CopyRolesModalProps {
|
||
opened: boolean
|
||
onClose: () => void
|
||
onCopy: (roleIds: number[]) => void
|
||
currentUserId: number | null
|
||
}
|
||
|
||
export default function CopyRolesModal({ opened, onClose, onCopy, currentUserId }: CopyRolesModalProps) {
|
||
const [search, setSearch] = useState('')
|
||
const [selectedUserId, setSelectedUserId] = useState<number | null>(null)
|
||
|
||
const { data, isLoading } = useUsers({
|
||
offset: 0,
|
||
limit: 100,
|
||
...(search && { full_name: search }),
|
||
})
|
||
|
||
const users = Array.isArray(data?.data) ? data.data : []
|
||
|
||
const handleSelectUser = (userId: number) => {
|
||
setSelectedUserId(userId)
|
||
}
|
||
|
||
const handleCopy = () => {
|
||
if (!selectedUserId) return
|
||
|
||
const selectedUser = users.find(u => u.id === selectedUserId)
|
||
if (selectedUser && Array.isArray(selectedUser.user_roles)) {
|
||
const roleIds = selectedUser.user_roles
|
||
.map(ur => ur.role_id)
|
||
.filter((id): id is number => !!id)
|
||
onCopy(roleIds)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title="Скопировать роли от пользователя"
|
||
size="md"
|
||
>
|
||
<Stack gap="md">
|
||
<TextInput
|
||
placeholder="Поиск по имени..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => setSearch(e.currentTarget.value)}
|
||
/>
|
||
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<ScrollArea.Autosize mah={400}>
|
||
<Stack gap="xs">
|
||
{users
|
||
.filter(u => u.id !== currentUserId)
|
||
.map((user) => (
|
||
<Paper
|
||
key={user.id}
|
||
withBorder
|
||
p="sm"
|
||
style={{
|
||
cursor: 'pointer',
|
||
backgroundColor: selectedUserId === user.id
|
||
? 'var(--mantine-color-blue-0)'
|
||
: undefined,
|
||
}}
|
||
onClick={() => handleSelectUser(user.id!)}
|
||
>
|
||
<Group justify="space-between">
|
||
<Box>
|
||
<Text fw={500} size="sm">{user.full_name}</Text>
|
||
<Text size="xs" c="dimmed">
|
||
{user.username ? `@${user.username}` : user.telegram_id}
|
||
</Text>
|
||
</Box>
|
||
<Badge variant="light" size="sm">
|
||
{Array.isArray(user.user_roles) ? user.user_roles.length : 0} ролей
|
||
</Badge>
|
||
</Group>
|
||
</Paper>
|
||
))}
|
||
</Stack>
|
||
</ScrollArea.Autosize>
|
||
)}
|
||
|
||
<Group justify="flex-end">
|
||
<Button variant="default" onClick={onClose}>
|
||
Отмена
|
||
</Button>
|
||
<Button
|
||
onClick={handleCopy}
|
||
disabled={!selectedUserId}
|
||
leftSection={<IconCopy size={16} />}
|
||
>
|
||
Скопировать роли
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/components/CopyRolesModal.tsx-----
|
||
|
||
File: src/components/DiagnosticErrorBoundary.tsx
|
||
Lines: 90
|
||
-----BEGIN src/components/DiagnosticErrorBoundary.tsx-----
|
||
import { Component, type ErrorInfo, type ReactNode } from 'react'
|
||
import { Center, Stack, Title, Text, Button, Code, Box } from '@mantine/core'
|
||
import { IconAlertTriangle } from '@tabler/icons-react'
|
||
|
||
interface Props {
|
||
children: ReactNode
|
||
// Полноэкранный вариант — для самого верхнего "предохранителя" (main.tsx).
|
||
// Без него — занимает высоту родителя (для page-level использования
|
||
// внутри layout, где вокруг уже есть Header/Sidebar).
|
||
fullPage?: boolean
|
||
}
|
||
|
||
interface State {
|
||
error: Error | null
|
||
componentStack: string | null
|
||
}
|
||
|
||
// Общий ErrorBoundary. Используется дважды:
|
||
// 1) в main.tsx, оборачивая <App /> — последний рубеж на случай падения
|
||
// чего угодно (в т.ч. самого layout/sidebar);
|
||
// 2) в MainLayout.tsx, оборачивая <Outlet />, с key={location.pathname} —
|
||
// тогда падение ОДНОЙ страницы не рушит весь интерфейс: Header и
|
||
// Sidebar остаются рабочими, и переход на другую страницу сам
|
||
// пересоздаёт boundary и сбрасывает ошибку — reload не нужен.
|
||
export default class ErrorBoundary extends Component<Props, State> {
|
||
state: State = { error: null, componentStack: null }
|
||
|
||
static getDerivedStateFromError(error: Error) {
|
||
return { error }
|
||
}
|
||
|
||
componentDidCatch(error: Error, info: ErrorInfo) {
|
||
// 🆕 Логируем с максимумом контекста — пригодится и сейчас для
|
||
// диагностики (например, бага "белый экран после правки
|
||
// иерархии"), и впредь. Если подключите Sentry или аналог —
|
||
// отправляйте error + info отсюда же.
|
||
console.error('[ErrorBoundary] Необработанная ошибка рендера:', {
|
||
message: error.message,
|
||
stack: error.stack,
|
||
componentStack: info.componentStack,
|
||
url: window.location.href,
|
||
timestamp: new Date().toISOString(),
|
||
})
|
||
this.setState({ componentStack: info.componentStack ?? null })
|
||
}
|
||
|
||
handleReload = () => {
|
||
window.location.reload()
|
||
}
|
||
|
||
render() {
|
||
const { error, componentStack } = this.state
|
||
if (!error) {
|
||
return this.props.children
|
||
}
|
||
|
||
return (
|
||
<Center h={this.props.fullPage ? '100vh' : '100%'} p="xl">
|
||
<Stack gap="sm" maw={640} align="center">
|
||
<IconAlertTriangle size={40} color="var(--mantine-color-red-6)" />
|
||
<Title order={3} ta="center">
|
||
Произошла ошибка при загрузке страницы
|
||
</Title>
|
||
<Text c="dimmed" ta="center" size="sm">
|
||
Попробуйте перейти на другую страницу через меню слева или перезагрузить
|
||
страницу. Если ошибка повторяется — сообщите в техническую поддержку.
|
||
</Text>
|
||
<Button onClick={this.handleReload} mt="sm">
|
||
Перезагрузить страницу
|
||
</Button>
|
||
|
||
{import.meta.env.DEV && (
|
||
<Box mt="md" w="100%">
|
||
<Text size="xs" fw={600} c="dimmed" mb={4}>
|
||
Технические детали (видно только в dev-сборке):
|
||
</Text>
|
||
<Code
|
||
block
|
||
style={{ whiteSpace: 'pre-wrap', fontSize: 10, maxHeight: 240, overflow: 'auto' }}
|
||
>
|
||
{error.message}
|
||
{'\n\n'}
|
||
{componentStack}
|
||
</Code>
|
||
</Box>
|
||
)}
|
||
</Stack>
|
||
</Center>
|
||
)
|
||
}
|
||
}
|
||
-----END src/components/DiagnosticErrorBoundary.tsx-----
|
||
|
||
File: src/components/Layout/Header.tsx
|
||
Lines: 73
|
||
-----BEGIN src/components/Layout/Header.tsx-----
|
||
import {
|
||
Group,
|
||
Burger,
|
||
Text,
|
||
Avatar,
|
||
Menu,
|
||
ActionIcon,
|
||
} from '@mantine/core'
|
||
import { IconLogout, IconUser } from '@tabler/icons-react'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
|
||
interface HeaderProps {
|
||
toggleMobile: () => void
|
||
toggleDesktop: () => void
|
||
mobileOpened: boolean
|
||
desktopOpened: boolean
|
||
}
|
||
|
||
export default function Header({
|
||
toggleMobile,
|
||
toggleDesktop,
|
||
mobileOpened,
|
||
desktopOpened
|
||
}: HeaderProps) {
|
||
const { user, logout } = useAuth()
|
||
|
||
return (
|
||
<Group h="100%" px="md" justify="space-between">
|
||
<Group h="100%" gap={0}>
|
||
<Burger
|
||
opened={mobileOpened}
|
||
onClick={toggleMobile}
|
||
hiddenFrom="sm"
|
||
size="sm"
|
||
/>
|
||
<Burger
|
||
opened={desktopOpened}
|
||
onClick={toggleDesktop}
|
||
visibleFrom="sm"
|
||
size="sm"
|
||
/>
|
||
<Text ml="md" fw={700}>
|
||
Панель управления администратора
|
||
</Text>
|
||
</Group>
|
||
|
||
<Group>
|
||
<Menu shadow="md" width={200}>
|
||
<Menu.Target>
|
||
<ActionIcon variant="subtle" size="lg">
|
||
<Avatar size="sm" radius="xl">
|
||
{user?.login?.charAt(0).toUpperCase() || 'A'}
|
||
</Avatar>
|
||
</ActionIcon>
|
||
</Menu.Target>
|
||
|
||
<Menu.Dropdown>
|
||
<Menu.Item leftSection={<IconUser size={14} />}>
|
||
{user?.login || 'Admin'}
|
||
</Menu.Item>
|
||
<Menu.Divider />
|
||
<Menu.Item
|
||
leftSection={<IconLogout size={14} />}
|
||
onClick={logout}
|
||
color="red"
|
||
>
|
||
Выйти
|
||
</Menu.Item>
|
||
</Menu.Dropdown>
|
||
</Menu>
|
||
</Group>
|
||
</Group>
|
||
)
|
||
}
|
||
-----END src/components/Layout/Header.tsx-----
|
||
|
||
File: src/components/Layout/MainLayout.tsx
|
||
Lines: 42
|
||
-----BEGIN src/components/Layout/MainLayout.tsx-----
|
||
import { AppShell } from '@mantine/core'
|
||
import { useDisclosure } from '@mantine/hooks'
|
||
import { Outlet, useLocation } from 'react-router-dom'
|
||
import Sidebar from './Sidebar'
|
||
import Header from './Header'
|
||
import ErrorBoundary from '../DiagnosticErrorBoundary'
|
||
|
||
export default function MainLayout() {
|
||
const [mobileOpened, { toggle: toggleMobile }] = useDisclosure()
|
||
const [desktopOpened, { toggle: toggleDesktop }] = useDisclosure(true)
|
||
const location = useLocation()
|
||
|
||
return (
|
||
<AppShell
|
||
header={{ height: 60 }}
|
||
navbar={{
|
||
width: 280,
|
||
breakpoint: 'sm',
|
||
collapsed: { mobile: !mobileOpened, desktop: !desktopOpened },
|
||
}}
|
||
padding="md"
|
||
>
|
||
<AppShell.Header>
|
||
<Header
|
||
toggleMobile={toggleMobile}
|
||
toggleDesktop={toggleDesktop}
|
||
mobileOpened={mobileOpened}
|
||
desktopOpened={desktopOpened}
|
||
/>
|
||
</AppShell.Header>
|
||
|
||
<AppShell.Navbar p={0}>
|
||
<Sidebar />
|
||
</AppShell.Navbar>
|
||
|
||
<AppShell.Main bg="gray.0" miw={0}>
|
||
<ErrorBoundary key={location.pathname}>
|
||
<Outlet />
|
||
</ErrorBoundary>
|
||
</AppShell.Main>
|
||
</AppShell>
|
||
)
|
||
}
|
||
-----END src/components/Layout/MainLayout.tsx-----
|
||
|
||
File: src/components/Layout/Sidebar.tsx
|
||
Lines: 211
|
||
-----BEGIN src/components/Layout/Sidebar.tsx-----
|
||
import { useState, useMemo } from 'react'
|
||
import { NavLink, Box, Text, Stack, Badge } from '@mantine/core'
|
||
import {
|
||
IconDashboard,
|
||
IconFileCheck,
|
||
IconSettings,
|
||
IconChevronRight,
|
||
IconList,
|
||
IconUsers,
|
||
IconBuilding,
|
||
IconShield,
|
||
IconKey,
|
||
IconCategory,
|
||
IconBriefcase,
|
||
IconUserCheck,
|
||
IconGitBranch,
|
||
IconUserCog,
|
||
IconCheck,
|
||
IconBellRinging,
|
||
IconBlocks,
|
||
IconHistory,
|
||
} from '@tabler/icons-react'
|
||
import { useLocation, useNavigate } from 'react-router-dom'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
|
||
interface MenuItem {
|
||
label: string
|
||
icon?: any
|
||
path?: string
|
||
children?: MenuItem[]
|
||
adminOnly?: boolean // скрывать от наблюдателей
|
||
}
|
||
|
||
const menuItems: MenuItem[] = [
|
||
{ label: 'Обзор', icon: IconDashboard, path: '/' },
|
||
{ label: 'Администраторы', icon: IconUserCog, path: '/admins', adminOnly: true },
|
||
{ label: 'Уведомления', icon: IconBellRinging, path: '/notifications', adminOnly: true },
|
||
{ label: 'Журнал действий', icon: IconHistory, path: '/logs', adminOnly: true },
|
||
{
|
||
label: 'Система согласований',
|
||
icon: IconFileCheck,
|
||
children: [
|
||
{ label: 'Панель управления', icon: IconDashboard, path: '/approval-dash' },
|
||
{ label: 'Заявки', icon: IconList, path: '/approvals' },
|
||
{ label: 'Задачи', icon: IconCheck, path: '/approval-tasks' },
|
||
{ label: 'Пользователи', icon: IconUsers, path: '/users' },
|
||
{ label: 'Отделы', icon: IconBuilding, path: '/departments', adminOnly: true },
|
||
{ label: 'Роли', icon: IconShield, path: '/roles', adminOnly: true },
|
||
{ label: 'Права', icon: IconKey, path: '/permissions', adminOnly: true },
|
||
{
|
||
label: 'Темы согласований',
|
||
icon: IconBriefcase,
|
||
adminOnly: true,
|
||
children: [
|
||
{ label: 'Категории', icon: IconCategory, path: '/categories' },
|
||
{ label: 'Темы', icon: IconBriefcase, path: '/topics' },
|
||
{ label: 'Исполнители', icon: IconUserCheck, path: '/executors' },
|
||
]
|
||
},
|
||
{ label: 'Конструктор тем', icon: IconBlocks, path: '/nodes', adminOnly: true },
|
||
{ label: 'Иерархия', icon: IconGitBranch, path: '/hierarchies', adminOnly: true },
|
||
]
|
||
},
|
||
{ label: 'Настройки', icon: IconSettings, path: '/settings'},
|
||
]
|
||
|
||
function filterMenuByRole(items: MenuItem[], isObserver: boolean): MenuItem[] {
|
||
return items
|
||
.filter((item) => {
|
||
if (isObserver && item.adminOnly) return false
|
||
return true
|
||
})
|
||
.map((item) => {
|
||
if (item.children) {
|
||
const filteredChildren = filterMenuByRole(item.children, isObserver)
|
||
// Если после фильтрации детей не осталось — скрываем родителя
|
||
if (filteredChildren.length === 0) return null
|
||
return { ...item, children: filteredChildren }
|
||
}
|
||
return item
|
||
})
|
||
.filter((item): item is MenuItem => item !== null)
|
||
}
|
||
|
||
function MenuItemLink({ item, level }: { item: MenuItem; level: number }) {
|
||
const location = useLocation()
|
||
const navigate = useNavigate()
|
||
const [opened, setOpened] = useState(false)
|
||
|
||
const hasChildren = item.children && item.children.length > 0
|
||
const isActive = item.path ? location.pathname === item.path : false
|
||
const hasActiveChild = item.children?.some(child =>
|
||
child.path ? location.pathname === child.path : false
|
||
) || false
|
||
|
||
const paddingLeft = 16 + level * 20
|
||
|
||
if (hasChildren) {
|
||
return (
|
||
<Box>
|
||
<NavLink
|
||
label={item.label}
|
||
leftSection={item.icon ? <item.icon size={18} /> : undefined}
|
||
rightSection={
|
||
<IconChevronRight
|
||
size={16}
|
||
style={{
|
||
transform: opened ? 'rotate(90deg)' : 'none',
|
||
transition: 'transform 0.2s ease',
|
||
}}
|
||
/>
|
||
}
|
||
active={hasActiveChild}
|
||
onClick={() => setOpened(!opened)}
|
||
styles={{
|
||
root: {
|
||
paddingLeft,
|
||
paddingRight: 12,
|
||
borderRadius: '8px',
|
||
marginBottom: 2,
|
||
'&:hover': {
|
||
backgroundColor: 'var(--mantine-color-gray-0)',
|
||
},
|
||
},
|
||
}}
|
||
/>
|
||
{opened && (
|
||
<Stack gap={2} mt={2}>
|
||
{item.children!.map((child) => (
|
||
<MenuItemLink key={child.label} item={child} level={level + 1} />
|
||
))}
|
||
</Stack>
|
||
)}
|
||
</Box>
|
||
)
|
||
}
|
||
|
||
return (
|
||
<NavLink
|
||
label={item.label}
|
||
leftSection={item.icon ? <item.icon size={18} /> : undefined}
|
||
active={isActive}
|
||
onClick={() => {
|
||
if (item.path) navigate(item.path)
|
||
}}
|
||
styles={{
|
||
root: {
|
||
paddingLeft,
|
||
paddingRight: 12,
|
||
borderRadius: '8px',
|
||
marginBottom: 2,
|
||
'&:hover': {
|
||
backgroundColor: 'var(--mantine-color-gray-0)',
|
||
},
|
||
},
|
||
label: {
|
||
fontWeight: isActive ? 600 : 400,
|
||
},
|
||
}}
|
||
/>
|
||
)
|
||
}
|
||
|
||
export default function Sidebar() {
|
||
const { user } = useAuth()
|
||
const isObserver = user?.is_observer === true
|
||
|
||
// 🆕 Фильтруем меню в зависимости от роли
|
||
const filteredMenuItems = useMemo(
|
||
() => filterMenuByRole(menuItems, isObserver),
|
||
[isObserver]
|
||
)
|
||
|
||
return (
|
||
<Box
|
||
style={{
|
||
padding: '12px 8px',
|
||
height: '100%',
|
||
overflowY: 'auto',
|
||
}}
|
||
>
|
||
<Text
|
||
size="xs"
|
||
c="dimmed"
|
||
fw={700}
|
||
mb="md"
|
||
px="sm"
|
||
style={{
|
||
textTransform: 'uppercase',
|
||
letterSpacing: '0.5px',
|
||
}}
|
||
>
|
||
Главное меню
|
||
</Text>
|
||
|
||
{/* 🆕 Индикатор режима наблюдателя */}
|
||
{isObserver && (
|
||
<Box px="sm" mb="md">
|
||
<Badge color="blue" variant="light" size="sm" fullWidth>
|
||
Режим наблюдателя
|
||
</Badge>
|
||
</Box>
|
||
)}
|
||
|
||
<Stack gap={4}>
|
||
{filteredMenuItems.map((item) => (
|
||
<MenuItemLink key={item.label} item={item} level={0} />
|
||
))}
|
||
</Stack>
|
||
</Box>
|
||
)
|
||
}
|
||
-----END src/components/Layout/Sidebar.tsx-----
|
||
|
||
File: src/components/TopicGapsModal.tsx
|
||
Lines: 79
|
||
-----BEGIN src/components/TopicGapsModal.tsx-----
|
||
import { Modal, Table, Text, Badge, Group, ScrollArea, Stack, Center } from '@mantine/core'
|
||
import { IconAlertTriangle } from '@tabler/icons-react'
|
||
|
||
interface TopicGap {
|
||
user_id: number
|
||
full_name: string
|
||
department_name: string
|
||
topic_id: number
|
||
topic_name: string
|
||
category_name: string
|
||
}
|
||
|
||
interface TopicGapsModalProps {
|
||
opened: boolean
|
||
onClose: () => void
|
||
gaps: TopicGap[]
|
||
}
|
||
|
||
export default function TopicGapsModal({ opened, onClose, gaps }: TopicGapsModalProps) {
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group gap="xs">
|
||
<IconAlertTriangle size={18} color="var(--mantine-color-orange-6)" />
|
||
<Text fw={700}>Темы без назначенного порядка согласования</Text>
|
||
</Group>
|
||
}
|
||
size="xl"
|
||
>
|
||
<Stack gap="md">
|
||
<Text size="sm" c="dimmed">
|
||
У перечисленных сотрудников есть право создавать заявку по теме, но
|
||
ни одно правило иерархии не назначает для них согласующего — при
|
||
попытке отправить такую заявку в боте она не пройдёт.
|
||
</Text>
|
||
|
||
{gaps.length === 0 ? (
|
||
<Center p={40}>
|
||
<Text c="dimmed">Пробелов не найдено — все настроено</Text>
|
||
</Center>
|
||
) : (
|
||
<ScrollArea.Autosize mah={480}>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th>Сотрудник</Table.Th>
|
||
<Table.Th>Отдел</Table.Th>
|
||
<Table.Th>Категория</Table.Th>
|
||
<Table.Th>Тема</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{gaps.map((g, i) => (
|
||
<Table.Tr key={`${g.user_id}-${g.topic_id}-${i}`}>
|
||
<Table.Td>
|
||
<Text size="sm" fw={500}>{g.full_name || `ID: ${g.user_id}`}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">{g.department_name || '—'}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge size="sm" variant="light" color="violet">
|
||
{g.category_name || '—'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm">{g.topic_name || `ID: ${g.topic_id}`}</Text>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))}
|
||
</Table.Tbody>
|
||
</Table>
|
||
</ScrollArea.Autosize>
|
||
)}
|
||
</Stack>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/components/TopicGapsModal.tsx-----
|
||
|
||
File: src/components/UserEditModal.tsx
|
||
Lines: 294
|
||
-----BEGIN src/components/UserEditModal.tsx-----
|
||
import { useEffect, useState } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Select,
|
||
MultiSelect,
|
||
Switch,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Divider,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
Paper,
|
||
Tabs,
|
||
ActionIcon,
|
||
Tooltip,
|
||
Box,
|
||
} from '@mantine/core'
|
||
import { IconTrash, IconCopy, IconUser, IconSettings, IconShield } from '@tabler/icons-react'
|
||
import { useForm } from '@mantine/form'
|
||
import { useUser, useUpdateUser } from '@/features/users/hooks/useUsers'
|
||
import { useDepartments } from '@/features/users/hooks/useDepartments'
|
||
import { useRoles } from '@/features/users/hooks/useRoles'
|
||
import { useUserRoles, useBulkAssignRoles } from '@/features/users/hooks/useUserRoles'
|
||
import CopyRolesModal from './CopyRolesModal'
|
||
|
||
interface UserEditModalProps {
|
||
userId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function UserEditModal({ userId, opened, onClose }: UserEditModalProps) {
|
||
const { data: user, isLoading: userLoading } = useUser(userId)
|
||
const { data: departments } = useDepartments()
|
||
const { data: allRoles } = useRoles({ limit: 1000 })
|
||
const { data: userRoles, isLoading: rolesLoading } = useUserRoles(userId)
|
||
|
||
const updateUser = useUpdateUser()
|
||
const assignRoles = useBulkAssignRoles()
|
||
|
||
const [copyRolesOpened, setCopyRolesOpened] = useState(false)
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
full_name: '',
|
||
department_id: null as number | null,
|
||
is_blocked: false,
|
||
is_fired: false,
|
||
role_ids: [] as number[],
|
||
},
|
||
})
|
||
|
||
useEffect(() => {
|
||
if (user) {
|
||
form.setValues({
|
||
full_name: user.full_name || '',
|
||
department_id: user.department_id || null,
|
||
is_blocked: user.is_blocked || false,
|
||
is_fired: user.is_fired || false,
|
||
role_ids: Array.isArray(user.user_roles)
|
||
? user.user_roles.map((ur) => ur.role_id!)
|
||
: [],
|
||
})
|
||
}
|
||
}, [user])
|
||
|
||
useEffect(() => {
|
||
if (Array.isArray(userRoles) && userRoles.length > 0) {
|
||
const roleIds = userRoles
|
||
.map((ur) => ur.role?.id || ur.role_id)
|
||
.filter((id): id is number => !!id)
|
||
form.setFieldValue('role_ids', roleIds)
|
||
}
|
||
}, [userRoles])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (!userId) return
|
||
|
||
await updateUser.mutateAsync({
|
||
id: userId,
|
||
full_name: values.full_name,
|
||
department_id: values.department_id,
|
||
is_blocked: values.is_blocked,
|
||
is_fired: values.is_fired,
|
||
})
|
||
|
||
await assignRoles.mutateAsync({
|
||
user_id: userId,
|
||
role_ids: values.role_ids,
|
||
})
|
||
|
||
onClose()
|
||
}
|
||
|
||
const handleClearAllRoles = () => {
|
||
form.setFieldValue('role_ids', [])
|
||
}
|
||
|
||
const handleCopyRoles = (roleIds: number[]) => {
|
||
form.setFieldValue('role_ids', roleIds)
|
||
setCopyRolesOpened(false)
|
||
}
|
||
|
||
const departmentOptions = Array.isArray(departments)
|
||
? departments.map((d) => ({
|
||
value: String(d.id),
|
||
label: d.name || '',
|
||
}))
|
||
: []
|
||
|
||
const roleOptions = Array.isArray(allRoles)
|
||
? allRoles.map((r) => ({
|
||
value: String(r.id),
|
||
label: r.name || '',
|
||
description: r.description,
|
||
}))
|
||
: []
|
||
|
||
const isLoading = userLoading || rolesLoading
|
||
const isSubmitting = updateUser.isPending || assignRoles.isPending
|
||
|
||
return (
|
||
<>
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>Редактирование пользователя</Text>
|
||
{user && <Badge variant="light">ID: {user.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="xl"
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : user ? (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Tabs defaultValue="info" variant="outline">
|
||
<Tabs.List mb="md">
|
||
<Tabs.Tab value="info" leftSection={<IconUser size={14} />}>
|
||
Информация
|
||
</Tabs.Tab>
|
||
<Tabs.Tab value="roles" leftSection={<IconShield size={14} />}>
|
||
Роли ({form.values.role_ids.length})
|
||
</Tabs.Tab>
|
||
<Tabs.Tab value="settings" leftSection={<IconSettings size={14} />}>
|
||
Настройки
|
||
</Tabs.Tab>
|
||
</Tabs.List>
|
||
|
||
{/* Вкладка: Информация */}
|
||
<Tabs.Panel value="info">
|
||
<Stack gap="md">
|
||
<Paper withBorder p="md" bg="gray.0">
|
||
<Stack gap="xs">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Telegram ID:</Text>
|
||
<Text ff="monospace">{user.telegram_id}</Text>
|
||
</Group>
|
||
{user.username && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Username:</Text>
|
||
<Text>@{user.username}</Text>
|
||
</Group>
|
||
)}
|
||
{user.last_login && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Последний вход:</Text>
|
||
<Text size="sm">
|
||
{new Date(user.last_login).toLocaleString('ru-RU')}
|
||
</Text>
|
||
</Group>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
<TextInput
|
||
label="ФИО"
|
||
placeholder="Иванов Иван Иванович"
|
||
value={form.values.full_name}
|
||
onChange={(e) => form.setFieldValue('full_name', e.currentTarget.value)}
|
||
required
|
||
/>
|
||
|
||
<Select
|
||
label="Отдел"
|
||
placeholder="Не назначен"
|
||
data={departmentOptions}
|
||
value={form.values.department_id ? String(form.values.department_id) : null}
|
||
onChange={(v) => form.setFieldValue('department_id', v ? Number(v) : null)}
|
||
clearable
|
||
/>
|
||
</Stack>
|
||
</Tabs.Panel>
|
||
|
||
{/* Вкладка: Роли */}
|
||
<Tabs.Panel value="roles">
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="sm" fw={500}>
|
||
Выбрано ролей: {form.values.role_ids.length}
|
||
</Text>
|
||
<Group gap="xs">
|
||
<Tooltip label="Снять все роли">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={handleClearAllRoles}
|
||
disabled={form.values.role_ids.length === 0}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Скопировать роли от другого пользователя">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setCopyRolesOpened(true)}
|
||
>
|
||
<IconCopy size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Group>
|
||
|
||
<MultiSelect
|
||
label="Роли"
|
||
placeholder="Выберите роли"
|
||
data={roleOptions}
|
||
value={form.values.role_ids.map(String)}
|
||
onChange={(v) => form.setFieldValue('role_ids', v.map(Number))}
|
||
searchable
|
||
clearable
|
||
description="Пользователь может иметь несколько ролей"
|
||
maxDropdownHeight={300}
|
||
/>
|
||
</Stack>
|
||
</Tabs.Panel>
|
||
|
||
{/* Вкладка: Настройки */}
|
||
<Tabs.Panel value="settings">
|
||
<Stack gap="md">
|
||
<Switch
|
||
label="Заблокирован"
|
||
description="Пользователь не сможет пользоваться системой"
|
||
checked={form.values.is_blocked}
|
||
onChange={(e) => form.setFieldValue('is_blocked', e.currentTarget.checked)}
|
||
color="red"
|
||
/>
|
||
|
||
<Switch
|
||
label="Уволен"
|
||
description="Пользователь больше не работает в компании"
|
||
checked={form.values.is_fired}
|
||
onChange={(e) => form.setFieldValue('is_fired', e.currentTarget.checked)}
|
||
color="gray"
|
||
/>
|
||
</Stack>
|
||
</Tabs.Panel>
|
||
</Tabs>
|
||
|
||
<Divider my="md" />
|
||
|
||
<Group justify="flex-end">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
Сохранить
|
||
</Button>
|
||
</Group>
|
||
</form>
|
||
) : (
|
||
<Center p={40}>
|
||
<Text c="dimmed">Пользователь не найден</Text>
|
||
</Center>
|
||
)}
|
||
</Modal>
|
||
|
||
<CopyRolesModal
|
||
opened={copyRolesOpened}
|
||
onClose={() => setCopyRolesOpened(false)}
|
||
onCopy={handleCopyRoles}
|
||
currentUserId={userId}
|
||
/>
|
||
</>
|
||
)
|
||
}
|
||
-----END src/components/UserEditModal.tsx-----
|
||
|
||
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/components/DepartmentEditModal.tsx
|
||
Lines: 151
|
||
-----BEGIN src/features/departments/components/DepartmentEditModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Textarea,
|
||
Switch,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
useDepartment,
|
||
useCreateDepartment,
|
||
useUpdateDepartment
|
||
} from '@/features/departments/hooks/useDepartments'
|
||
|
||
interface DepartmentEditModalProps {
|
||
departmentId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function DepartmentEditModal({
|
||
departmentId,
|
||
opened,
|
||
onClose
|
||
}: DepartmentEditModalProps) {
|
||
const { data: department, isLoading: departmentLoading } = useDepartment(departmentId)
|
||
|
||
const createDepartment = useCreateDepartment()
|
||
const updateDepartment = useUpdateDepartment()
|
||
|
||
const isEditMode = departmentId !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
name: '',
|
||
code: '',
|
||
description: '',
|
||
is_active: true,
|
||
},
|
||
validate: {
|
||
name: (value: string | any[]) => (value.length < 2 ? 'Название должно содержать минимум 2 символа' : null),
|
||
code: (value: string | any[]) => {
|
||
if (value.length < 2) return 'Код должен содержать минимум 2 символа'
|
||
if (!/^[a-z0-9_]+$/.test(value as string)) return 'Код должен содержать только lowercase буквы, цифры и подчеркивания'
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
// Заполняем форму данными отдела
|
||
useEffect(() => {
|
||
if (department) {
|
||
form.setValues({
|
||
name: department.name || '',
|
||
code: department.code || '',
|
||
description: department.description || '',
|
||
is_active: department.is_active ?? true,
|
||
})
|
||
} else if (!isEditMode) {
|
||
form.reset()
|
||
}
|
||
}, [department, isEditMode])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (isEditMode && departmentId) {
|
||
// Режим редактирования
|
||
await updateDepartment.mutateAsync({
|
||
id: departmentId,
|
||
...values,
|
||
})
|
||
} else {
|
||
// Режим создания
|
||
await createDepartment.mutateAsync(values)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isLoading = departmentLoading
|
||
const isSubmitting = createDepartment.isPending || updateDepartment.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование отдела' : 'Создание отдела'}
|
||
</Text>
|
||
{department && <Badge variant="light">ID: {department.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="md"
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<TextInput
|
||
label="Название"
|
||
placeholder="Отдел продаж"
|
||
required
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Код"
|
||
placeholder="sales"
|
||
required
|
||
description="Уникальный идентификатор отдела (lowercase, цифры, подчеркивания)"
|
||
disabled={isEditMode}
|
||
{...form.getInputProps('code')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Описание"
|
||
placeholder="Описание отдела..."
|
||
minRows={3}
|
||
{...form.getInputProps('description')}
|
||
/>
|
||
|
||
<Switch
|
||
label="Активен"
|
||
description="Неактивные отделы не будут доступны для выбора"
|
||
checked={form.values.is_active}
|
||
onChange={(e) => form.setFieldValue('is_active', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/features/departments/components/DepartmentEditModal.tsx-----
|
||
|
||
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/main.tsx
|
||
Lines: 38
|
||
-----BEGIN src/main.tsx-----
|
||
import React from 'react'
|
||
import ReactDOM from 'react-dom/client'
|
||
import { MantineProvider } from '@mantine/core'
|
||
import { Notifications } from '@mantine/notifications'
|
||
import { ModalsProvider } from '@mantine/modals'
|
||
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
|
||
import { BrowserRouter } from 'react-router-dom'
|
||
import App from './App'
|
||
import { theme } from './theme'
|
||
import '@mantine/core/styles.css'
|
||
import '@mantine/notifications/styles.css'
|
||
import '@mantine/dates/styles.css'
|
||
import ErrorBoundary from './components/DiagnosticErrorBoundary'
|
||
|
||
const queryClient = new QueryClient({
|
||
defaultOptions: {
|
||
queries: {
|
||
refetchOnWindowFocus: false,
|
||
retry: 1,
|
||
},
|
||
},
|
||
})
|
||
|
||
ReactDOM.createRoot(document.getElementById('root')!).render(
|
||
<React.StrictMode>
|
||
<BrowserRouter>
|
||
<QueryClientProvider client={queryClient}>
|
||
<MantineProvider theme={theme}>
|
||
<ModalsProvider>
|
||
<Notifications position="top-right" />
|
||
<ErrorBoundary fullPage>
|
||
<App />
|
||
</ErrorBoundary>
|
||
</ModalsProvider>
|
||
</MantineProvider>
|
||
</QueryClientProvider>
|
||
</BrowserRouter>
|
||
</React.StrictMode>
|
||
)
|
||
-----END src/main.tsx-----
|
||
|
||
File: src/pages/Dashboard.tsx
|
||
Lines: 601
|
||
-----BEGIN src/pages/Dashboard.tsx-----
|
||
import { useEffect, useState } from 'react'
|
||
import {
|
||
SimpleGrid,
|
||
Paper,
|
||
Text,
|
||
Group,
|
||
Stack,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
Progress,
|
||
Alert,
|
||
Box,
|
||
ThemeIcon,
|
||
UnstyledButton,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconUsers,
|
||
IconFileCheck,
|
||
IconBuilding,
|
||
IconCategory,
|
||
IconAlertTriangle,
|
||
IconAlertOctagon,
|
||
IconClock,
|
||
IconAlertCircle,
|
||
IconCircleCheck,
|
||
IconChecklist,
|
||
IconCalendarOff,
|
||
IconChevronRight,
|
||
IconUserExclamation,
|
||
} from '@tabler/icons-react'
|
||
import {
|
||
PieChart,
|
||
Pie,
|
||
Cell,
|
||
ResponsiveContainer,
|
||
LineChart,
|
||
Line,
|
||
XAxis,
|
||
YAxis,
|
||
CartesianGrid,
|
||
Tooltip,
|
||
Legend,
|
||
} from 'recharts'
|
||
import { useNavigate } from 'react-router-dom'
|
||
import { dashboardApi } from '@/api/dashboard'
|
||
import type { DashboardStats } from '@/api/dashboard'
|
||
import dayjs from 'dayjs'
|
||
import 'dayjs/locale/ru'
|
||
import TopicGapsModal from "@/components/TopicGapsModal.tsx";
|
||
|
||
dayjs.locale('ru')
|
||
|
||
const STATUS_COLORS: Record<string, string> = {
|
||
draft: '#868e96',
|
||
pending: '#228be6',
|
||
approved: '#40c057',
|
||
rejected: '#fa5252',
|
||
revoked: '#fd7e14',
|
||
revision: '#7950f2',
|
||
}
|
||
|
||
const STATUS_LABELS: Record<string, string> = {
|
||
draft: 'Черновики',
|
||
pending: 'На согласовании',
|
||
approved: 'Согласованы',
|
||
rejected: 'Отклонены',
|
||
revoked: 'Отозваны',
|
||
revision: 'На доработке',
|
||
}
|
||
|
||
const TASK_STATUS_COLORS: Record<string, string> = {
|
||
pending: '#228be6',
|
||
waiting: '#868e96',
|
||
completed: '#40c057',
|
||
cancelled: '#fa5252',
|
||
}
|
||
|
||
const TASK_STATUS_LABELS: Record<string, string> = {
|
||
pending: 'В работе',
|
||
waiting: 'В очереди',
|
||
completed: 'Выполнены',
|
||
cancelled: 'Отменены',
|
||
}
|
||
|
||
export default function Dashboard() {
|
||
const navigate = useNavigate()
|
||
const [stats, setStats] = useState<DashboardStats | null>(null)
|
||
const [loading, setLoading] = useState(true)
|
||
const [error, setError] = useState<string | null>(null)
|
||
const [topicGapsOpened, setTopicGapsOpened] = useState(false)
|
||
|
||
useEffect(() => {
|
||
const loadData = async () => {
|
||
try {
|
||
const response = await dashboardApi.getStats()
|
||
setStats(response.data)
|
||
} catch (err: any) {
|
||
setError(err.response?.data?.error_description || 'Ошибка загрузки')
|
||
} finally {
|
||
setLoading(false)
|
||
}
|
||
}
|
||
loadData()
|
||
}, [])
|
||
|
||
if (loading) {
|
||
return (
|
||
<Center h={400}>
|
||
<Loader size="xl" />
|
||
</Center>
|
||
)
|
||
}
|
||
|
||
if (error || !stats) {
|
||
return (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="red" title="Ошибка">
|
||
{error || 'Не удалось загрузить данные'}
|
||
</Alert>
|
||
)
|
||
}
|
||
|
||
// Фильтруем нулевые значения для pie chart
|
||
const chartData = stats.statusData.filter(s => s.count > 0)
|
||
const totalApprovals = chartData.reduce((sum, s) => sum + s.count, 0)
|
||
|
||
const taskChartData = stats.taskStatusData.filter(s => s.count > 0)
|
||
const totalTasks = taskChartData.reduce((sum, s) => sum + s.count, 0)
|
||
|
||
// 🆕 Клик по алерту "просрочены" — ведёт на заявки со status=pending
|
||
// и date_to = сегодня минус oldPendingDays (те же самые заявки, что
|
||
// посчитаны в oldPendingCount на бэкенде — общее определение "просрочки").
|
||
const goToOldPending = () => {
|
||
const cutoff = dayjs().subtract(stats.oldPendingDays, 'day').format('YYYY-MM-DD')
|
||
navigate(`/approvals?status=pending&date_to=${cutoff}`)
|
||
}
|
||
|
||
const goToRevision = () => {
|
||
navigate('/approvals?status=revision')
|
||
}
|
||
|
||
const goToTasksByStatus = (status: string) => {
|
||
navigate(`/approval-tasks?status=${status}`)
|
||
}
|
||
|
||
return (
|
||
<Stack gap="lg">
|
||
{/* Заголовок */}
|
||
<Group justify="space-between">
|
||
<div>
|
||
<Text size="xl" fw={700}>Dashboard</Text>
|
||
<Text size="sm" c="dimmed">Обзор системы согласований</Text>
|
||
</div>
|
||
<Badge size="lg" variant="light" color="blue">
|
||
{dayjs().format('DD MMMM YYYY')}
|
||
</Badge>
|
||
</Group>
|
||
|
||
{/* 🆕 Alert теперь кликабельный — ведёт на отфильтрованный список заявок */}
|
||
{stats.oldPendingCount > 0 && (
|
||
<UnstyledButton onClick={goToOldPending} style={{ width: '100%' }}>
|
||
<Alert
|
||
icon={<IconAlertTriangle size={16} />}
|
||
color="orange"
|
||
variant="light"
|
||
title={`⚠️ ${stats.oldPendingCount} заявок требуют внимания`}
|
||
style={{ cursor: 'pointer' }}
|
||
>
|
||
<Group justify="space-between">
|
||
<Text size="sm">
|
||
Есть заявки, которые находятся на согласовании более {stats.oldPendingDays} дней.
|
||
</Text>
|
||
<Group gap={4} c="orange">
|
||
<Text size="xs" fw={600}>Посмотреть список</Text>
|
||
<IconChevronRight size={14} />
|
||
</Group>
|
||
</Group>
|
||
</Alert>
|
||
</UnstyledButton>
|
||
)}
|
||
|
||
|
||
{/* 🆕 Проблемы конфигурации инициаторов */}
|
||
{stats.topicGaps.length > 0 && (
|
||
<UnstyledButton onClick={() => setTopicGapsOpened(true)} style={{ width: '100%' }}>
|
||
<Paper withBorder p="md" radius="md" style={{ cursor: 'pointer' }}>
|
||
<Group justify="space-between">
|
||
<Group>
|
||
<ThemeIcon variant="light" color="orange" size="lg">
|
||
<IconAlertTriangle size={18} />
|
||
</ThemeIcon>
|
||
<div>
|
||
<Text fw={600}>
|
||
{stats.topicGaps.length} {stats.topicGaps.length === 1 ? 'тема без' : 'тем без'} назначенного порядка согласования
|
||
</Text>
|
||
<Text size="sm" c="dimmed">
|
||
Есть право создать заявку, но некому её согласовать — сотрудник наткнётся на ошибку в боте.
|
||
</Text>
|
||
</div>
|
||
</Group>
|
||
<Group gap={4} c="orange">
|
||
<Text size="xs" fw={600}>Показать список</Text>
|
||
<IconChevronRight size={14} />
|
||
</Group>
|
||
</Group>
|
||
</Paper>
|
||
</UnstyledButton>
|
||
)}
|
||
|
||
{stats.usersWithoutHierarchy.length > 0 && (
|
||
<Alert
|
||
icon={<IconUserExclamation size={16} />}
|
||
color="red"
|
||
variant="light"
|
||
title={`${stats.usersWithoutHierarchy.length} сотрудник(ов) без настроенной иерархии`}
|
||
>
|
||
<Text size="sm">
|
||
У перечисленных ниже есть право создавать заявки, но для их отдела не
|
||
настроено вообще ни одного правила согласования:{' '}
|
||
<Text span fw={600}>
|
||
{stats.usersWithoutHierarchy.map(u => u.full_name || `ID ${u.user_id}`).join(', ')}
|
||
</Text>
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
|
||
<TopicGapsModal
|
||
opened={topicGapsOpened}
|
||
onClose={() => setTopicGapsOpened(false)}
|
||
gaps={stats.topicGaps}
|
||
/>
|
||
|
||
{/* 🆕 Alert теперь кликабельный — ведёт на заявки на доработке */}
|
||
{stats.approvals.revision > 0 && (
|
||
<UnstyledButton onClick={goToRevision} style={{ width: '100%' }}>
|
||
<Paper withBorder p="md" radius="md" style={{ cursor: 'pointer' }}>
|
||
<Group justify="space-between">
|
||
<Group>
|
||
<ThemeIcon variant="light" color="orange" size="lg">
|
||
<IconClock size={18} />
|
||
</ThemeIcon>
|
||
<div>
|
||
<Text fw={600}>Требуют внимания: {stats.approvals.revision} заявок на доработке</Text>
|
||
<Text size="sm" c="dimmed">
|
||
Эти заявки были возвращены согласующими на доработку и требуют действий от инициаторов.
|
||
</Text>
|
||
</div>
|
||
</Group>
|
||
<IconChevronRight size={18} color="var(--mantine-color-gray-5)" />
|
||
</Group>
|
||
</Paper>
|
||
</UnstyledButton>
|
||
)}
|
||
|
||
{/* 🆕 Кто отсутствует сегодня */}
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group mb="md">
|
||
<ThemeIcon variant="light" color="gray" size="lg">
|
||
<IconCalendarOff size={18} />
|
||
</ThemeIcon>
|
||
<Text fw={600}>
|
||
Отсутствуют сегодня{stats.absentToday.length > 0 ? ` (${stats.absentToday.length})` : ''}
|
||
</Text>
|
||
</Group>
|
||
|
||
{stats.absentToday.length === 0 ? (
|
||
<Text c="dimmed" size="sm">Сегодня все на месте</Text>
|
||
) : (
|
||
<SimpleGrid cols={{ base: 1, sm: 2, lg: 3 }} spacing="xs">
|
||
{stats.absentToday.map((person, i) => (
|
||
<Group key={i} gap="xs" wrap="nowrap">
|
||
<Text size="sm" fw={500} truncate>{person.name}</Text>
|
||
<Text size="xs" c="dimmed" truncate>— {person.description}</Text>
|
||
</Group>
|
||
))}
|
||
</SimpleGrid>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* KPI карточки */}
|
||
<SimpleGrid cols={{ base: 1, sm: 2, lg: 4 }} spacing="md">
|
||
<StatCard
|
||
title="Пользователи"
|
||
value={stats.users.total}
|
||
subtitle={`${stats.users.active} активных`}
|
||
icon={IconUsers}
|
||
color="blue"
|
||
trend={stats.users.blocked > 0 ? `${stats.users.blocked} заблокировано` : undefined}
|
||
/>
|
||
<StatCard
|
||
title="Заявки"
|
||
value={stats.approvals.total}
|
||
subtitle={`${stats.approvals.today} за сегодня`}
|
||
icon={IconFileCheck}
|
||
color="green"
|
||
trend={stats.approvals.pending > 0 ? `${stats.approvals.pending} в работе` : undefined}
|
||
/>
|
||
<StatCard
|
||
title="Темы"
|
||
value={stats.topics.total}
|
||
subtitle={`${stats.topics.active} активных`}
|
||
icon={IconCategory}
|
||
color="violet"
|
||
trend={`${stats.categories} категорий`}
|
||
/>
|
||
<StatCard
|
||
title="Отделы / Роли"
|
||
value={stats.departments}
|
||
subtitle={`${stats.roles} ролей`}
|
||
icon={IconBuilding}
|
||
color="orange"
|
||
trend={`${stats.executors} исполнителей`}
|
||
/>
|
||
</SimpleGrid>
|
||
|
||
{/* Графики по заявкам */}
|
||
<SimpleGrid cols={{ base: 1, lg: 2 }} spacing="md">
|
||
{/* Pie chart */}
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group justify="space-between" mb="md">
|
||
<Text fw={600}>Распределение заявок по статусам</Text>
|
||
<Badge variant="light">{totalApprovals} всего</Badge>
|
||
</Group>
|
||
|
||
{chartData.length === 0 ? (
|
||
<Center h={250}>
|
||
<Text c="dimmed">Нет данных</Text>
|
||
</Center>
|
||
) : (
|
||
<ResponsiveContainer width="100%" height={250}>
|
||
<PieChart>
|
||
<Pie
|
||
data={chartData}
|
||
dataKey="count"
|
||
nameKey="status"
|
||
cx="50%"
|
||
cy="50%"
|
||
innerRadius={60}
|
||
outerRadius={90}
|
||
paddingAngle={2}
|
||
label={(entry: any) => STATUS_LABELS[entry.payload?.status] || entry.payload?.status}
|
||
onClick={(entry: any) => navigate(`/approvals?status=${entry.status}`)}
|
||
style={{ cursor: 'pointer' }}
|
||
>
|
||
{chartData.map((entry, index) => (
|
||
<Cell
|
||
key={`cell-${index}`}
|
||
fill={STATUS_COLORS[entry.status] || '#868e96'}
|
||
/>
|
||
))}
|
||
</Pie>
|
||
<Tooltip
|
||
formatter={(value: any, name: any) => [
|
||
value,
|
||
STATUS_LABELS[name] || name
|
||
]}
|
||
/>
|
||
</PieChart>
|
||
</ResponsiveContainer>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* Line chart */}
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group justify="space-between" mb="md">
|
||
<Text fw={600}>Динамика за 7 дней</Text>
|
||
<Badge variant="light" color="blue">Заявки</Badge>
|
||
</Group>
|
||
|
||
<ResponsiveContainer width="100%" height={250}>
|
||
<LineChart data={stats.dailyData}>
|
||
<CartesianGrid strokeDasharray="3 3" />
|
||
<XAxis
|
||
dataKey="date"
|
||
tickFormatter={(d) => dayjs(d).format('DD.MM')}
|
||
/>
|
||
<YAxis />
|
||
<Tooltip
|
||
labelFormatter={(d) => dayjs(d).format('DD.MM.YYYY')}
|
||
formatter={(value: any, name: any) => [
|
||
value,
|
||
name === 'created' ? 'Создано' : 'Согласовано'
|
||
]}
|
||
/>
|
||
<Legend
|
||
formatter={(value) =>
|
||
value === 'created' ? 'Создано' : 'Согласовано'
|
||
}
|
||
/>
|
||
<Line
|
||
type="monotone"
|
||
dataKey="created"
|
||
stroke="#228be6"
|
||
strokeWidth={2}
|
||
dot={{ r: 4 }}
|
||
/>
|
||
<Line
|
||
type="monotone"
|
||
dataKey="approved"
|
||
stroke="#40c057"
|
||
strokeWidth={2}
|
||
dot={{ r: 4 }}
|
||
/>
|
||
</LineChart>
|
||
</ResponsiveContainer>
|
||
</Paper>
|
||
</SimpleGrid>
|
||
|
||
{/* 🆕 Задачи — те же два графика, что у заявок выше */}
|
||
<SimpleGrid cols={{ base: 1, lg: 2 }} spacing="md">
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group justify="space-between" mb="md">
|
||
<Group gap="xs">
|
||
<ThemeIcon variant="light" color="teal" size="lg">
|
||
<IconChecklist size={18} />
|
||
</ThemeIcon>
|
||
<Text fw={600}>Задачи по статусам</Text>
|
||
</Group>
|
||
<Badge variant="light">{totalTasks} всего</Badge>
|
||
</Group>
|
||
|
||
{taskChartData.length === 0 ? (
|
||
<Center h={250}>
|
||
<Text c="dimmed">Нет данных</Text>
|
||
</Center>
|
||
) : (
|
||
<ResponsiveContainer width="100%" height={250}>
|
||
<PieChart>
|
||
<Pie
|
||
data={taskChartData}
|
||
dataKey="count"
|
||
nameKey="status"
|
||
cx="50%"
|
||
cy="50%"
|
||
innerRadius={60}
|
||
outerRadius={90}
|
||
paddingAngle={2}
|
||
label={(entry: any) => TASK_STATUS_LABELS[entry.payload?.status] || entry.payload?.status}
|
||
onClick={(entry: any) => goToTasksByStatus(entry.status)}
|
||
style={{ cursor: 'pointer' }}
|
||
>
|
||
{taskChartData.map((entry, index) => (
|
||
<Cell
|
||
key={`task-cell-${index}`}
|
||
fill={TASK_STATUS_COLORS[entry.status] || '#868e96'}
|
||
/>
|
||
))}
|
||
</Pie>
|
||
<Tooltip
|
||
formatter={(value: any, name: any) => [
|
||
value,
|
||
TASK_STATUS_LABELS[name] || name
|
||
]}
|
||
/>
|
||
</PieChart>
|
||
</ResponsiveContainer>
|
||
)}
|
||
</Paper>
|
||
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group justify="space-between" mb="md">
|
||
<Text fw={600}>Динамика задач за 7 дней</Text>
|
||
<Badge variant="light" color="teal">Задачи</Badge>
|
||
</Group>
|
||
|
||
<ResponsiveContainer width="100%" height={250}>
|
||
<LineChart data={stats.taskDailyData}>
|
||
<CartesianGrid strokeDasharray="3 3" />
|
||
<XAxis
|
||
dataKey="date"
|
||
tickFormatter={(d) => dayjs(d).format('DD.MM')}
|
||
/>
|
||
<YAxis />
|
||
<Tooltip
|
||
labelFormatter={(d) => dayjs(d).format('DD.MM.YYYY')}
|
||
formatter={(value: any, name: any) => [
|
||
value,
|
||
name === 'created' ? 'Создано' : 'Выполнено'
|
||
]}
|
||
/>
|
||
<Legend
|
||
formatter={(value) =>
|
||
value === 'created' ? 'Создано' : 'Выполнено'
|
||
}
|
||
/>
|
||
<Line
|
||
type="monotone"
|
||
dataKey="created"
|
||
stroke="#228be6"
|
||
strokeWidth={2}
|
||
dot={{ r: 4 }}
|
||
/>
|
||
<Line
|
||
type="monotone"
|
||
dataKey="completed"
|
||
stroke="#12b886"
|
||
strokeWidth={2}
|
||
dot={{ r: 4 }}
|
||
/>
|
||
</LineChart>
|
||
</ResponsiveContainer>
|
||
</Paper>
|
||
</SimpleGrid>
|
||
|
||
{/* Разбивка по категориям + узкие места */}
|
||
<SimpleGrid cols={{ base: 1, lg: 2 }} spacing="md">
|
||
{/* Разбивка по категориям */}
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group mb="md">
|
||
<ThemeIcon variant="light" color="violet" size="lg">
|
||
<IconCategory size={18} />
|
||
</ThemeIcon>
|
||
<Text fw={600}>Заявки по категориям</Text>
|
||
</Group>
|
||
|
||
{stats.categoryBreakdown.length === 0 ? (
|
||
<Center h={200}>
|
||
<Text c="dimmed">Нет данных</Text>
|
||
</Center>
|
||
) : (
|
||
<Stack gap="sm">
|
||
{stats.categoryBreakdown.map((cat) => {
|
||
const maxCount = Math.max(...stats.categoryBreakdown.map(c => c.total_count))
|
||
const percent = maxCount > 0 ? (cat.total_count / maxCount) * 100 : 0
|
||
|
||
return (
|
||
<Box key={cat.id}>
|
||
<Group justify="space-between" mb={4}>
|
||
<Text size="sm" fw={500}>{cat.name}</Text>
|
||
<Group gap="xs">
|
||
<Text size="sm" fw={600}>{cat.total_count}</Text>
|
||
{cat.pending_count > 0 && (
|
||
<Badge size="xs" color="blue" variant="light">
|
||
{cat.pending_count} в работе
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
</Group>
|
||
<Progress value={percent} size="sm" color="violet" />
|
||
</Box>
|
||
)
|
||
})}
|
||
</Stack>
|
||
)}
|
||
</Paper>
|
||
</SimpleGrid>
|
||
</Stack>
|
||
)
|
||
}
|
||
|
||
// Компонент карточки статистики
|
||
interface StatCardProps {
|
||
title: string
|
||
value: number | string
|
||
subtitle?: string
|
||
icon: any
|
||
color: string
|
||
trend?: string
|
||
}
|
||
|
||
function StatCard({ title, value, subtitle, icon: Icon, color, trend }: StatCardProps) {
|
||
return (
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group justify="space-between" align="flex-start">
|
||
<Stack gap={4}>
|
||
<Text c="dimmed" size="xs" tt="uppercase" fw={700}>
|
||
{title}
|
||
</Text>
|
||
<Text size="xl" fw={700} c={color}>
|
||
{value}
|
||
</Text>
|
||
{subtitle && (
|
||
<Text size="xs" c="dimmed">
|
||
{subtitle}
|
||
</Text>
|
||
)}
|
||
</Stack>
|
||
<ThemeIcon
|
||
variant="light"
|
||
color={color}
|
||
size="xl"
|
||
radius="md"
|
||
>
|
||
<Icon size={24} />
|
||
</ThemeIcon>
|
||
</Group>
|
||
|
||
{trend && (
|
||
<Box
|
||
mt="md"
|
||
pt="md"
|
||
style={{
|
||
borderTop: '1px solid var(--mantine-color-gray-3)',
|
||
}}
|
||
>
|
||
<Text size="xs" c="dimmed">{trend}</Text>
|
||
</Box>
|
||
)}
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/Dashboard.tsx-----
|
||
|
||
File: src/pages/DepartmentsPage.tsx
|
||
Lines: 230
|
||
-----BEGIN src/pages/DepartmentsPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
TextInput,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import { IconPencil, IconTrash, IconPlus, IconSearch } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useDepartments, useDeleteDepartment } from '@/features/departments/hooks/useDepartments'
|
||
import DepartmentEditModal from "@/features/departments/components/DepartmentEditModal.tsx";
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function DepartmentsPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [search, setSearch] = useState('')
|
||
const [activeFilter, setActiveFilter] = useState<boolean | null>(null)
|
||
const [editDepartmentId, setEditDepartmentId] = useState<number | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
|
||
const { data, isLoading, isFetching } = useDepartments({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(search && { name: search }),
|
||
...(activeFilter !== null && { is_active: activeFilter }),
|
||
})
|
||
|
||
const deleteDepartment = useDeleteDepartment()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить этот отдел? Это действие нельзя отменить.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteDepartment.mutate(id),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Отделы</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => setCreateModalOpened(true)}
|
||
>
|
||
Создать отдел
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<TextInput
|
||
label="Поиск по названию"
|
||
placeholder="Отдел продаж..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
|
||
<Switch
|
||
label="Только активные"
|
||
checked={activeFilter === true}
|
||
onChange={(e) => {
|
||
setActiveFilter(e.currentTarget.checked ? true : null)
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Название</Table.Th>
|
||
<Table.Th>Код</Table.Th>
|
||
<Table.Th>Описание</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={6}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Отделы не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((department) => (
|
||
<Table.Tr key={department.id}>
|
||
<Table.Td>{department.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text fw={500}>{department.name}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace" c="dimmed">
|
||
{department.code}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={2}>
|
||
{department.description || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={department.is_active ? 'green' : 'gray'}
|
||
variant={department.is_active ? 'light' : 'filled'}
|
||
>
|
||
{department.is_active ? 'Активен' : 'Неактивен'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditDepartmentId(department.id!)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(department.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{/* Пагинация */}
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* Индикатор обновления */}
|
||
{isFetching && !isLoading && (
|
||
<Box
|
||
style={{
|
||
position: 'fixed',
|
||
top: 70,
|
||
right: 20,
|
||
zIndex: 1000
|
||
}}
|
||
>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
{/* Модальное окно редактирования */}
|
||
<DepartmentEditModal
|
||
departmentId={editDepartmentId}
|
||
opened={editDepartmentId !== null}
|
||
onClose={() => setEditDepartmentId(null)}
|
||
/>
|
||
|
||
{/* Модальное окно создания */}
|
||
<DepartmentEditModal
|
||
departmentId={null}
|
||
opened={createModalOpened}
|
||
onClose={() => setCreateModalOpened(false)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/DepartmentsPage.tsx-----
|
||
|
||
File: src/pages/Login.tsx
|
||
Lines: 85
|
||
-----BEGIN src/pages/Login.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Container,
|
||
Paper,
|
||
Title,
|
||
Text,
|
||
TextInput,
|
||
PasswordInput,
|
||
Button,
|
||
Group,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { notifications } from '@mantine/notifications'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
|
||
export default function Login() {
|
||
const { login } = useAuth()
|
||
const [loading, setLoading] = useState(false)
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
login: '',
|
||
password: '',
|
||
},
|
||
validate: {
|
||
login: (value: string | any[]) => (value.length < 3 ? 'Логин должен содержать минимум 3 символа' : null),
|
||
password: (value: string | any[]) => (value.length < 4 ? 'Пароль должен содержать минимум 4 символа' : null),
|
||
},
|
||
})
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
setLoading(true)
|
||
try {
|
||
await login(values.login, values.password)
|
||
notifications.show({
|
||
title: 'Успешный вход',
|
||
message: `Добро пожаловать, ${values.login}!`,
|
||
color: 'green',
|
||
})
|
||
} catch (error: any) {
|
||
notifications.show({
|
||
title: 'Ошибка входа',
|
||
message: error.response?.data?.error_description || 'Неверный логин или пароль',
|
||
color: 'red',
|
||
})
|
||
} finally {
|
||
setLoading(false)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Container size={420} my={40}>
|
||
<Title ta="center" mb="md">
|
||
Корпоративная панель администратора
|
||
</Title>
|
||
<Text c="dimmed" size="sm" ta="center" mb="xl">
|
||
Введите свои данные для входа в систему
|
||
</Text>
|
||
|
||
<Paper withBorder shadow="md" p={30} mt={30} radius="md">
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<TextInput
|
||
label="Логин"
|
||
placeholder="admin"
|
||
required
|
||
{...form.getInputProps('login')}
|
||
/>
|
||
|
||
<PasswordInput
|
||
label="Пароль"
|
||
placeholder="your password"
|
||
required
|
||
mt="md"
|
||
{...form.getInputProps('password')}
|
||
/>
|
||
|
||
<Group justify="space-between" mt="xl">
|
||
<Button type="submit" fullWidth loading={loading}>
|
||
Войти
|
||
</Button>
|
||
</Group>
|
||
</form>
|
||
</Paper>
|
||
</Container>
|
||
)
|
||
}
|
||
-----END src/pages/Login.tsx-----
|
||
|
||
File: src/pages/adminLogs/AdminLogsPage.tsx
|
||
Lines: 331
|
||
-----BEGIN src/pages/adminLogs/AdminLogsPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Group,
|
||
ActionIcon,
|
||
Text,
|
||
TextInput,
|
||
Select,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Badge,
|
||
} from '@mantine/core'
|
||
import { DatePickerInput } from '@mantine/dates'
|
||
import { IconTrash, IconSearch, IconX, IconEye } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
import { useAdminLogs, useDeleteAdminLog } from '@/features/adminLogs/hooks/useAdminLogs'
|
||
import type { AdminActionLog } from '@/api/adminLogs'
|
||
import AdminLogDetailModal from './components/AdminLogDetailModal'
|
||
import dayjs from 'dayjs'
|
||
import 'dayjs/locale/ru'
|
||
|
||
dayjs.locale('ru')
|
||
|
||
const LIMIT = 50
|
||
|
||
const ACTION_COLORS: Record<string, string> = {
|
||
create: 'green',
|
||
update: 'blue',
|
||
delete: 'red',
|
||
}
|
||
const ACTION_LABELS: Record<string, string> = {
|
||
create: 'Создание',
|
||
update: 'Изменение',
|
||
delete: 'Удаление',
|
||
}
|
||
|
||
const ENTITY_TYPE_OPTIONS = [
|
||
{ value: 'user', label: 'Пользователь' },
|
||
{ value: 'admin', label: 'Администратор' },
|
||
{ value: 'department', label: 'Отдел' },
|
||
{ value: 'role', label: 'Роль' },
|
||
{ value: 'permission', label: 'Право' },
|
||
{ value: 'category', label: 'Категория' },
|
||
{ value: 'topic', label: 'Тема' },
|
||
{ value: 'topic_executor', label: 'Исполнитель темы' },
|
||
{ value: 'hierarchy', label: 'Иерархия' },
|
||
{ value: 'flow_node', label: 'Узел дерева' },
|
||
{ value: 'flow_tree', label: 'Дерево категории' },
|
||
{ value: 'user_role', label: 'Роль пользователя' },
|
||
{ value: 'user_roles', label: 'Роли пользователя (массово)' },
|
||
{ value: 'approval_task', label: 'Задача' },
|
||
{ value: 'notification', label: 'Рассылка' },
|
||
]
|
||
|
||
export default function AdminLogPage() {
|
||
const { user: currentUser } = useAuth()
|
||
const isRoot = currentUser?.is_root === true
|
||
|
||
const [page, setPage] = useState(1)
|
||
const [adminLogin, setAdminLogin] = useState('')
|
||
const [action, setAction] = useState<string | null>(null)
|
||
const [entityType, setEntityType] = useState<string | null>(null)
|
||
const [entityId, setEntityId] = useState('')
|
||
const [search, setSearch] = useState('')
|
||
const [dateFrom, setDateFrom] = useState<Date | null>(null)
|
||
const [dateTo, setDateTo] = useState<Date | null>(null)
|
||
const [selectedLog, setSelectedLog] = useState<AdminActionLog | null>(null)
|
||
|
||
const { data, isLoading, isFetching } = useAdminLogs({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(adminLogin && { admin_login: adminLogin }),
|
||
...(action && { action }),
|
||
...(entityType && { entity_type: entityType }),
|
||
...(entityId && { entity_id: Number(entityId) }),
|
||
...(search && { search }),
|
||
...(dateFrom && { date_from: dayjs(dateFrom).format('YYYY-MM-DD') }),
|
||
...(dateTo && { date_to: dayjs(dateTo).format('YYYY-MM-DD') }),
|
||
})
|
||
|
||
const deleteLog = useDeleteAdminLog()
|
||
|
||
const logs = data?.data || []
|
||
const totalCount = data?.total_count || 0
|
||
const totalPages = totalCount ? Math.ceil(totalCount / LIMIT) : 1
|
||
|
||
const hasActiveFilters = adminLogin || action || entityType || entityId || search || dateFrom || dateTo
|
||
|
||
const handleResetFilters = () => {
|
||
setAdminLogin('')
|
||
setAction(null)
|
||
setEntityType(null)
|
||
setEntityId('')
|
||
setSearch('')
|
||
setDateFrom(null)
|
||
setDateTo(null)
|
||
setPage(1)
|
||
}
|
||
|
||
const handleDelete = (entry: AdminActionLog) => {
|
||
modals.openConfirmModal({
|
||
title: 'Удалить запись журнала?',
|
||
children: (
|
||
<Text size="sm">
|
||
Это действие доступно только root-администратору и необратимо.
|
||
Обычно записи журнала не удаляют — используйте только если запись
|
||
ошибочна или содержит чувствительные данные, которые нужно убрать.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteLog.mutate(entry.id),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Журнал действий администраторов</Text>
|
||
<Text c="dimmed" size="sm">Всего: {totalCount}</Text>
|
||
</Group>
|
||
|
||
<Paper withBorder p="md">
|
||
<Stack gap="md">
|
||
<Group gap="md" align="flex-end" grow>
|
||
<TextInput
|
||
label="Администратор"
|
||
placeholder="Логин..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={adminLogin}
|
||
onChange={(e) => {
|
||
setAdminLogin(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
|
||
<Select
|
||
label="Действие"
|
||
placeholder="Все"
|
||
data={[
|
||
{ value: 'create', label: 'Создание' },
|
||
{ value: 'update', label: 'Изменение' },
|
||
{ value: 'delete', label: 'Удаление' },
|
||
]}
|
||
value={action}
|
||
onChange={(v) => {
|
||
setAction(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
/>
|
||
|
||
<Select
|
||
label="Тип сущности"
|
||
placeholder="Все"
|
||
data={ENTITY_TYPE_OPTIONS}
|
||
value={entityType}
|
||
onChange={(v) => {
|
||
setEntityType(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
/>
|
||
|
||
<TextInput
|
||
label="ID сущности"
|
||
placeholder="Например, 19"
|
||
value={entityId}
|
||
onChange={(e) => {
|
||
setEntityId(e.currentTarget.value.replace(/\D/g, ''))
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
</Group>
|
||
|
||
<Group gap="md" align="flex-end" grow>
|
||
<TextInput
|
||
label="Поиск по описанию"
|
||
placeholder="Введите текст..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
rightSection={
|
||
search && (
|
||
<ActionIcon variant="subtle" onClick={() => setSearch('')}>
|
||
<IconX size={14} />
|
||
</ActionIcon>
|
||
)
|
||
}
|
||
/>
|
||
<DatePickerInput
|
||
label="С даты"
|
||
placeholder="Выберите дату"
|
||
value={dateFrom}
|
||
onChange={(val) => {
|
||
setDateFrom(val as Date | null)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
maxDate={dateTo || undefined}
|
||
/>
|
||
<DatePickerInput
|
||
label="По дату"
|
||
placeholder="Выберите дату"
|
||
value={dateTo}
|
||
onChange={(val) => {
|
||
setDateTo(val as Date | null)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
minDate={dateFrom || undefined}
|
||
/>
|
||
<Box>
|
||
{hasActiveFilters && (
|
||
<ActionIcon variant="light" color="gray" size="lg" onClick={handleResetFilters} title="Сбросить фильтры">
|
||
<IconX size={16} />
|
||
</ActionIcon>
|
||
)}
|
||
</Box>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 160 }}>Когда</Table.Th>
|
||
<Table.Th>Администратор</Table.Th>
|
||
<Table.Th style={{ width: 120 }}>Действие</Table.Th>
|
||
<Table.Th style={{ width: 160 }}>Сущность</Table.Th>
|
||
<Table.Th>Описание</Table.Th>
|
||
<Table.Th style={{ width: 90 }}>—</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{logs.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={6}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Записей не найдено</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
logs.map((entry) => (
|
||
<Table.Tr key={entry.id} style={{ cursor: 'pointer' }} onClick={() => setSelectedLog(entry)}>
|
||
<Table.Td>
|
||
<Text size="xs" c="dimmed">
|
||
{dayjs(entry.created_at).format('DD.MM.YYYY HH:mm')}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" fw={500}>{entry.admin_login}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge size="sm" color={ACTION_COLORS[entry.action] || 'gray'} variant="light">
|
||
{ACTION_LABELS[entry.action] || entry.action}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge size="sm" variant="outline" color="gray">
|
||
{entry.entity_type}{entry.entity_id ? ` #${entry.entity_id}` : ''}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={1}>{entry.description}</Text>
|
||
</Table.Td>
|
||
<Table.Td onClick={(e) => e.stopPropagation()}>
|
||
<Group gap="xs">
|
||
<Tooltip label="Детали">
|
||
<ActionIcon variant="light" color="blue" onClick={() => setSelectedLog(entry)}>
|
||
<IconEye size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
{isRoot && (
|
||
<Tooltip label="Удалить (только root)">
|
||
<ActionIcon variant="light" color="red" onClick={() => handleDelete(entry)}>
|
||
<IconTrash size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Страница {page} из {totalPages}</Text>
|
||
<Pagination value={page} onChange={setPage} total={totalPages} withEdges />
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
<AdminLogDetailModal
|
||
log={selectedLog}
|
||
opened={selectedLog !== null}
|
||
onClose={() => setSelectedLog(null)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/adminLogs/AdminLogsPage.tsx-----
|
||
|
||
File: src/pages/adminLogs/components/AdminLogDetailModal.tsx
|
||
Lines: 104
|
||
-----BEGIN src/pages/adminLogs/components/AdminLogDetailModal.tsx-----
|
||
import { useMemo } from 'react'
|
||
import { Modal, Stack, Text, Table, Badge, Group, Code, Center } from '@mantine/core'
|
||
import type { AdminActionLog } from '@/api/adminLogs'
|
||
|
||
interface FieldChange {
|
||
field: string
|
||
old: unknown
|
||
new: unknown
|
||
}
|
||
|
||
interface AdminLogDetailModalProps {
|
||
log: AdminActionLog | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
function formatValue(v: unknown): string {
|
||
if (v === null || v === undefined || v === '') return '—'
|
||
if (typeof v === 'boolean') return v ? 'да' : 'нет'
|
||
if (Array.isArray(v)) return v.length ? v.join(', ') : '—'
|
||
return String(v)
|
||
}
|
||
|
||
export default function AdminLogDetailModal({ log, opened, onClose }: AdminLogDetailModalProps) {
|
||
const parsed = useMemo(() => {
|
||
if (!log?.metadata) return null
|
||
try {
|
||
return JSON.parse(log.metadata) as {
|
||
changes?: FieldChange[]
|
||
snapshot?: Record<string, unknown>
|
||
[key: string]: unknown
|
||
}
|
||
} catch {
|
||
return null
|
||
}
|
||
}, [log])
|
||
|
||
return (
|
||
<Modal opened={opened} onClose={onClose} title="Детали действия" size="lg">
|
||
{!log ? null : (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">{log.admin_login}</Text>
|
||
<Badge variant="light">{log.entity_type}</Badge>
|
||
</Group>
|
||
<Text>{log.description}</Text>
|
||
|
||
{parsed?.changes && parsed.changes.length > 0 && (
|
||
<Table striped withTableBorder>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th>Поле</Table.Th>
|
||
<Table.Th>Было</Table.Th>
|
||
<Table.Th>Стало</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{parsed.changes.map((c, i) => (
|
||
<Table.Tr key={i}>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace">{c.field}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="red">{formatValue(c.old)}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="green">{formatValue(c.new)}</Text>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))}
|
||
</Table.Tbody>
|
||
</Table>
|
||
)}
|
||
|
||
{parsed?.snapshot && (
|
||
<Table striped withTableBorder>
|
||
<Table.Tbody>
|
||
{Object.entries(parsed.snapshot).map(([key, value]) => (
|
||
<Table.Tr key={key}>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace" c="dimmed">{key}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm">{formatValue(value)}</Text>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))}
|
||
</Table.Tbody>
|
||
</Table>
|
||
)}
|
||
|
||
{!parsed?.changes && !parsed?.snapshot && parsed && (
|
||
<Code block>{JSON.stringify(parsed, null, 2)}</Code>
|
||
)}
|
||
|
||
{!log.metadata && (
|
||
<Center p="md">
|
||
<Text c="dimmed" size="sm">Дополнительных данных нет</Text>
|
||
</Center>
|
||
)}
|
||
</Stack>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/adminLogs/components/AdminLogDetailModal.tsx-----
|
||
|
||
File: src/pages/admins/AdminsPage.tsx
|
||
Lines: 398
|
||
-----BEGIN src/pages/admins/AdminsPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
TextInput,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconTrash,
|
||
IconPlus,
|
||
IconSearch,
|
||
IconLock,
|
||
IconLockOpen,
|
||
IconPencil,
|
||
IconShield,
|
||
IconUser,
|
||
} from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { notifications } from '@mantine/notifications'
|
||
import {
|
||
useAdmins,
|
||
useDeleteAdmin,
|
||
useUpdateAdmin
|
||
} from '@/features/admins/hooks/useAdmins'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
import CreateAdminModal from './components/CreateAdminModal'
|
||
import EditAdminModal from './components/EditAdminModal'
|
||
import type { Admin } from '@/types/api'
|
||
import dayjs from 'dayjs'
|
||
import 'dayjs/locale/ru'
|
||
|
||
dayjs.locale('ru')
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function AdminsPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [search, setSearch] = useState('')
|
||
const [blockedFilter, setBlockedFilter] = useState<boolean | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
const [editAdmin, setEditAdmin] = useState<Admin | null>(null)
|
||
|
||
const { user: currentUser } = useAuth()
|
||
|
||
const { data, isLoading, isFetching } = useAdmins({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(search && { login: search }),
|
||
...(blockedFilter !== null && { is_blocked: blockedFilter }),
|
||
})
|
||
|
||
const deleteAdmin = useDeleteAdmin()
|
||
const updateAdmin = useUpdateAdmin()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
// 🆕 Проверка, является ли текущий пользователь root
|
||
const isRoot = currentUser?.is_root === true
|
||
|
||
const handleDelete = (id: number, login: string, isAdminRoot: boolean) => {
|
||
// Нельзя удалить себя
|
||
if (currentUser?.id === id) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Вы не можете удалить свой собственный аккаунт',
|
||
color: 'red',
|
||
})
|
||
return
|
||
}
|
||
|
||
// Нельзя удалить root-админа (если текущий не root)
|
||
if (isAdminRoot && !isRoot) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Только root-администратор может удалять других root-администраторов',
|
||
color: 'red',
|
||
})
|
||
return
|
||
}
|
||
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить администратора <b>{login}</b>?
|
||
Это действие нельзя отменить.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteAdmin.mutate(id),
|
||
})
|
||
}
|
||
|
||
const handleToggleBlock = (id: number, login: string, isBlocked: boolean, isAdminRoot: boolean) => {
|
||
// Нельзя заблокировать себя
|
||
if (currentUser?.id === id) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Вы не можете заблокировать свой собственный аккаунт',
|
||
color: 'red',
|
||
})
|
||
return
|
||
}
|
||
|
||
// Нельзя заблокировать root-админа (если текущий не root)
|
||
if (isAdminRoot && !isRoot) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Только root-администратор может блокировать других root-администраторов',
|
||
color: 'red',
|
||
})
|
||
return
|
||
}
|
||
|
||
const action = isBlocked ? 'разблокировать' : 'заблокировать'
|
||
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите действие',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите {action} администратора <b>{login}</b>?
|
||
</Text>
|
||
),
|
||
labels: { confirm: action.charAt(0).toUpperCase() + action.slice(1), cancel: 'Отмена' },
|
||
confirmProps: { color: isBlocked ? 'green' : 'red' },
|
||
onConfirm: () => updateAdmin.mutate({ id, is_blocked: !isBlocked }),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
{/* Заголовок */}
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Администраторы</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
{isRoot && (
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => setCreateModalOpened(true)}
|
||
>
|
||
Создать администратора
|
||
</Button>
|
||
)}
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Предупреждение для не-root пользователей */}
|
||
{!isRoot && (
|
||
<Paper withBorder p="md" bg="yellow.0">
|
||
<Text size="sm">
|
||
⚠️ Создание новых администраторов доступно только для root-администратора.
|
||
</Text>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<TextInput
|
||
label="Поиск по логину"
|
||
placeholder="admin_user..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
|
||
<Switch
|
||
label="Только заблокированные"
|
||
checked={blockedFilter === true}
|
||
onChange={(e) => {
|
||
setBlockedFilter(e.currentTarget.checked ? true : null)
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Логин</Table.Th>
|
||
<Table.Th>Имя</Table.Th>
|
||
<Table.Th>Роль</Table.Th>
|
||
<Table.Th>Telegram</Table.Th>
|
||
<Table.Th>Создан</Table.Th>
|
||
<Table.Th>Последний вход</Table.Th>
|
||
<Table.Th>Последний IP</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 140 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={10}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Администраторы не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((admin) => {
|
||
const isCurrentUser = currentUser?.id === admin.id
|
||
const isAdminRoot = admin.is_root === true
|
||
return (
|
||
<Table.Tr key={admin.id}>
|
||
<Table.Td>{admin.id}</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Text fw={500}>{admin.login}</Text>
|
||
{isCurrentUser && (
|
||
<Badge size="xs" color="blue" variant="light">
|
||
Вы
|
||
</Badge>
|
||
)}
|
||
{isAdminRoot && (
|
||
<Badge
|
||
size="xs"
|
||
color="red"
|
||
variant="filled"
|
||
leftSection={<IconShield size={10} />}
|
||
>
|
||
ROOT
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm">{admin.name || '—'}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap={4}>
|
||
{isAdminRoot && (
|
||
<Badge size="xs" color="red" variant="filled" leftSection={<IconShield size={10} />}>
|
||
ROOT
|
||
</Badge>
|
||
)}
|
||
{admin.is_observer && (
|
||
<Badge size="xs" color="blue" variant="filled" leftSection={<IconUser size={10} />}>
|
||
Наблюдатель
|
||
</Badge>
|
||
)}
|
||
{!isAdminRoot && !admin.is_observer && (
|
||
<Badge size="xs" color="gray" variant="light">
|
||
Админ
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
{admin.telegram_user ? (
|
||
<Text size="sm">{admin.telegram_user.full_name || admin.telegram_user.username || '—'}</Text>
|
||
) : admin.telegram_id ? (
|
||
<Text size="sm" c="dimmed">ID: {admin.telegram_id}</Text>
|
||
) : (
|
||
<Text size="sm" c="dimmed">—</Text>
|
||
)}
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">
|
||
{admin.created_at
|
||
? dayjs(admin.created_at).format('DD.MM.YYYY')
|
||
: '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">
|
||
{admin.last_login
|
||
? dayjs(admin.last_login).format('DD.MM.YYYY HH:mm')
|
||
: '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace" c="dimmed">
|
||
{admin.last_ip_login || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={admin.is_blocked ? 'red' : 'green'}
|
||
variant={admin.is_blocked ? 'filled' : 'light'}
|
||
>
|
||
{admin.is_blocked ? 'Заблокирован' : 'Активен'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditAdmin(admin)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label={admin.is_blocked ? 'Разблокировать' : 'Заблокировать'}>
|
||
<ActionIcon
|
||
variant="light"
|
||
color={admin.is_blocked ? 'green' : 'orange'}
|
||
onClick={() => handleToggleBlock(
|
||
admin.id!,
|
||
admin.login,
|
||
admin.is_blocked || false,
|
||
isAdminRoot
|
||
)}
|
||
disabled={isCurrentUser || (isAdminRoot && !isRoot)}
|
||
>
|
||
{admin.is_blocked ? <IconLockOpen size={16} /> : <IconLock size={16} />}
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(admin.id!, admin.login, isAdminRoot)}
|
||
disabled={isCurrentUser || (isAdminRoot && !isRoot)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
)
|
||
})
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{/* Пагинация */}
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* Индикатор обновления */}
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
{/* Модальные окна */}
|
||
<CreateAdminModal
|
||
opened={createModalOpened}
|
||
onClose={() => setCreateModalOpened(false)}
|
||
/>
|
||
|
||
<EditAdminModal
|
||
admin={editAdmin}
|
||
opened={editAdmin !== null}
|
||
onClose={() => setEditAdmin(null)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/admins/AdminsPage.tsx-----
|
||
|
||
File: src/pages/admins/components/CreateAdminModal.tsx
|
||
Lines: 258
|
||
-----BEGIN src/pages/admins/components/CreateAdminModal.tsx-----
|
||
import { useState, useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Button,
|
||
Text,
|
||
Alert,
|
||
CopyButton,
|
||
ActionIcon,
|
||
Tooltip,
|
||
Group,
|
||
Paper,
|
||
Code,
|
||
Switch,
|
||
Select,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { IconCheck, IconCopy, IconKey, IconAlertCircle, IconShield, IconUser } from '@tabler/icons-react'
|
||
import { useCreateAdmin } from '@/features/admins/hooks/useAdmins'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import type { Admin } from '@/types/api'
|
||
|
||
interface CreateAdminModalProps {
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function CreateAdminModal({ opened, onClose }: CreateAdminModalProps) {
|
||
const [createdAdmin, setCreatedAdmin] = useState<Admin | null>(null)
|
||
const createAdmin = useCreateAdmin()
|
||
const { data: usersData } = useUsers({ limit: 1000 })
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
login: '',
|
||
name: '',
|
||
is_root: false,
|
||
is_observer: false,
|
||
telegram_id: null as number | null,
|
||
},
|
||
validate: {
|
||
login: (value) => {
|
||
if (value.length < 3) return 'Логин должен содержать минимум 3 символа'
|
||
if (!/^[a-zA-Z0-9_]+$/.test(value)) return 'Логин может содержать только буквы, цифры и подчеркивания'
|
||
return null
|
||
},
|
||
telegram_id: (value, values) => {
|
||
if (values.is_observer && !value) {
|
||
return 'Для наблюдателя обязательно выберите Telegram-аккаунт'
|
||
}
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
// Сброс telegram_id при снятии галочки наблюдателя
|
||
useEffect(() => {
|
||
if (!form.values.is_observer) {
|
||
form.setFieldValue('telegram_id', null)
|
||
}
|
||
}, [form.values.is_observer])
|
||
|
||
// Опции пользователей Telegram (только те, у кого есть telegram_id)
|
||
const userOptions = usersData?.data
|
||
?.filter((u) => u.telegram_id && u.telegram_id > 0)
|
||
.map((u) => ({
|
||
value: String(u.telegram_id),
|
||
label: u.full_name || u.username || `ID: ${u.telegram_id}`,
|
||
})) || []
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
try {
|
||
const admin = await createAdmin.mutateAsync({
|
||
login: values.login,
|
||
name: values.name || undefined,
|
||
is_root: values.is_root,
|
||
is_observer: values.is_observer,
|
||
telegram_id: values.is_observer ? values.telegram_id! : undefined,
|
||
})
|
||
setCreatedAdmin(admin)
|
||
form.reset()
|
||
} catch (error) {
|
||
// Ошибка уже обработана в хуке
|
||
}
|
||
}
|
||
|
||
const handleClose = () => {
|
||
setCreatedAdmin(null)
|
||
form.reset()
|
||
onClose()
|
||
}
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={handleClose}
|
||
title="Создание администратора"
|
||
size="md"
|
||
>
|
||
{createdAdmin ? (
|
||
<Stack gap="md">
|
||
<Alert
|
||
icon={<IconKey size={16} />}
|
||
title="Администратор создан"
|
||
color="green"
|
||
variant="light"
|
||
>
|
||
<Text size="sm">
|
||
Администратор <Code>{createdAdmin.login}</Code> успешно создан.
|
||
{createdAdmin.is_root && (
|
||
<Text size="sm" fw={600} mt={4}>
|
||
Выданы root-права 👑
|
||
</Text>
|
||
)}
|
||
{createdAdmin.is_observer && (
|
||
<Text size="sm" fw={600} mt={4}>
|
||
Роль: Наблюдатель 👁
|
||
</Text>
|
||
)}
|
||
</Text>
|
||
</Alert>
|
||
|
||
<Paper withBorder p="md" bg="yellow.0">
|
||
<Stack gap="xs">
|
||
<Group gap="xs">
|
||
<IconAlertCircle size={20} color="orange" />
|
||
<Text fw={600} size="sm">Временный пароль</Text>
|
||
</Group>
|
||
|
||
<Text size="sm" c="dimmed">
|
||
Сохраните этот пароль! После закрытия окна он больше не будет доступен.
|
||
</Text>
|
||
|
||
<Group gap="xs">
|
||
<Code
|
||
block
|
||
style={{
|
||
flex: 1,
|
||
padding: '12px',
|
||
fontSize: '16px',
|
||
fontWeight: 600,
|
||
letterSpacing: '1px',
|
||
}}
|
||
>
|
||
{createdAdmin.password || '—'}
|
||
</Code>
|
||
<CopyButton value={createdAdmin.password || ''} timeout={2000}>
|
||
{({ copied, copy }) => (
|
||
<Tooltip label={copied ? 'Скопировано' : 'Копировать'} withArrow position="right">
|
||
<ActionIcon color={copied ? 'teal' : 'gray'} variant="subtle" onClick={copy}>
|
||
{copied ? <IconCheck size={16} /> : <IconCopy size={16} />}
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
)}
|
||
</CopyButton>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
<Button onClick={handleClose} fullWidth>
|
||
Закрыть
|
||
</Button>
|
||
</Stack>
|
||
) : (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<TextInput
|
||
label="Логин"
|
||
placeholder="admin_user"
|
||
required
|
||
description="Уникальный идентификатор (буквы, цифры, подчеркивания)"
|
||
{...form.getInputProps('login')}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Имя (опционально)"
|
||
placeholder="Иванов Иван"
|
||
description="Отображаемое имя администратора"
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<Paper withBorder p="md" bg={form.values.is_root ? 'red.0' : 'gray.0'}>
|
||
<Switch
|
||
label={
|
||
<Group gap="xs">
|
||
<IconShield size={16} color="red" />
|
||
<Text fw={600}>Выдать root-права</Text>
|
||
</Group>
|
||
}
|
||
description="Администратор сможет создавать других администраторов и управлять root-правами"
|
||
checked={form.values.is_root}
|
||
onChange={(e) => form.setFieldValue('is_root', e.currentTarget.checked)}
|
||
color="red"
|
||
disabled={form.values.is_observer}
|
||
/>
|
||
</Paper>
|
||
|
||
<Paper withBorder p="md" bg={form.values.is_observer ? 'blue.0' : 'gray.0'}>
|
||
<Switch
|
||
label={
|
||
<Group gap="xs">
|
||
<IconUser size={16} color="blue" />
|
||
<Text fw={600}>Наблюдатель</Text>
|
||
</Group>
|
||
}
|
||
description="Ограниченный доступ: только пользователи, заявки и задачи. Обязательна привязка к Telegram-аккаунту"
|
||
checked={form.values.is_observer}
|
||
onChange={(e) => form.setFieldValue('is_observer', e.currentTarget.checked)}
|
||
color="blue"
|
||
disabled={form.values.is_root}
|
||
/>
|
||
</Paper>
|
||
|
||
{form.values.is_observer && (
|
||
<Select
|
||
label="Telegram-аккаунт"
|
||
placeholder="Выберите пользователя"
|
||
data={userOptions}
|
||
value={form.values.telegram_id ? String(form.values.telegram_id) : null}
|
||
onChange={(v) => form.setFieldValue('telegram_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
error={form.errors.telegram_id}
|
||
description="Пользователь бота, от имени которого будут выгружаться данные"
|
||
nothingFoundMessage="Пользователи не найдены"
|
||
/>
|
||
)}
|
||
|
||
{form.values.is_root && (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="red" variant="light">
|
||
<Text size="sm">
|
||
<b>Внимание!</b> Root-права дают полный доступ к системе, включая создание и удаление других администраторов.
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
{form.values.is_observer && (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="blue" variant="light">
|
||
<Text size="sm">
|
||
<b>Наблюдатель</b> видит только пользователей, заявки и задачи. Данные выгружаются только те, что доступны выбранному Telegram-аккаунту в боте.
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={handleClose} disabled={createAdmin.isPending}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={createAdmin.isPending}>
|
||
Создать
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/admins/components/CreateAdminModal.tsx-----
|
||
|
||
File: src/pages/admins/components/EditAdminModal.tsx
|
||
Lines: 202
|
||
-----BEGIN src/pages/admins/components/EditAdminModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Button,
|
||
Text,
|
||
Group,
|
||
Badge,
|
||
Switch,
|
||
Paper,
|
||
Alert,
|
||
Select,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { IconShield, IconAlertCircle, IconUser } from '@tabler/icons-react'
|
||
import { useUpdateAdmin } from '@/features/admins/hooks/useAdmins'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import type { Admin } from '@/types/api'
|
||
|
||
interface EditAdminModalProps {
|
||
admin: Admin | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function EditAdminModal({ admin, opened, onClose }: EditAdminModalProps) {
|
||
const updateAdmin = useUpdateAdmin()
|
||
const { user: currentUser } = useAuth()
|
||
const { data: usersData } = useUsers({ limit: 1000 })
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
name: '',
|
||
is_root: false,
|
||
is_observer: false,
|
||
telegram_id: null as number | null,
|
||
},
|
||
validate: {
|
||
telegram_id: (value, values) => {
|
||
if (values.is_observer && !value) {
|
||
return 'Для наблюдателя обязательно выберите Telegram-аккаунт'
|
||
}
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
useEffect(() => {
|
||
if (admin) {
|
||
form.setValues({
|
||
name: admin.name || '',
|
||
is_root: admin.is_root ?? false,
|
||
is_observer: admin.is_observer ?? false,
|
||
telegram_id: admin.telegram_id || null,
|
||
})
|
||
}
|
||
}, [admin])
|
||
|
||
useEffect(() => {
|
||
if (!form.values.is_observer) {
|
||
form.setFieldValue('telegram_id', null)
|
||
}
|
||
}, [form.values.is_observer])
|
||
|
||
const isCurrentUser = currentUser?.id === admin?.id
|
||
|
||
const userOptions = usersData?.data
|
||
?.filter((u) => u.telegram_id && u.telegram_id > 0)
|
||
.map((u) => ({
|
||
value: String(u.telegram_id),
|
||
label: u.full_name || u.username || `ID: ${u.telegram_id}`,
|
||
})) || []
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (!admin?.id) return
|
||
await updateAdmin.mutateAsync({
|
||
id: admin.id,
|
||
name: values.name || undefined,
|
||
is_root: values.is_root,
|
||
is_observer: values.is_observer,
|
||
telegram_id: values.is_observer ? values.telegram_id! : null,
|
||
})
|
||
onClose()
|
||
}
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>Редактирование администратора</Text>
|
||
{admin && <Badge variant="light">{admin.login}</Badge>}
|
||
{admin?.is_root && (
|
||
<Badge color="red" variant="filled" leftSection={<IconShield size={12} />}>
|
||
ROOT
|
||
</Badge>
|
||
)}
|
||
{admin?.is_observer && (
|
||
<Badge color="blue" variant="filled" leftSection={<IconUser size={12} />}>
|
||
Наблюдатель
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
size="md"
|
||
>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<TextInput
|
||
label="Логин"
|
||
value={admin?.login || ''}
|
||
disabled
|
||
description="Логин нельзя изменить"
|
||
/>
|
||
|
||
<TextInput
|
||
label="Имя"
|
||
placeholder="Иванов Иван"
|
||
description="Отображаемое имя администратора"
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<Paper withBorder p="md" bg={form.values.is_root ? 'red.0' : 'gray.0'}>
|
||
<Switch
|
||
label={
|
||
<Group gap="xs">
|
||
<IconShield size={16} color="red" />
|
||
<Text fw={600}>Root-права</Text>
|
||
</Group>
|
||
}
|
||
description="Может создавать администраторов и управлять root-правами"
|
||
checked={form.values.is_root}
|
||
onChange={(e) => form.setFieldValue('is_root', e.currentTarget.checked)}
|
||
color="red"
|
||
disabled={isCurrentUser || form.values.is_observer}
|
||
/>
|
||
</Paper>
|
||
|
||
<Paper withBorder p="md" bg={form.values.is_observer ? 'blue.0' : 'gray.0'}>
|
||
<Switch
|
||
label={
|
||
<Group gap="xs">
|
||
<IconUser size={16} color="blue" />
|
||
<Text fw={600}>Наблюдатель</Text>
|
||
</Group>
|
||
}
|
||
description="Ограниченный доступ: только пользователи, заявки и задачи"
|
||
checked={form.values.is_observer}
|
||
onChange={(e) => form.setFieldValue('is_observer', e.currentTarget.checked)}
|
||
color="blue"
|
||
disabled={isCurrentUser || form.values.is_root}
|
||
/>
|
||
</Paper>
|
||
|
||
{form.values.is_observer && (
|
||
<Select
|
||
label="Telegram-аккаунт"
|
||
placeholder="Выберите пользователя"
|
||
data={userOptions}
|
||
value={form.values.telegram_id ? String(form.values.telegram_id) : null}
|
||
onChange={(v) => form.setFieldValue('telegram_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
error={form.errors.telegram_id}
|
||
description="Пользователь бота, от имени которого будут выгружаться данные"
|
||
nothingFoundMessage="Пользователи не найдены"
|
||
/>
|
||
)}
|
||
|
||
{isCurrentUser && (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="yellow" variant="light">
|
||
<Text size="sm">
|
||
Вы не можете изменить свои собственные права.
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
{form.values.is_root !== (admin?.is_root ?? false) && !isCurrentUser && (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="red" variant="light">
|
||
<Text size="sm">
|
||
<b>Внимание!</b> Вы изменяете root-права. {form.values.is_root
|
||
? 'Этот администратор получит полный доступ к системе.'
|
||
: 'Этот администратор потеряет возможность создавать других администраторов.'}
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={updateAdmin.isPending}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={updateAdmin.isPending}>
|
||
Сохранить
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/admins/components/EditAdminModal.tsx-----
|
||
|
||
File: src/pages/approvalTasks/ApprovalTasksPage.tsx
|
||
Lines: 284
|
||
-----BEGIN src/pages/approvalTasks/ApprovalTasksPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
Select,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import { IconEye, IconTrash, IconSearch } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useSearchParams } from 'react-router-dom'
|
||
import { useApprovalTasks, useDeleteApprovalTask } from '@/features/approvalTasks/hooks/useApprovalTasks'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { TASK_STATUSES, STATUS_COLORS, STATUS_LABELS } from '@/features/approvalTasks/const'
|
||
import ApprovalTaskDetailsModal from './components/ApprovalTaskDetailsModal'
|
||
import dayjs from 'dayjs'
|
||
import 'dayjs/locale/ru'
|
||
|
||
dayjs.locale('ru')
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function ApprovalTasksPage() {
|
||
// 🆕 Начальный статус берём из URL (например, с дашборда:
|
||
// /approval-tasks?status=completed) — читаем один раз при монтировании.
|
||
const [searchParams] = useSearchParams()
|
||
|
||
const [page, setPage] = useState(1)
|
||
const [statusFilter, setStatusFilter] = useState<string | null>(
|
||
() => searchParams.get('status')
|
||
)
|
||
const [executorFilter, setExecutorFilter] = useState<string | null>(null)
|
||
const [requireFileFilter, setRequireFileFilter] = useState<boolean | null>(null)
|
||
const [selectedTaskId, setSelectedTaskId] = useState<number | null>(null)
|
||
|
||
const { data, isLoading, isFetching } = useApprovalTasks({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(statusFilter && { status: statusFilter }),
|
||
...(executorFilter && { executor_id: Number(executorFilter) }),
|
||
...(requireFileFilter !== null && { require_file: requireFileFilter }),
|
||
})
|
||
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const deleteTask = useDeleteApprovalTask()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const executorOptions = users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || '',
|
||
})) || []
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить эту задачу? Это действие нельзя отменить.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteTask.mutate(id),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Задачи по заявкам</Text>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
</Group>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<Select
|
||
label="Статус"
|
||
placeholder="Все статусы"
|
||
data={TASK_STATUSES.map((s) => ({ value: s.value, label: s.label }))}
|
||
value={statusFilter}
|
||
onChange={(v) => {
|
||
setStatusFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
style={{ minWidth: 180 }}
|
||
/>
|
||
|
||
<Select
|
||
label="Исполнитель"
|
||
placeholder="Все исполнители"
|
||
data={executorOptions}
|
||
value={executorFilter}
|
||
onChange={(v) => {
|
||
setExecutorFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
style={{ minWidth: 200 }}
|
||
/>
|
||
|
||
<Switch
|
||
label="Требуют файл"
|
||
checked={requireFileFilter === true}
|
||
onChange={(e) => {
|
||
setRequireFileFilter(e.currentTarget.checked ? true : null)
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Заявка</Table.Th>
|
||
<Table.Th>Исполнитель</Table.Th>
|
||
<Table.Th>Текст задачи</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Шаг</Table.Th>
|
||
<Table.Th style={{ width: 120 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Файл</Table.Th>
|
||
<Table.Th>Создана</Table.Th>
|
||
<Table.Th>Выполнена</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={10}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Задачи не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((task) => (
|
||
<Table.Tr key={task.id}>
|
||
<Table.Td>
|
||
<Text fw={500}>#{task.id}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Stack gap={0}>
|
||
<Text size="xs" c="dimmed">
|
||
#{task.approval_id}
|
||
</Text>
|
||
<Text size="sm" lineClamp={1}>
|
||
{task.approval?.topic?.name || '—'}
|
||
</Text>
|
||
</Stack>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm">
|
||
{task.executor?.full_name || '—'}
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
{task.executor?.department?.name}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={2}>
|
||
{task.task_text || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge variant="light" color="gray">
|
||
#{task.step_order}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={STATUS_COLORS[task.status || ''] || 'gray'}
|
||
variant={task.status === 'completed' ? 'filled' : 'light'}
|
||
>
|
||
{STATUS_LABELS[task.status || ''] || task.status}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
{task.require_file ? (
|
||
<Badge size="xs" color="violet" variant="light">
|
||
Да
|
||
</Badge>
|
||
) : (
|
||
<Text size="xs" c="dimmed">—</Text>
|
||
)}
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="xs" c="dimmed">
|
||
{task.created_at
|
||
? dayjs(task.created_at).format('DD.MM.YYYY HH:mm')
|
||
: '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="xs" c="dimmed">
|
||
{task.completed_at
|
||
? dayjs(task.completed_at).format('DD.MM.YYYY HH:mm')
|
||
: '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Просмотреть">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setSelectedTaskId(task.id!)}
|
||
>
|
||
<IconEye size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(task.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
<ApprovalTaskDetailsModal
|
||
taskId={selectedTaskId}
|
||
opened={selectedTaskId !== null}
|
||
onClose={() => setSelectedTaskId(null)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/approvalTasks/ApprovalTasksPage.tsx-----
|
||
|
||
File: src/pages/approvalTasks/components/ApprovalTaskDetailsModal.tsx
|
||
Lines: 396
|
||
-----BEGIN src/pages/approvalTasks/components/ApprovalTaskDetailsModal.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Text,
|
||
Group,
|
||
Badge,
|
||
Paper,
|
||
Loader,
|
||
Center,
|
||
ScrollArea,
|
||
Select,
|
||
Button,
|
||
Box,
|
||
ActionIcon,
|
||
Tooltip,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { notifications } from '@mantine/notifications'
|
||
import {
|
||
IconUser,
|
||
IconBuilding,
|
||
IconCalendar,
|
||
IconFileText,
|
||
IconCheck,
|
||
IconEye,
|
||
IconDownload,
|
||
} from '@tabler/icons-react'
|
||
import { useApprovalTask, useUpdateApprovalTask } from '@/features/approvalTasks/hooks/useApprovalTasks'
|
||
import { TASK_STATUSES, STATUS_COLORS, STATUS_LABELS } from '@/features/approvalTasks/const'
|
||
import FilePreviewModal from '@/pages/approvals/components/FilePreviewModal'
|
||
import dayjs from 'dayjs'
|
||
import 'dayjs/locale/ru'
|
||
|
||
dayjs.locale('ru')
|
||
|
||
interface ApprovalTaskDetailsModalProps {
|
||
taskId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
// Определение MIME типа по расширению
|
||
const getMimeType = (fileName: string): string => {
|
||
const ext = fileName.split('.').pop()?.toLowerCase() || ''
|
||
const mimeTypes: Record<string, string> = {
|
||
'jpg': 'image/jpeg', 'jpeg': 'image/jpeg', 'png': 'image/png',
|
||
'gif': 'image/gif', 'webp': 'image/webp', 'svg': 'image/svg+xml',
|
||
'pdf': 'application/pdf', 'txt': 'text/plain',
|
||
'doc': 'application/msword',
|
||
'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
'xls': 'application/vnd.ms-excel',
|
||
'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
}
|
||
return mimeTypes[ext] || 'application/octet-stream'
|
||
}
|
||
|
||
const PREVIEWABLE_TYPES = [
|
||
'image/jpeg', 'image/png', 'image/gif', 'image/webp',
|
||
'image/svg+xml', 'application/pdf', 'text/plain',
|
||
]
|
||
|
||
export default function ApprovalTaskDetailsModal({
|
||
taskId,
|
||
opened,
|
||
onClose
|
||
}: ApprovalTaskDetailsModalProps) {
|
||
const { data: task, isLoading } = useApprovalTask(taskId)
|
||
const updateTask = useUpdateApprovalTask()
|
||
|
||
// Состояние для предпросмотра файла
|
||
const [previewFileId, setPreviewFileId] = useState<number | null>(null)
|
||
const [previewFileName, setPreviewFileName] = useState('')
|
||
const [previewFileType, setPreviewFileType] = useState('')
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
status: '',
|
||
},
|
||
})
|
||
|
||
const handleFilePreview = (fileId: number, fileName: string) => {
|
||
setPreviewFileId(fileId)
|
||
setPreviewFileName(fileName)
|
||
setPreviewFileType(getMimeType(fileName))
|
||
}
|
||
|
||
const handleFileDownload = async (fileId: number, fileName: string) => {
|
||
try {
|
||
const token = localStorage.getItem('token')
|
||
const timestamp = Math.floor(Date.now() / 1000).toString()
|
||
const publicKey = import.meta.env.VITE_API_PUBLIC_KEY
|
||
const privateKey = import.meta.env.VITE_API_PRIVATE_KEY
|
||
const message = publicKey + ':' + timestamp
|
||
const CryptoJS = await import('crypto-js')
|
||
const signature = CryptoJS.HmacSHA256(message, privateKey).toString(CryptoJS.enc.Hex)
|
||
const deviceId = localStorage.getItem('device_id') || 'admin-panel'
|
||
|
||
// 🆕 Используем URL для задач
|
||
const url = `/api/approval-tasks/${taskId}/files/${fileId}/download`
|
||
|
||
const response = await fetch(url, {
|
||
method: 'GET',
|
||
headers: {
|
||
'Authorization': `Bearer ${token}`,
|
||
'ApiKey': signature,
|
||
'X-Timestamp': timestamp,
|
||
'x-device-id': deviceId,
|
||
},
|
||
})
|
||
|
||
if (!response.ok) throw new Error('Failed to download file')
|
||
|
||
const blob = await response.blob()
|
||
const blobUrl = window.URL.createObjectURL(blob)
|
||
const link = document.createElement('a')
|
||
link.href = blobUrl
|
||
link.download = fileName
|
||
document.body.appendChild(link)
|
||
link.click()
|
||
link.remove()
|
||
window.URL.revokeObjectURL(blobUrl)
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: 'Файл скачан',
|
||
color: 'green',
|
||
})
|
||
} catch (error) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Не удалось скачать файл',
|
||
color: 'red',
|
||
})
|
||
}
|
||
}
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (!task?.id) return
|
||
await updateTask.mutateAsync({
|
||
id: task.id,
|
||
status: values.status,
|
||
})
|
||
onClose()
|
||
}
|
||
|
||
return (
|
||
<>
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>Задача #{taskId}</Text>
|
||
{task && (
|
||
<Badge color={STATUS_COLORS[task.status || ''] || 'gray'}>
|
||
{STATUS_LABELS[task.status || ''] || task.status}
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
size="xl"
|
||
styles={{
|
||
body: {
|
||
height: 'calc(80vh - 120px)',
|
||
padding: 0,
|
||
},
|
||
}}
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : task ? (
|
||
<ScrollArea
|
||
style={{ height: 'calc(80vh - 120px)' }}
|
||
offsetScrollbars
|
||
>
|
||
<Box p="md">
|
||
<Stack gap="md">
|
||
{/* Информация о задаче */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Информация о задаче</Text>
|
||
<Stack gap="sm">
|
||
<Text size="sm" c="dimmed">Текст задачи:</Text>
|
||
<Text size="sm" style={{ whiteSpace: 'pre-wrap' }}>
|
||
{task.task_text || '—'}
|
||
</Text>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Шаг:</Text>
|
||
<Badge variant="light">#{task.step_order}</Badge>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Требует файл:</Text>
|
||
<Badge color={task.require_file ? 'violet' : 'gray'} variant="light">
|
||
{task.require_file ? 'Да' : 'Нет'}
|
||
</Badge>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* 🆕 Прикреплённые файлы */}
|
||
{task.files && task.files.length > 0 && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Прикреплённые файлы</Text>
|
||
<Stack gap="xs">
|
||
{task.files.map((file) => {
|
||
const mimeType = getMimeType(file.file_name || '')
|
||
const canPreview = PREVIEWABLE_TYPES.includes(mimeType)
|
||
const fileSizeKB = file.file_base64
|
||
? Math.round((file.file_base64.length * 3 / 4) / 1024)
|
||
: 0
|
||
|
||
return (
|
||
<Paper key={file.id} withBorder p="sm">
|
||
<Group justify="space-between">
|
||
<Group gap="sm">
|
||
<IconFileText size={20} color="blue" />
|
||
<Stack gap={0}>
|
||
<Text size="sm" fw={500}>
|
||
{file.file_name || 'Без имени'}
|
||
</Text>
|
||
{fileSizeKB > 0 && (
|
||
<Text size="xs" c="dimmed">
|
||
{fileSizeKB} KB
|
||
</Text>
|
||
)}
|
||
</Stack>
|
||
</Group>
|
||
<Group gap="xs">
|
||
{canPreview && (
|
||
<Tooltip label="Предпросмотр">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => handleFilePreview(file.id!, file.file_name || '')}
|
||
>
|
||
<IconEye size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
)}
|
||
<Tooltip label="Скачать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="green"
|
||
onClick={() => handleFileDownload(file.id!, file.file_name || '')}
|
||
>
|
||
<IconDownload size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Group>
|
||
</Paper>
|
||
)
|
||
})}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Связанная заявка */}
|
||
{task.approval && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Связанная заявка</Text>
|
||
<Stack gap="sm">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">ID заявки:</Text>
|
||
<Text fw={500}>#{task.approval.id}</Text>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Тема:</Text>
|
||
<Text>{task.approval.topic?.name || '—'}</Text>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Инициатор:</Text>
|
||
<Group gap="xs">
|
||
<IconUser size={16} />
|
||
<Text>{task.approval.initiator?.full_name || '—'}</Text>
|
||
</Group>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Статус заявки:</Text>
|
||
<Badge>{task.approval.status}</Badge>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Исполнитель */}
|
||
{task.executor && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Исполнитель</Text>
|
||
<Stack gap="sm">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Имя:</Text>
|
||
<Group gap="xs">
|
||
<IconUser size={16} />
|
||
<Text fw={500}>{task.executor.full_name}</Text>
|
||
</Group>
|
||
</Group>
|
||
{task.executor.department && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Отдел:</Text>
|
||
<Group gap="xs">
|
||
<IconBuilding size={16} />
|
||
<Text>{task.executor.department.name}</Text>
|
||
</Group>
|
||
</Group>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Даты */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Временные метки</Text>
|
||
<Stack gap="sm">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Создана:</Text>
|
||
<Group gap="xs">
|
||
<IconCalendar size={16} />
|
||
<Text>
|
||
{task.created_at
|
||
? dayjs(task.created_at).format('DD.MM.YYYY HH:mm')
|
||
: '—'}
|
||
</Text>
|
||
</Group>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Обновлена:</Text>
|
||
<Text>
|
||
{task.updated_at
|
||
? dayjs(task.updated_at).format('DD.MM.YYYY HH:mm')
|
||
: '—'}
|
||
</Text>
|
||
</Group>
|
||
{task.completed_at && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Выполнена:</Text>
|
||
<Group gap="xs">
|
||
<IconCheck size={16} color="green" />
|
||
<Text c="green">
|
||
{dayjs(task.completed_at).format('DD.MM.YYYY HH:mm')}
|
||
</Text>
|
||
</Group>
|
||
</Group>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Форма обновления статуса */}
|
||
<Paper withBorder p="md" bg="blue.0">
|
||
<Text size="sm" fw={600} mb="sm">Изменить статус</Text>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<Select
|
||
label="Новый статус"
|
||
placeholder="Выберите статус"
|
||
data={TASK_STATUSES.map((s) => ({ value: s.value, label: s.label }))}
|
||
value={form.values.status || task.status}
|
||
onChange={(v) => form.setFieldValue('status', v || '')}
|
||
required
|
||
/>
|
||
<Group justify="flex-end">
|
||
<Button
|
||
type="submit"
|
||
loading={updateTask.isPending}
|
||
leftSection={<IconCheck size={16} />}
|
||
>
|
||
Обновить статус
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Paper>
|
||
</Stack>
|
||
</Box>
|
||
</ScrollArea>
|
||
) : (
|
||
<Center p={40}>
|
||
<Text c="dimmed">Задача не найдена</Text>
|
||
</Center>
|
||
)}
|
||
</Modal>
|
||
|
||
{previewFileId && taskId && (
|
||
<FilePreviewModal
|
||
taskId={taskId}
|
||
fileId={previewFileId}
|
||
fileName={previewFileName}
|
||
fileType={previewFileType}
|
||
opened={!!previewFileId}
|
||
onClose={() => setPreviewFileId(null)}
|
||
/>
|
||
)}
|
||
</>
|
||
)
|
||
}
|
||
-----END src/pages/approvalTasks/components/ApprovalTaskDetailsModal.tsx-----
|
||
|
||
File: src/pages/approvals/ApprovalsPage.tsx
|
||
Lines: 614
|
||
-----BEGIN src/pages/approvals/ApprovalsPage.tsx-----
|
||
import { useEffect, useState, useMemo } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
TextInput,
|
||
Select,
|
||
MultiSelect,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Divider,
|
||
Alert,
|
||
} from '@mantine/core'
|
||
import { DatePickerInput } from '@mantine/dates'
|
||
import {
|
||
IconEye,
|
||
IconSearch,
|
||
IconFileText,
|
||
IconFileExcel,
|
||
IconInfoCircle,
|
||
IconX,
|
||
IconFilter,
|
||
} from '@tabler/icons-react'
|
||
import { notifications } from '@mantine/notifications'
|
||
import { useSearchParams } from 'react-router-dom'
|
||
import { useApprovals } from '@/features/approvals/hooks/useApprovals'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import { useDepartments } from '@/features/departments/hooks/useDepartments'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { approvalsApi } from '@/api/approvals'
|
||
import ApprovalDetailsModal from './components/ApprovalDetailsModal'
|
||
import dayjs from 'dayjs'
|
||
import 'dayjs/locale/ru'
|
||
import { useDebouncedValue } from '@mantine/hooks'
|
||
|
||
dayjs.locale('ru')
|
||
|
||
const LIMIT = 20
|
||
|
||
const STATUS_COLORS: Record<string, string> = {
|
||
pending: 'blue',
|
||
approved: 'green',
|
||
rejected: 'red',
|
||
revoked: 'orange',
|
||
revision: 'violet',
|
||
}
|
||
|
||
const STATUS_LABELS: Record<string, string> = {
|
||
pending: 'На согласовании',
|
||
approved: 'Согласована',
|
||
rejected: 'Отклонена',
|
||
revoked: 'Отозвана',
|
||
revision: 'На доработке',
|
||
}
|
||
|
||
export default function ApprovalsPage() {
|
||
// 🆕 Значения фильтров, с которыми пришли по ссылке (например, с
|
||
// дашборда: /approvals?status=pending&date_to=2026-07-20). Читаем
|
||
// только один раз при монтировании — страница не синхронизирует
|
||
// фильтры с URL постоянно, только принимает начальное состояние.
|
||
const [searchParams] = useSearchParams()
|
||
|
||
// === Состояния фильтров ===
|
||
const [page, setPage] = useState(1)
|
||
const [searchInput, setSearchInput] = useState('')
|
||
const [search, setSearch] = useState('')
|
||
const [searchError, setSearchError] = useState<string | null>(null)
|
||
const [debouncedSearch] = useDebouncedValue(searchInput, 400)
|
||
|
||
const [statusFilter, setStatusFilter] = useState<string | null>(
|
||
() => searchParams.get('status')
|
||
)
|
||
const [categoryFilter, setCategoryFilter] = useState<string[]>([])
|
||
const [topicFilter, setTopicFilter] = useState<string[]>([])
|
||
const [departmentFilter, setDepartmentFilter] = useState<string | null>(null)
|
||
const [initiatorFilter, setInitiatorFilter] = useState<string | null>(null)
|
||
const [dateFrom, setDateFrom] = useState<Date | null>(() => {
|
||
const v = searchParams.get('date_from')
|
||
return v ? dayjs(v).toDate() : null
|
||
})
|
||
const [dateTo, setDateTo] = useState<Date | null>(() => {
|
||
const v = searchParams.get('date_to')
|
||
return v ? dayjs(v).toDate() : null
|
||
})
|
||
|
||
// === Отчёт ===
|
||
const [reportDateFrom, setReportDateFrom] = useState<Date | null>(null)
|
||
const [reportDateTo, setReportDateTo] = useState<Date | null>(null)
|
||
const [reportLoading, setReportLoading] = useState(false)
|
||
|
||
const [selectedApprovalId, setSelectedApprovalId] = useState<number | null>(null)
|
||
|
||
// === Обработка поиска ===
|
||
useEffect(() => {
|
||
if (debouncedSearch === '') {
|
||
setSearch('')
|
||
setSearchError(null)
|
||
setPage(1)
|
||
return
|
||
}
|
||
if (debouncedSearch.length < 2) {
|
||
setSearchError('Введите минимум 2 символа')
|
||
return
|
||
}
|
||
setSearchError(null)
|
||
setSearch(debouncedSearch)
|
||
setPage(1)
|
||
}, [debouncedSearch])
|
||
|
||
// === Загрузка справочников ===
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
const { data: allTopics } = useTopics({ limit: 1000 })
|
||
const { data: departments } = useDepartments()
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
|
||
// === Темы, отфильтрованные по выбранным категориям ===
|
||
const filteredTopics = useMemo(() => {
|
||
if (!allTopics?.data) return []
|
||
if (categoryFilter.length === 0) return allTopics.data
|
||
const categoryIds = categoryFilter.map(Number)
|
||
return allTopics.data.filter((t) =>
|
||
t.category_id && categoryIds.includes(t.category_id)
|
||
)
|
||
}, [allTopics, categoryFilter])
|
||
|
||
// === Сброс невалидных тем при изменении категорий ===
|
||
useEffect(() => {
|
||
if (categoryFilter.length > 0 && topicFilter.length > 0) {
|
||
const validTopicIds = new Set(filteredTopics.map((t) => String(t.id)))
|
||
const validSelected = topicFilter.filter((id) => validTopicIds.has(id))
|
||
if (validSelected.length !== topicFilter.length) {
|
||
setTopicFilter(validSelected)
|
||
}
|
||
}
|
||
// Если категории сброшены — темы остаются как есть
|
||
}, [categoryFilter, filteredTopics, topicFilter])
|
||
|
||
// === Опции для Select/MultiSelect ===
|
||
const categoryOptions = useMemo(
|
||
() =>
|
||
categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || [],
|
||
[categories]
|
||
)
|
||
|
||
const topicOptions = useMemo(
|
||
() =>
|
||
filteredTopics.map((t) => ({
|
||
value: String(t.id),
|
||
label: `${t.category?.name || '—'} / ${t.name || ''}`,
|
||
})),
|
||
[filteredTopics]
|
||
)
|
||
|
||
const departmentOptions = useMemo(
|
||
() =>
|
||
departments?.data?.map((d) => ({
|
||
value: String(d.id),
|
||
label: d.name || '',
|
||
})) || [],
|
||
[departments]
|
||
)
|
||
|
||
const userOptions = useMemo(
|
||
() =>
|
||
users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || u.username || `ID: ${u.id}`,
|
||
})) || [],
|
||
[users]
|
||
)
|
||
|
||
// === Формирование параметров запроса ===
|
||
const requestParams = useMemo(() => {
|
||
const params: any = {
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
}
|
||
if (search) params.content = search
|
||
if (statusFilter) params.status = statusFilter
|
||
if (departmentFilter) params.department_id = Number(departmentFilter)
|
||
if (initiatorFilter) params.initiator_id = Number(initiatorFilter)
|
||
if (categoryFilter.length > 0) {
|
||
params.category_ids = categoryFilter.map(Number)
|
||
}
|
||
if (topicFilter.length > 0) {
|
||
params.topic_ids = topicFilter.map(Number)
|
||
}
|
||
if (dateFrom) params.date_from = dayjs(dateFrom).format('YYYY-MM-DD')
|
||
if (dateTo) params.date_to = dayjs(dateTo).format('YYYY-MM-DD')
|
||
return params
|
||
}, [
|
||
page, search, statusFilter, departmentFilter,
|
||
initiatorFilter, categoryFilter, topicFilter, dateFrom, dateTo,
|
||
])
|
||
|
||
// === Запрос списка заявок ===
|
||
const { data, isLoading, isFetching } = useApprovals(requestParams)
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
// === Сброс фильтров ===
|
||
const handleResetFilters = () => {
|
||
setSearchInput('')
|
||
setSearch('')
|
||
setStatusFilter(null)
|
||
setCategoryFilter([])
|
||
setTopicFilter([])
|
||
setDepartmentFilter(null)
|
||
setInitiatorFilter(null)
|
||
setDateFrom(null)
|
||
setDateTo(null)
|
||
setPage(1)
|
||
}
|
||
|
||
const hasActiveFilters =
|
||
search ||
|
||
statusFilter ||
|
||
categoryFilter.length > 0 ||
|
||
topicFilter.length > 0 ||
|
||
departmentFilter ||
|
||
initiatorFilter ||
|
||
dateFrom ||
|
||
dateTo
|
||
|
||
// === Генерация отчёта ===
|
||
const handleGenerateReport = async () => {
|
||
setReportLoading(true)
|
||
try {
|
||
const params: any = { all_access: true }
|
||
if (reportDateFrom) params.date_from = dayjs(reportDateFrom).format('YYYY-MM-DD')
|
||
if (reportDateTo) params.date_to = dayjs(reportDateTo).format('YYYY-MM-DD')
|
||
|
||
const response = await approvalsApi.downloadReport(params)
|
||
const blob = new Blob([response.data], {
|
||
type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
})
|
||
const url = window.URL.createObjectURL(blob)
|
||
const link = document.createElement('a')
|
||
link.href = url
|
||
const now = dayjs()
|
||
link.setAttribute(
|
||
'download',
|
||
`Согласования_${now.format('DD.MM.YYYY')}_${now.format('HH-mm')}.xlsx`
|
||
)
|
||
document.body.appendChild(link)
|
||
link.click()
|
||
link.remove()
|
||
window.URL.revokeObjectURL(url)
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: 'Отчёт сформирован и скачан',
|
||
color: 'green',
|
||
})
|
||
} catch (error: any) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: error.response?.data?.error_description || 'Не удалось сформировать отчёт',
|
||
color: 'red',
|
||
})
|
||
} finally {
|
||
setReportLoading(false)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
{/* Заголовок */}
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Заявки</Text>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
</Group>
|
||
|
||
{/* Секция отчёта */}
|
||
<Paper withBorder p="md" bg="blue.0">
|
||
<Stack gap="sm">
|
||
<Group justify="space-between">
|
||
<Group gap="xs">
|
||
<IconFileExcel size={20} color="blue" />
|
||
<Text fw={600} size="lg">Формирование отчёта</Text>
|
||
</Group>
|
||
<Button
|
||
leftSection={<IconFileExcel size={16} />}
|
||
color="green"
|
||
onClick={handleGenerateReport}
|
||
loading={reportLoading}
|
||
size="sm"
|
||
>
|
||
Скачать XLSX
|
||
</Button>
|
||
</Group>
|
||
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light" p="xs">
|
||
<Text size="sm">
|
||
Выберите период для выгрузки отчёта. Если даты не указаны — будут выгружены все заявки.
|
||
</Text>
|
||
</Alert>
|
||
|
||
<Group gap="md" align="flex-end">
|
||
<DatePickerInput
|
||
label="Дата начала периода"
|
||
placeholder="Выберите дату"
|
||
value={reportDateFrom}
|
||
onChange={(val) => setReportDateFrom(val as Date | null)}
|
||
clearable
|
||
style={{ flex: 1 }}
|
||
/>
|
||
<DatePickerInput
|
||
label="Дата окончания периода"
|
||
placeholder="Выберите дату"
|
||
value={reportDateTo}
|
||
onChange={(val) => setReportDateTo(val as Date | null)}
|
||
clearable
|
||
minDate={reportDateFrom || undefined}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
<Divider />
|
||
|
||
{/* Фильтры списка */}
|
||
<Paper withBorder p="md">
|
||
<Group justify="space-between" mb="sm">
|
||
<Group gap="xs">
|
||
<IconFilter size={20} />
|
||
<Text fw={600} size="lg">Фильтры</Text>
|
||
</Group>
|
||
{hasActiveFilters && (
|
||
<Button
|
||
variant="subtle"
|
||
color="gray"
|
||
size="xs"
|
||
leftSection={<IconX size={14} />}
|
||
onClick={handleResetFilters}
|
||
>
|
||
Сбросить фильтры
|
||
</Button>
|
||
)}
|
||
</Group>
|
||
|
||
<Stack gap="md">
|
||
{/* Строка 1: Поиск + Статус + Инициатор */}
|
||
<Group gap="md" align="flex-end" grow>
|
||
<TextInput
|
||
label="Поиск по тексту"
|
||
placeholder="Введите 2+ символа..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={searchInput}
|
||
onChange={(e) => setSearchInput(e.currentTarget.value)}
|
||
error={searchError}
|
||
rightSection={
|
||
searchInput && (
|
||
<ActionIcon
|
||
variant="subtle"
|
||
onClick={() => setSearchInput('')}
|
||
>
|
||
<IconX size={14} />
|
||
</ActionIcon>
|
||
)
|
||
}
|
||
/>
|
||
|
||
<Select
|
||
label="Статус"
|
||
placeholder="Все статусы"
|
||
data={[
|
||
{ value: 'pending', label: 'На согласовании' },
|
||
{ value: 'approved', label: 'Согласована' },
|
||
{ value: 'rejected', label: 'Отклонена' },
|
||
{ value: 'revoked', label: 'Отозвана' },
|
||
{ value: 'revision', label: 'На доработке' },
|
||
]}
|
||
value={statusFilter}
|
||
onChange={(v) => {
|
||
setStatusFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
/>
|
||
|
||
<Select
|
||
label="Инициатор"
|
||
placeholder="Все инициаторы"
|
||
data={userOptions}
|
||
value={initiatorFilter}
|
||
onChange={(v) => {
|
||
setInitiatorFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
/>
|
||
</Group>
|
||
|
||
{/* Строка 2: Категории + Темы + Отдел */}
|
||
<Group gap="md" align="flex-end" grow>
|
||
<MultiSelect
|
||
label="Категории"
|
||
placeholder="Все категории"
|
||
data={categoryOptions}
|
||
value={categoryFilter}
|
||
onChange={(v) => {
|
||
setCategoryFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
nothingFoundMessage="Категории не найдены"
|
||
/>
|
||
|
||
<MultiSelect
|
||
label="Темы"
|
||
placeholder={
|
||
categoryFilter.length > 0
|
||
? 'Выберите темы'
|
||
: 'Все темы'
|
||
}
|
||
data={topicOptions}
|
||
value={topicFilter}
|
||
onChange={(v) => {
|
||
setTopicFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
disabled={filteredTopics.length === 0}
|
||
nothingFoundMessage="Темы не найдены"
|
||
description={
|
||
categoryFilter.length > 0
|
||
? `Показаны темы выбранных категорий (${filteredTopics.length})`
|
||
: undefined
|
||
}
|
||
/>
|
||
|
||
<Select
|
||
label="Отдел"
|
||
placeholder="Все отделы"
|
||
data={departmentOptions}
|
||
value={departmentFilter}
|
||
onChange={(v) => {
|
||
setDepartmentFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
/>
|
||
</Group>
|
||
|
||
{/* Строка 3: Период дат */}
|
||
<Group gap="md" align="flex-end" grow>
|
||
<DatePickerInput
|
||
label="Дата создания от"
|
||
placeholder="Выберите дату"
|
||
value={dateFrom}
|
||
onChange={(val) => {
|
||
setDateFrom(val as Date | null)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
maxDate={dateTo || undefined}
|
||
/>
|
||
<DatePickerInput
|
||
label="Дата создания до"
|
||
placeholder="Выберите дату"
|
||
value={dateTo}
|
||
onChange={(val) => {
|
||
setDateTo(val as Date | null)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
minDate={dateFrom || undefined}
|
||
/>
|
||
<Box style={{ flex: 1 }} />
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Категория / Тема</Table.Th>
|
||
<Table.Th>Инициатор</Table.Th>
|
||
<Table.Th>Отдел</Table.Th>
|
||
<Table.Th>Дата создания</Table.Th>
|
||
<Table.Th style={{ width: 150 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={7}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Заявки не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((approval) => (
|
||
<Table.Tr key={approval.id}>
|
||
<Table.Td>
|
||
<Text fw={500}>#{approval.id}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Stack gap={0}>
|
||
<Text size="xs" c="dimmed">
|
||
{approval.topic?.category?.name || '—'}
|
||
</Text>
|
||
<Group gap="xs">
|
||
<IconFileText size={14} color="gray" />
|
||
<Text size="sm" lineClamp={1}>
|
||
{approval.topic?.name || 'Тема не указана'}
|
||
</Text>
|
||
</Group>
|
||
</Stack>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm">
|
||
{approval.initiator?.full_name || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">
|
||
{approval.department?.name || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">
|
||
{approval.created_at
|
||
? dayjs(approval.created_at).format('DD.MM.YYYY HH:mm')
|
||
: '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={STATUS_COLORS[approval.status || ''] || 'gray'}
|
||
variant={approval.status === 'pending' ? 'light' : 'filled'}
|
||
>
|
||
{STATUS_LABELS[approval.status || ''] || approval.status}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Tooltip label="Просмотреть детали">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setSelectedApprovalId(approval.id!)}
|
||
>
|
||
<IconEye size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
<ApprovalDetailsModal
|
||
approvalId={selectedApprovalId}
|
||
opened={selectedApprovalId !== null}
|
||
onClose={() => setSelectedApprovalId(null)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/approvals/ApprovalsPage.tsx-----
|
||
|
||
File: src/pages/approvals/components/ApprovalDetailsModal.tsx
|
||
Lines: 690
|
||
-----BEGIN src/pages/approvals/components/ApprovalDetailsModal.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Text,
|
||
Group,
|
||
Badge,
|
||
Paper,
|
||
Loader,
|
||
Center,
|
||
Timeline,
|
||
ScrollArea,
|
||
Box,
|
||
ActionIcon,
|
||
Tooltip,
|
||
Alert,
|
||
Divider,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconUser,
|
||
IconBuilding,
|
||
IconCalendar,
|
||
IconFileText,
|
||
IconCheck,
|
||
IconX,
|
||
IconClock,
|
||
IconAlertCircle,
|
||
IconEye,
|
||
IconDownload,
|
||
IconMessageCircle,
|
||
IconUserPlus,
|
||
IconEyeglass,
|
||
IconRotate,
|
||
IconChecklist,
|
||
IconAlertTriangle,
|
||
} from '@tabler/icons-react'
|
||
import { notifications } from '@mantine/notifications'
|
||
import {
|
||
useApproval,
|
||
useAdditionalApprovers,
|
||
useApprovalComments,
|
||
useApprovalObservers,
|
||
useRevocationRequest,
|
||
useApprovalTasks,
|
||
} from '@/features/approvals/hooks/useApprovals'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import FilePreviewModal from './FilePreviewModal'
|
||
import { formatMsk } from '@/utils/date'
|
||
|
||
interface ApprovalDetailsModalProps {
|
||
approvalId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
const STATUS_COLORS: Record<string, string> = {
|
||
draft: 'gray',
|
||
pending: 'blue',
|
||
approved: 'green',
|
||
rejected: 'red',
|
||
revoked: 'orange',
|
||
revision: 'violet',
|
||
}
|
||
|
||
const STATUS_LABELS: Record<string, string> = {
|
||
pending: 'На согласовании',
|
||
approved: 'Согласована',
|
||
rejected: 'Отклонена',
|
||
revoked: 'Отозвана',
|
||
revision: 'На доработке',
|
||
}
|
||
|
||
const STEP_STATUS_ICONS: Record<string, any> = {
|
||
pending: IconClock,
|
||
approved: IconCheck,
|
||
rejected: IconX,
|
||
waiting: IconClock,
|
||
cancelled_any_of: IconAlertCircle,
|
||
}
|
||
|
||
const STEP_STATUS_COLORS: Record<string, string> = {
|
||
pending: 'blue',
|
||
approved: 'green',
|
||
rejected: 'red',
|
||
waiting: 'gray',
|
||
cancelled_any_of: 'orange',
|
||
}
|
||
|
||
// Статусы "доп. согласующего" — те же значения, что в handleDecision
|
||
// (isAdditionalApprover): "pending" / "approved" / "rejected".
|
||
const ADDITIONAL_APPROVER_LABELS: Record<string, string> = {
|
||
pending: 'Ожидает решения',
|
||
approved: 'Одобрил',
|
||
rejected: 'Отклонил',
|
||
}
|
||
|
||
const ADDITIONAL_APPROVER_COLORS: Record<string, string> = {
|
||
pending: 'blue',
|
||
approved: 'green',
|
||
rejected: 'red',
|
||
}
|
||
|
||
// Статусы согласующего на запрос отзыва (см. HandleRevocationApproverDecision
|
||
// в telegram_service).
|
||
const REVOCATION_APPROVER_LABELS: Record<string, string> = {
|
||
pending: 'Ещё не ответил',
|
||
approved: 'Согласен на отзыв',
|
||
rejected: 'Против отзыва',
|
||
}
|
||
|
||
const REVOCATION_APPROVER_COLORS: Record<string, string> = {
|
||
pending: 'gray',
|
||
approved: 'green',
|
||
rejected: 'red',
|
||
}
|
||
|
||
const APPROVAL_MODE_LABELS: Record<string, string> = {
|
||
sequential: 'Последовательно',
|
||
any_of: 'Любой из согласующих',
|
||
}
|
||
|
||
// Статусы задач — те же значения и подписи, что в отчёте (reportcore.go)
|
||
// и в "Стадиях согласования" бота.
|
||
const TASK_STATUS_LABELS: Record<string, string> = {
|
||
pending: 'В работе',
|
||
waiting: 'Ожидает',
|
||
completed: 'Выполнена',
|
||
cancelled: 'Отменена',
|
||
cancellation: 'Требует отмены изменений',
|
||
}
|
||
|
||
const TASK_STATUS_COLORS: Record<string, string> = {
|
||
pending: 'blue',
|
||
waiting: 'gray',
|
||
completed: 'green',
|
||
cancelled: 'red',
|
||
cancellation: 'orange',
|
||
}
|
||
|
||
const PREVIEWABLE_TYPES = [
|
||
'image/jpeg',
|
||
'image/png',
|
||
'image/gif',
|
||
'image/webp',
|
||
'image/svg+xml',
|
||
'application/pdf',
|
||
'text/plain',
|
||
]
|
||
|
||
const getMimeType = (fileName: string): string => {
|
||
const ext = fileName.split('.').pop()?.toLowerCase() || ''
|
||
const mimeTypes: Record<string, string> = {
|
||
jpg: 'image/jpeg',
|
||
jpeg: 'image/jpeg',
|
||
png: 'image/png',
|
||
gif: 'image/gif',
|
||
webp: 'image/webp',
|
||
svg: 'image/svg+xml',
|
||
pdf: 'application/pdf',
|
||
txt: 'text/plain',
|
||
doc: 'application/msword',
|
||
docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
xls: 'application/vnd.ms-excel',
|
||
xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
}
|
||
return mimeTypes[ext] || 'application/octet-stream'
|
||
}
|
||
|
||
const generateSignature = async (): Promise<{ signature: string; timestamp: string; deviceId: string }> => {
|
||
const timestamp = Math.floor(Date.now() / 1000).toString()
|
||
const publicKey = import.meta.env.VITE_API_PUBLIC_KEY
|
||
const privateKey = import.meta.env.VITE_API_PRIVATE_KEY
|
||
const message = publicKey + ':' + timestamp
|
||
const CryptoJS = await import('crypto-js')
|
||
const signature = CryptoJS.HmacSHA256(message, privateKey).toString(CryptoJS.enc.Hex)
|
||
const deviceId = localStorage.getItem('device_id') || 'admin-panel'
|
||
return { signature, timestamp, deviceId }
|
||
}
|
||
|
||
const getAuthHeaders = async () => {
|
||
const token = localStorage.getItem('token')
|
||
const { signature, timestamp, deviceId } = await generateSignature()
|
||
return {
|
||
Authorization: `Bearer ${token}`,
|
||
ApiKey: signature,
|
||
'X-Timestamp': timestamp,
|
||
'x-device-id': deviceId,
|
||
}
|
||
}
|
||
|
||
export default function ApprovalDetailsModal({
|
||
approvalId,
|
||
opened,
|
||
onClose,
|
||
}: ApprovalDetailsModalProps) {
|
||
const { data: approval, isLoading } = useApproval(approvalId)
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
|
||
// Хуки отдают ApiResponse<T> целиком (как useFlowNodesTree раньше) —
|
||
// разворачиваем здесь, а не в самих хуках, чтобы не плодить два разных
|
||
// соглашения об обёртке в одном проекте.
|
||
const { data: additionalApproversResponse } = useAdditionalApprovers(approvalId)
|
||
const { data: commentsResponse } = useApprovalComments(approvalId)
|
||
const { data: observersResponse } = useApprovalObservers(approvalId)
|
||
const { data: revocationRequestResponse } = useRevocationRequest(approvalId)
|
||
const { data: tasksResponse } = useApprovalTasks(approvalId)
|
||
|
||
const additionalApprovers = additionalApproversResponse?.data
|
||
const comments = commentsResponse?.data
|
||
const observers = observersResponse?.data
|
||
const revocationRequest = revocationRequestResponse?.data
|
||
const tasksData = tasksResponse?.data
|
||
|
||
const [previewFileId, setPreviewFileId] = useState<number | null>(null)
|
||
const [previewFileName, setPreviewFileName] = useState('')
|
||
const [previewFileType, setPreviewFileType] = useState('')
|
||
|
||
const category = approval?.topic?.category_id && categories?.data
|
||
? categories.data.find((c) => c.id === approval.topic?.category_id)
|
||
: null
|
||
|
||
const handleFilePreview = (fileId: number, fileName: string) => {
|
||
setPreviewFileId(fileId)
|
||
setPreviewFileName(fileName)
|
||
setPreviewFileType(getMimeType(fileName))
|
||
}
|
||
|
||
const handleFileDownload = async (fileId: number, fileName: string) => {
|
||
try {
|
||
const headers = await getAuthHeaders()
|
||
const url = `/api/approvals/${approvalId}/files/${fileId}/download`
|
||
|
||
const response = await fetch(url, { method: 'GET', headers })
|
||
if (!response.ok) {
|
||
throw new Error('Failed to download file')
|
||
}
|
||
|
||
const blob = await response.blob()
|
||
const blobUrl = window.URL.createObjectURL(blob)
|
||
const link = document.createElement('a')
|
||
link.href = blobUrl
|
||
link.download = fileName
|
||
document.body.appendChild(link)
|
||
link.click()
|
||
link.remove()
|
||
window.URL.revokeObjectURL(blobUrl)
|
||
|
||
notifications.show({ title: 'Успешно', message: 'Файл скачан', color: 'green' })
|
||
} catch (error) {
|
||
console.error('Download error:', error)
|
||
notifications.show({ title: 'Ошибка', message: 'Не удалось скачать файл', color: 'red' })
|
||
}
|
||
}
|
||
|
||
// Показываем превью "что будет поставлено" только пока заявка ещё не
|
||
// согласована И задачи по факту ещё не созданы — как только появились
|
||
// реальные ApprovalTask, показываем уже их (ниже), а не план.
|
||
const showPlannedTasks =
|
||
approval?.status === 'pending' &&
|
||
!!tasksData?.topic_executors?.length &&
|
||
!tasksData?.tasks?.length
|
||
|
||
return (
|
||
<>
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>Заявка #{approvalId}</Text>
|
||
{approval && (
|
||
<Badge color={STATUS_COLORS[approval.status || ''] || 'gray'}>
|
||
{STATUS_LABELS[approval.status || ''] || approval.status}
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
size="xl"
|
||
styles={{ body: { height: 'calc(80vh - 120px)', padding: 0 } }}
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : approval ? (
|
||
<ScrollArea style={{ height: 'calc(80vh - 120px)' }} offsetScrollbars>
|
||
<Box p="md">
|
||
<Stack gap="md">
|
||
{/* НОВОЕ: ошибка создания задач — та же логика, что в отчёте
|
||
(reportcore.go: hasTaskError). Ставим у самого верха, это
|
||
требует внимания администратора, а не просто информация. */}
|
||
{tasksData?.has_task_error && (
|
||
<Alert icon={<IconAlertTriangle size={16} />} color="red" variant="filled">
|
||
<Text size="sm" fw={600}>
|
||
Ошибка при создании задачи
|
||
</Text>
|
||
<Text size="xs">
|
||
Для темы этой заявки настроены исполнители, заявка согласована, но ни
|
||
одной задачи по факту не создано — стоит проверить вручную.
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
{/* НОВОЕ: активный запрос на отзыв — самое "срочное", поэтому
|
||
сверху, ещё до общей информации. Показывается, только если
|
||
такой запрос реально есть (backend отдаёт data: null иначе) */}
|
||
{revocationRequest && (
|
||
<Alert icon={<IconRotate size={16} />} color="orange" variant="light">
|
||
<Stack gap={6}>
|
||
<Text size="sm" fw={600}>
|
||
Идёт запрос на отзыв этой заявки
|
||
</Text>
|
||
<Text size="xs">
|
||
Инициатор запроса: {revocationRequest.requested_by_name}
|
||
</Text>
|
||
{revocationRequest.reason && (
|
||
<Text size="xs">Причина: {revocationRequest.reason}</Text>
|
||
)}
|
||
<Stack gap={4} mt={4}>
|
||
{revocationRequest.approvers.map((a) => (
|
||
<Group key={a.approver_id} justify="space-between" gap="xs">
|
||
<Text size="xs">{a.approver_name}</Text>
|
||
<Badge
|
||
size="xs"
|
||
color={REVOCATION_APPROVER_COLORS[a.status] || 'gray'}
|
||
>
|
||
{REVOCATION_APPROVER_LABELS[a.status] || a.status}
|
||
</Badge>
|
||
</Group>
|
||
))}
|
||
</Stack>
|
||
</Stack>
|
||
</Alert>
|
||
)}
|
||
|
||
{/* Основная информация */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Основная информация</Text>
|
||
<Stack gap="sm">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Категория:</Text>
|
||
<Text fw={500}>{category?.name || '—'}</Text>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Тема:</Text>
|
||
<Text>{approval.topic?.name || '—'}</Text>
|
||
</Group>
|
||
{/* Режим согласования — лежит на теме */}
|
||
{approval.topic?.approval_mode && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Режим согласования:</Text>
|
||
<Text>
|
||
{APPROVAL_MODE_LABELS[approval.topic.approval_mode] ||
|
||
approval.topic.approval_mode}
|
||
</Text>
|
||
</Group>
|
||
)}
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Инициатор:</Text>
|
||
<Group gap="xs">
|
||
<IconUser size={16} />
|
||
<Text>{approval.initiator?.full_name || '—'}</Text>
|
||
</Group>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Отдел:</Text>
|
||
<Group gap="xs">
|
||
<IconBuilding size={16} />
|
||
<Text>{approval.department?.name || '—'}</Text>
|
||
</Group>
|
||
</Group>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Дата создания (МСК):</Text>
|
||
<Group gap="xs">
|
||
<IconCalendar size={16} />
|
||
<Text>{formatMsk(approval.created_at)}</Text>
|
||
</Group>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* НОВОЕ: превью "что будет поставлено" — только для pending-заявок,
|
||
пока реальных задач ещё нет. Данные берём из ApprovalTopicExecutor
|
||
(настройка темы), а не из ApprovalTask (их ещё физически не существует). */}
|
||
{showPlannedTasks && (
|
||
<Paper withBorder p="md" bg="blue.0">
|
||
<Group gap="xs" mb="xs">
|
||
<IconChecklist size={16} />
|
||
<Text size="sm" c="dimmed">
|
||
Какие задачи будут поставлены после согласования
|
||
</Text>
|
||
</Group>
|
||
<Stack gap="xs">
|
||
{tasksData!.topic_executors
|
||
.slice()
|
||
.sort((a, b) => a.step_order - b.step_order)
|
||
.map((te) => (
|
||
<Group key={te.id} justify="space-between" wrap="nowrap">
|
||
<Text size="sm" style={{ flex: 1 }}>
|
||
{te.task_text || '—'}
|
||
</Text>
|
||
<Badge variant="light" color="blue">
|
||
{te.executor_name || 'Исполнитель не назначен'}
|
||
</Badge>
|
||
</Group>
|
||
))}
|
||
</Stack>
|
||
<Text size="xs" c="dimmed" mt="xs">
|
||
Появится автоматически, как только заявку согласуют полностью.
|
||
</Text>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* НОВОЕ: уже реально выставленные задачи */}
|
||
{!!tasksData?.tasks?.length && (
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb="xs">
|
||
<IconChecklist size={16} />
|
||
<Text size="sm" c="dimmed">Задачи</Text>
|
||
</Group>
|
||
<Stack gap="xs">
|
||
{tasksData.tasks.map((task, i) => (
|
||
<Paper key={task.id} withBorder p="sm">
|
||
<Group justify="space-between" wrap="nowrap" mb={4}>
|
||
<Text size="sm" fw={500}>
|
||
Выставлена задача №{i + 1}
|
||
</Text>
|
||
<Badge size="xs" color={TASK_STATUS_COLORS[task.status] || 'gray'}>
|
||
{TASK_STATUS_LABELS[task.status] || task.status}
|
||
</Badge>
|
||
</Group>
|
||
<Text size="sm">{task.task_text || '—'}</Text>
|
||
<Text size="xs" c="dimmed" mt={4}>
|
||
Исполнитель: {task.executor_name || '—'}
|
||
{task.completed_at && <> · Выполнена {formatMsk(task.completed_at)}</>}
|
||
</Text>
|
||
</Paper>
|
||
))}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Наблюдатели — вычисляются динамически по категории/теме
|
||
(не хранимая связь), поэтому отдельным запросом */}
|
||
{observers && observers.length > 0 && (
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb="xs">
|
||
<IconEyeglass size={16} />
|
||
<Text size="sm" c="dimmed">Наблюдатели</Text>
|
||
</Group>
|
||
<Group gap="xs">
|
||
{observers.map((o) => (
|
||
<Badge key={o.id} variant="light" color="gray">
|
||
{o.full_name}
|
||
</Badge>
|
||
))}
|
||
</Group>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Текст заявки */}
|
||
{approval.content && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Текст заявки</Text>
|
||
<Text>{approval.content}</Text>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Метаданные */}
|
||
{approval.metadata && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Метаданные</Text>
|
||
<Text size="sm" style={{ fontFamily: 'monospace', whiteSpace: 'pre-wrap' }}>
|
||
{(() => {
|
||
try {
|
||
return JSON.stringify(JSON.parse(approval.metadata), null, 2)
|
||
} catch {
|
||
return approval.metadata
|
||
}
|
||
})()}
|
||
</Text>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Файлы */}
|
||
{approval.files && approval.files.length > 0 && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Прикреплённые файлы</Text>
|
||
<Stack gap="xs">
|
||
{approval.files.map((file) => {
|
||
const mimeType = getMimeType(file.file_name || '')
|
||
const canPreview = PREVIEWABLE_TYPES.includes(mimeType)
|
||
const fileSizeKB = file.file_base64
|
||
? Math.round((file.file_base64.length * 3) / 4 / 1024)
|
||
: 0
|
||
|
||
return (
|
||
<Paper key={file.id} withBorder p="sm">
|
||
<Group justify="space-between">
|
||
<Group gap="sm">
|
||
<IconFileText size={20} color="blue" />
|
||
<Stack gap={0}>
|
||
<Text size="sm" fw={500}>
|
||
{file.file_name || 'Без имени'}
|
||
</Text>
|
||
{fileSizeKB > 0 && (
|
||
<Text size="xs" c="dimmed">
|
||
{fileSizeKB} KB
|
||
</Text>
|
||
)}
|
||
</Stack>
|
||
</Group>
|
||
<Group gap="xs">
|
||
{canPreview && (
|
||
<Tooltip label="Предпросмотр">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => handleFilePreview(file.id!, file.file_name || '')}
|
||
>
|
||
<IconEye size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
)}
|
||
<Tooltip label="Скачать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="green"
|
||
onClick={() => handleFileDownload(file.id!, file.file_name || '')}
|
||
>
|
||
<IconDownload size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Group>
|
||
</Paper>
|
||
)
|
||
})}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Шаги согласования */}
|
||
{approval.steps && approval.steps.length > 0 && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" c="dimmed" mb="xs">Шаги согласования</Text>
|
||
<Timeline active={-1} bulletSize={24} lineWidth={2}>
|
||
{approval.steps
|
||
.sort((a, b) => (a.step_order || 0) - (b.step_order || 0))
|
||
.map((step, index) => {
|
||
const StatusIcon = STEP_STATUS_ICONS[step.status || ''] || IconClock
|
||
return (
|
||
<Timeline.Item
|
||
key={step.id}
|
||
bullet={<StatusIcon size={14} />}
|
||
title={
|
||
<Group gap="xs">
|
||
<Text size="sm" fw={500}>
|
||
Шаг {index + 1}: {step.approver_name_snapshot || 'Согласующий'}
|
||
</Text>
|
||
<Badge size="xs" color={STEP_STATUS_COLORS[step.status || ''] || 'gray'}>
|
||
{step.status}
|
||
</Badge>
|
||
</Group>
|
||
}
|
||
>
|
||
<Text size="xs" c="dimmed">
|
||
{step.approver?.full_name || '—'}
|
||
{step.acted_at && (
|
||
<>
|
||
{' • '}
|
||
{formatMsk(step.acted_at)}
|
||
</>
|
||
)}
|
||
</Text>
|
||
{step.comment && (
|
||
<Text size="xs" mt={4}>
|
||
Комментарий: {step.comment}
|
||
</Text>
|
||
)}
|
||
</Timeline.Item>
|
||
)
|
||
})}
|
||
</Timeline>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Дополнительные согласующие */}
|
||
{additionalApprovers && additionalApprovers.length > 0 && (
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb="xs">
|
||
<IconUserPlus size={16} />
|
||
<Text size="sm" c="dimmed">Дополнительные согласующие</Text>
|
||
</Group>
|
||
<Stack gap="xs">
|
||
{additionalApprovers.map((aa) => (
|
||
<Group key={aa.id} justify="space-between">
|
||
<Text size="sm">{aa.approver_name}</Text>
|
||
<Group gap="xs">
|
||
{aa.acted_at && (
|
||
<Text size="xs" c="dimmed">{formatMsk(aa.acted_at)}</Text>
|
||
)}
|
||
<Badge size="xs" color={ADDITIONAL_APPROVER_COLORS[aa.status] || 'blue'}>
|
||
{ADDITIONAL_APPROVER_LABELS[aa.status] || aa.status}
|
||
</Badge>
|
||
</Group>
|
||
</Group>
|
||
))}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Комментарии */}
|
||
{comments && comments.length > 0 && (
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb="xs">
|
||
<IconMessageCircle size={16} />
|
||
<Text size="sm" c="dimmed">Комментарии ({comments.length})</Text>
|
||
</Group>
|
||
<Stack gap="sm">
|
||
{comments.map((c, i) => (
|
||
<Box key={c.id}>
|
||
<Group justify="space-between" gap="xs">
|
||
<Text size="xs" fw={600}>{c.user_name}</Text>
|
||
{c.created_at && (
|
||
<Text size="xs" c="dimmed">{formatMsk(c.created_at)}</Text>
|
||
)}
|
||
</Group>
|
||
<Text size="sm">{c.comment}</Text>
|
||
{i < comments.length - 1 && <Divider mt="sm" />}
|
||
</Box>
|
||
))}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Информация об отзыве */}
|
||
{approval.status === 'revoked' && approval.revoked_by && (
|
||
<Paper withBorder p="md" bg="orange.0">
|
||
<Text size="sm" c="dimmed" mb="xs">Информация об отзыве</Text>
|
||
<Group gap="sm">
|
||
<IconAlertCircle size={16} />
|
||
<Text size="sm">
|
||
Отозвана: {approval.revoked_by.full_name}
|
||
{approval.revoked_at && <> {formatMsk(approval.revoked_at)}</>}
|
||
</Text>
|
||
</Group>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Информация о доработке */}
|
||
{approval.status === 'revision' && (
|
||
<Paper withBorder p="md" bg="violet.0">
|
||
<Text size="sm" c="dimmed" mb="xs">Информация о доработке</Text>
|
||
<Stack gap="xs">
|
||
{approval.revision_comment && (
|
||
<Text size="sm">
|
||
<Text fw={500} component="span">Комментарий:</Text> {approval.revision_comment}
|
||
</Text>
|
||
)}
|
||
{approval.revision_count !== undefined && approval.revision_count > 0 && (
|
||
<Text size="sm">
|
||
<Text fw={500} component="span">Количество доработок:</Text> {approval.revision_count}
|
||
</Text>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
</Stack>
|
||
</Box>
|
||
</ScrollArea>
|
||
) : (
|
||
<Center p={40}>
|
||
<Text c="dimmed">Заявка не найдена</Text>
|
||
</Center>
|
||
)}
|
||
</Modal>
|
||
|
||
{previewFileId && approvalId && (
|
||
<FilePreviewModal
|
||
approvalId={approvalId}
|
||
fileId={previewFileId}
|
||
fileName={previewFileName}
|
||
fileType={previewFileType}
|
||
opened={!!previewFileId}
|
||
onClose={() => setPreviewFileId(null)}
|
||
/>
|
||
)}
|
||
</>
|
||
)
|
||
}
|
||
-----END src/pages/approvals/components/ApprovalDetailsModal.tsx-----
|
||
|
||
File: src/pages/approvals/components/FilePreviewModal.tsx
|
||
Lines: 266
|
||
-----BEGIN src/pages/approvals/components/FilePreviewModal.tsx-----
|
||
import { useState, useEffect } from 'react'
|
||
import { Modal, Group, Text, Loader, Center, Paper, ActionIcon, Stack, Box } from '@mantine/core'
|
||
import { IconDownload } from '@tabler/icons-react'
|
||
import { notifications } from '@mantine/notifications'
|
||
|
||
interface FilePreviewModalProps {
|
||
approvalId?: number // Теперь опционально
|
||
fileId: number
|
||
fileName: string
|
||
fileType: string
|
||
opened: boolean
|
||
onClose: () => void
|
||
taskId?: number // 🆕 Для файлов задач
|
||
}
|
||
|
||
// 🆕 Тип сущности
|
||
type EntityType = 'approval' | 'task'
|
||
|
||
const getAuthHeaders = async () => {
|
||
const token = localStorage.getItem('token')
|
||
const timestamp = Math.floor(Date.now() / 1000).toString()
|
||
const publicKey = import.meta.env.VITE_API_PUBLIC_KEY
|
||
const privateKey = import.meta.env.VITE_API_PRIVATE_KEY
|
||
const message = publicKey + ':' + timestamp
|
||
const CryptoJS = await import('crypto-js')
|
||
const signature = CryptoJS.HmacSHA256(message, privateKey).toString(CryptoJS.enc.Hex)
|
||
const deviceId = localStorage.getItem('device_id') || 'admin-panel'
|
||
|
||
return {
|
||
'Authorization': `Bearer ${token}`,
|
||
'ApiKey': signature,
|
||
'X-Timestamp': timestamp,
|
||
'x-device-id': deviceId,
|
||
}
|
||
}
|
||
|
||
export default function FilePreviewModal({
|
||
approvalId,
|
||
fileId,
|
||
fileName,
|
||
fileType,
|
||
opened,
|
||
onClose,
|
||
taskId, // 🆕
|
||
}: FilePreviewModalProps) {
|
||
const [loading, setLoading] = useState(true)
|
||
const [error, setError] = useState<string | null>(null)
|
||
const [fileUrl, setFileUrl] = useState<string | null>(null)
|
||
|
||
// 🆕 Определяем тип сущности
|
||
const entityType: EntityType = taskId ? 'task' : 'approval'
|
||
const entityId = taskId || approvalId
|
||
|
||
// 🆕 Формируем URL в зависимости от типа сущности
|
||
const getPreviewUrl = () => {
|
||
if (entityType === 'task') {
|
||
return `/api/approval-tasks/${taskId}/files/${fileId}`
|
||
}
|
||
return `/api/approvals/${approvalId}/files/${fileId}`
|
||
}
|
||
|
||
const getDownloadUrl = () => {
|
||
if (entityType === 'task') {
|
||
return `/api/approval-tasks/${taskId}/files/${fileId}/download`
|
||
}
|
||
return `/api/approvals/${approvalId}/files/${fileId}/download`
|
||
}
|
||
|
||
const canPreview = [
|
||
'image/jpeg',
|
||
'image/png',
|
||
'image/gif',
|
||
'image/webp',
|
||
'image/svg+xml',
|
||
'application/pdf',
|
||
'text/plain',
|
||
].includes(fileType)
|
||
|
||
useEffect(() => {
|
||
if (!opened || !canPreview || !entityId) return
|
||
|
||
let objectUrl: string | null = null
|
||
|
||
const loadFile = async () => {
|
||
setLoading(true)
|
||
setError(null)
|
||
|
||
try {
|
||
const headers = await getAuthHeaders()
|
||
const url = getPreviewUrl()
|
||
|
||
const response = await fetch(url, {
|
||
method: 'GET',
|
||
headers,
|
||
})
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP ${response.status}`)
|
||
}
|
||
|
||
const blob = await response.blob()
|
||
objectUrl = window.URL.createObjectURL(blob)
|
||
setFileUrl(objectUrl)
|
||
} catch (err) {
|
||
console.error('File load error:', err)
|
||
setError('Не удалось загрузить файл')
|
||
} finally {
|
||
setLoading(false)
|
||
}
|
||
}
|
||
|
||
loadFile()
|
||
|
||
return () => {
|
||
if (objectUrl) {
|
||
window.URL.revokeObjectURL(objectUrl)
|
||
}
|
||
}
|
||
}, [opened, entityId, fileId, canPreview])
|
||
|
||
const handleDownload = async () => {
|
||
try {
|
||
const headers = await getAuthHeaders()
|
||
const url = getDownloadUrl()
|
||
|
||
const response = await fetch(url, {
|
||
method: 'GET',
|
||
headers,
|
||
})
|
||
|
||
if (!response.ok) {
|
||
throw new Error('Failed to download file')
|
||
}
|
||
|
||
const blob = await response.blob()
|
||
const blobUrl = window.URL.createObjectURL(blob)
|
||
const link = document.createElement('a')
|
||
link.href = blobUrl
|
||
link.download = fileName
|
||
document.body.appendChild(link)
|
||
link.click()
|
||
link.remove()
|
||
window.URL.revokeObjectURL(blobUrl)
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: 'Файл скачан',
|
||
color: 'green',
|
||
})
|
||
} catch (err) {
|
||
console.error('Download error:', err)
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Не удалось скачать файл',
|
||
color: 'red',
|
||
})
|
||
}
|
||
}
|
||
|
||
if (!canPreview) {
|
||
return (
|
||
<Modal opened={opened} onClose={onClose} title="Предпросмотр недоступен" size="md">
|
||
<Paper p="md" withBorder>
|
||
<Stack gap="md">
|
||
<Text>
|
||
Предпросмотр этого типа файла не поддерживается.
|
||
<br />
|
||
Вы можете скачать файл.
|
||
</Text>
|
||
<Group justify="flex-end">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
size="lg"
|
||
onClick={handleDownload}
|
||
>
|
||
<IconDownload size={20} />
|
||
</ActionIcon>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
</Modal>
|
||
)
|
||
}
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group justify="space-between" style={{ flex: 1 }}>
|
||
<Text fw={600} lineClamp={1}>{fileName}</Text>
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={handleDownload}
|
||
>
|
||
<IconDownload size={20} />
|
||
</ActionIcon>
|
||
</Group>
|
||
}
|
||
size="xl"
|
||
styles={{
|
||
body: {
|
||
height: 'calc(80vh - 120px)',
|
||
padding: 0,
|
||
},
|
||
}}
|
||
>
|
||
<Box style={{ height: '100%', width: '100%', position: 'relative' }}>
|
||
{loading && (
|
||
<Center style={{ position: 'absolute', inset: 0, zIndex: 1 }}>
|
||
<Stack align="center" gap="xs">
|
||
<Loader size="lg" />
|
||
<Text size="sm" c="dimmed">Загрузка файла...</Text>
|
||
</Stack>
|
||
</Center>
|
||
)}
|
||
|
||
{error && (
|
||
<Center h="100%">
|
||
<Text c="red">{error}</Text>
|
||
</Center>
|
||
)}
|
||
|
||
{fileUrl && !error && (
|
||
<>
|
||
{fileType.startsWith('image/') ? (
|
||
<Center style={{ height: '100%', background: '#f5f5f5' }}>
|
||
<img
|
||
src={fileUrl}
|
||
alt={fileName}
|
||
style={{
|
||
maxWidth: '100%',
|
||
maxHeight: '100%',
|
||
objectFit: 'contain',
|
||
}}
|
||
/>
|
||
</Center>
|
||
) : fileType === 'application/pdf' ? (
|
||
<iframe
|
||
src={fileUrl}
|
||
style={{
|
||
width: '100%',
|
||
height: '100%',
|
||
border: 'none',
|
||
}}
|
||
title={fileName}
|
||
/>
|
||
) : fileType === 'text/plain' ? (
|
||
<iframe
|
||
src={fileUrl}
|
||
style={{
|
||
width: '100%',
|
||
height: '100%',
|
||
border: 'none',
|
||
background: 'white',
|
||
}}
|
||
title={fileName}
|
||
/>
|
||
) : null}
|
||
</>
|
||
)}
|
||
</Box>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/approvals/components/FilePreviewModal.tsx-----
|
||
|
||
File: src/pages/categories/CategoriesPage.tsx
|
||
Lines: 230
|
||
-----BEGIN src/pages/categories/CategoriesPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
TextInput,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import { IconPencil, IconTrash, IconPlus, IconSearch } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useCategories, useDeleteCategory } from '@/features/categories/hooks/useCategories'
|
||
import CategoryEditModal from './components/CategoryEditModal'
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function CategoriesPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [search, setSearch] = useState('')
|
||
const [activeFilter, setActiveFilter] = useState<boolean | null>(null)
|
||
const [editCategoryId, setEditCategoryId] = useState<number | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
|
||
const { data, isLoading, isFetching } = useCategories({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(search && { name: search }),
|
||
...(activeFilter !== null && { is_active: activeFilter }),
|
||
})
|
||
|
||
const deleteCategory = useDeleteCategory()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить эту категорию? Все темы этой категории останутся без категории.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteCategory.mutate(id),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Категории тем</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => setCreateModalOpened(true)}
|
||
>
|
||
Создать категорию
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<TextInput
|
||
label="Поиск по названию"
|
||
placeholder="Отпуска, больничные..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
|
||
<Switch
|
||
label="Только активные"
|
||
checked={activeFilter === true}
|
||
onChange={(e) => {
|
||
setActiveFilter(e.currentTarget.checked ? true : null)
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Название</Table.Th>
|
||
<Table.Th>Код</Table.Th>
|
||
<Table.Th>Описание</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={6}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Категории не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((category) => (
|
||
<Table.Tr key={category.id}>
|
||
<Table.Td>{category.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text fw={500}>{category.name}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace" c="dimmed">
|
||
{category.code}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={2}>
|
||
{category.description || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={category.is_active ? 'green' : 'gray'}
|
||
variant={category.is_active ? 'light' : 'filled'}
|
||
>
|
||
{category.is_active ? 'Активна' : 'Неактивна'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditCategoryId(category.id!)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(category.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{/* Пагинация */}
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* Индикатор обновления */}
|
||
{isFetching && !isLoading && (
|
||
<Box
|
||
style={{
|
||
position: 'fixed',
|
||
top: 70,
|
||
right: 20,
|
||
zIndex: 1000
|
||
}}
|
||
>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
{/* Модальное окно редактирования */}
|
||
<CategoryEditModal
|
||
categoryId={editCategoryId}
|
||
opened={editCategoryId !== null}
|
||
onClose={() => setEditCategoryId(null)}
|
||
/>
|
||
|
||
{/* Модальное окно создания */}
|
||
<CategoryEditModal
|
||
categoryId={null}
|
||
opened={createModalOpened}
|
||
onClose={() => setCreateModalOpened(false)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/categories/CategoriesPage.tsx-----
|
||
|
||
File: src/pages/categories/components/CategoryEditModal.tsx
|
||
Lines: 151
|
||
-----BEGIN src/pages/categories/components/CategoryEditModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Textarea,
|
||
Switch,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
useCategory,
|
||
useCreateCategory,
|
||
useUpdateCategory
|
||
} from '@/features/categories/hooks/useCategories'
|
||
|
||
interface CategoryEditModalProps {
|
||
categoryId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function CategoryEditModal({
|
||
categoryId,
|
||
opened,
|
||
onClose
|
||
}: CategoryEditModalProps) {
|
||
const { data: category, isLoading: categoryLoading } = useCategory(categoryId)
|
||
|
||
const createCategory = useCreateCategory()
|
||
const updateCategory = useUpdateCategory()
|
||
|
||
const isEditMode = categoryId !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
name: '',
|
||
code: '',
|
||
description: '',
|
||
is_active: true,
|
||
},
|
||
validate: {
|
||
name: (value: string | any[]) => (value.length < 2 ? 'Название должно содержать минимум 2 символа' : null),
|
||
code: (value: string | any[]) => {
|
||
if (value.length < 2) return 'Код должен содержать минимум 2 символа'
|
||
if (!/^[a-z0-9_]+$/.test(value as string)) return 'Код должен содержать только lowercase буквы, цифры и подчеркивания'
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
// Заполняем форму данными категории
|
||
useEffect(() => {
|
||
if (category) {
|
||
form.setValues({
|
||
name: category.name || '',
|
||
code: category.code || '',
|
||
description: category.description || '',
|
||
is_active: category.is_active ?? true,
|
||
})
|
||
} else if (!isEditMode) {
|
||
form.reset()
|
||
}
|
||
}, [category, isEditMode])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (isEditMode && categoryId) {
|
||
// Режим редактирования
|
||
await updateCategory.mutateAsync({
|
||
id: categoryId,
|
||
...values,
|
||
})
|
||
} else {
|
||
// Режим создания
|
||
await createCategory.mutateAsync(values)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isLoading = categoryLoading
|
||
const isSubmitting = createCategory.isPending || updateCategory.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование категории' : 'Создание категории'}
|
||
</Text>
|
||
{category && <Badge variant="light">ID: {category.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="md"
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<TextInput
|
||
label="Название"
|
||
placeholder="Отпуска и отгулы"
|
||
required
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Код"
|
||
placeholder="vacation"
|
||
required
|
||
description="Уникальный идентификатор категории (lowercase, цифры, подчеркивания)"
|
||
disabled={isEditMode}
|
||
{...form.getInputProps('code')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Описание"
|
||
placeholder="Описание категории..."
|
||
minRows={3}
|
||
{...form.getInputProps('description')}
|
||
/>
|
||
|
||
<Switch
|
||
label="Активна"
|
||
description="Неактивные категории не будут доступны для выбора при создании тем"
|
||
checked={form.values.is_active}
|
||
onChange={(e) => form.setFieldValue('is_active', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/categories/components/CategoryEditModal.tsx-----
|
||
|
||
File: src/pages/flowNodes/FlowTreeGuidePage.tsx
|
||
Lines: 766
|
||
-----BEGIN src/pages/flowNodes/FlowTreeGuidePage.tsx-----
|
||
import { useState, useEffect } from 'react'
|
||
import {
|
||
Stack,
|
||
Text,
|
||
Code,
|
||
Paper,
|
||
Group,
|
||
Box,
|
||
Title,
|
||
Table,
|
||
Divider,
|
||
ActionIcon,
|
||
Tooltip,
|
||
CopyButton,
|
||
ScrollArea,
|
||
Badge,
|
||
Alert,
|
||
UnstyledButton,
|
||
Timeline,
|
||
ThemeIcon,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconArrowLeft,
|
||
IconCopy,
|
||
IconCheck,
|
||
IconBulb,
|
||
IconAlertTriangle,
|
||
} from '@tabler/icons-react'
|
||
import { useNavigate } from 'react-router-dom'
|
||
|
||
// ================================================================
|
||
// Структура документации
|
||
// ================================================================
|
||
|
||
interface DocSection {
|
||
id: string
|
||
title: string
|
||
level: number
|
||
}
|
||
|
||
const SECTIONS: DocSection[] = [
|
||
{ id: 'overview', title: 'Что это такое', level: 1 },
|
||
{ id: 'terms', title: 'Три простых понятия', level: 1 },
|
||
{ id: 'howto', title: 'Как создать дерево — по шагам', level: 1 },
|
||
{ id: 'step-1', title: ' 1. Выбрать категорию', level: 2 },
|
||
{ id: 'step-2', title: ' 2. Создать первый узел', level: 2 },
|
||
{ id: 'step-3', title: ' 3. Добавить варианты (ветки)', level: 2 },
|
||
{ id: 'step-4', title: ' 4. Завершить ветку вводом текста', level: 2 },
|
||
{ id: 'step-5', title: ' 5. Настроить сообщение согласующему', level: 2 },
|
||
{ id: 'step-6', title: ' 6. Проверить результат', level: 2 },
|
||
{ id: 'node-types', title: 'Три типа узлов', level: 1 },
|
||
{ id: 'example-1', title: 'Пример: «Отпуска»', level: 1 },
|
||
{ id: 'example-2', title: 'Пример: выбор из нескольких списков', level: 1 },
|
||
{ id: 'template-basics', title: 'Как писать сообщение согласующему', level: 1 },
|
||
{ id: 'tips', title: 'Советы и правила', level: 1 },
|
||
{ id: 'troubleshooting', title: 'Если что-то не работает', level: 1 },
|
||
]
|
||
|
||
export default function FlowTreeGuidePage() {
|
||
const navigate = useNavigate()
|
||
const [activeSection, setActiveSection] = useState('overview')
|
||
|
||
useEffect(() => {
|
||
const handleScroll = () => {
|
||
const scrollPosition = window.scrollY + 100
|
||
for (const section of [...SECTIONS].reverse()) {
|
||
const element = document.getElementById(section.id)
|
||
if (element && element.offsetTop <= scrollPosition) {
|
||
setActiveSection(section.id)
|
||
break
|
||
}
|
||
}
|
||
}
|
||
window.addEventListener('scroll', handleScroll)
|
||
return () => window.removeEventListener('scroll', handleScroll)
|
||
}, [])
|
||
|
||
const scrollTo = (id: string) => {
|
||
document.getElementById(id)?.scrollIntoView({ behavior: 'smooth', block: 'start' })
|
||
setActiveSection(id)
|
||
}
|
||
|
||
return (
|
||
<Box style={{ display: 'flex', gap: 32, alignItems: 'flex-start' }}>
|
||
<Box
|
||
style={{
|
||
width: 260,
|
||
flexShrink: 0,
|
||
position: 'sticky',
|
||
top: 20,
|
||
maxHeight: 'calc(100vh - 40px)',
|
||
}}
|
||
>
|
||
<Stack gap={0}>
|
||
<Group justify="space-between" mb="md">
|
||
<Text size="xs" fw={600} c="dimmed" tt="uppercase" lts={1}>
|
||
Руководство
|
||
</Text>
|
||
<ActionIcon
|
||
variant="subtle"
|
||
size="sm"
|
||
onClick={() => navigate('/nodes')}
|
||
>
|
||
<IconArrowLeft size={16} />
|
||
</ActionIcon>
|
||
</Group>
|
||
|
||
<ScrollArea style={{ maxHeight: 'calc(100vh - 120px)' }}>
|
||
<Stack gap={2}>
|
||
{SECTIONS.map((section) => (
|
||
<UnstyledButton
|
||
key={section.id}
|
||
onClick={() => scrollTo(section.id)}
|
||
px={section.level === 2 ? 20 : 12}
|
||
py={6}
|
||
style={{
|
||
borderRadius: 4,
|
||
backgroundColor:
|
||
activeSection === section.id
|
||
? 'var(--mantine-color-blue-0)'
|
||
: 'transparent',
|
||
borderLeft:
|
||
activeSection === section.id
|
||
? '2px solid var(--mantine-color-blue-6)'
|
||
: '2px solid transparent',
|
||
}}
|
||
>
|
||
<Text
|
||
size={section.level === 2 ? 'xs' : 'sm'}
|
||
c={activeSection === section.id ? 'blue.7' : 'dimmed'}
|
||
fw={activeSection === section.id ? 600 : 400}
|
||
>
|
||
{section.title}
|
||
</Text>
|
||
</UnstyledButton>
|
||
))}
|
||
</Stack>
|
||
</ScrollArea>
|
||
</Stack>
|
||
</Box>
|
||
|
||
{/* ============================================================ */}
|
||
{/* Основной контент */}
|
||
{/* ============================================================ */}
|
||
<Box style={{ flex: 1, maxWidth: 880, minWidth: 0 }}>
|
||
<Stack gap={48} pb={120}>
|
||
{/* Заголовок */}
|
||
<Box>
|
||
<Title order={1}>Как настроить дерево согласования</Title>
|
||
<Text c="dimmed" mt="sm" size="lg">
|
||
Это руководство для тех, кто настраивает бота — без программирования.
|
||
Здесь пошагово показано, как собрать «дерево» вопросов, которые бот задаёт
|
||
сотруднику, когда тот создаёт заявку: например, «Какой регион?» →
|
||
«Какая причина?» → «Опишите заявку».
|
||
</Text>
|
||
</Box>
|
||
|
||
<Divider />
|
||
|
||
{/* ============================================================ */}
|
||
{/* ОБЗОР */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="overview" title="Что это такое" />
|
||
|
||
<Text>
|
||
Когда сотрудник создаёт заявку в Telegram-боте, бот задаёт ему вопросы по
|
||
очереди и предлагает варианты ответов кнопками. Например: «Выберите
|
||
регион» → «Крым» или «Краснодар» → «Опишите заявку текстом». Эта
|
||
последовательность вопросов и есть <b>дерево</b>.
|
||
</Text>
|
||
|
||
<Text>
|
||
Вы настраиваете это дерево в разделе «Конструктор деревьев» — без единой
|
||
строчки кода. Каждый вопрос и каждая кнопка — это отдельный «узел», который
|
||
вы добавляете через простую форму.
|
||
</Text>
|
||
|
||
<Callout title="Зачем это нужно">
|
||
Так настраиваются любые сценарии: отпуска, больничные, внебюджетные
|
||
расходы, возвраты и любые другие заявки. Если появится новый вид заявки —
|
||
не нужно ничего программировать, достаточно собрать новое дерево здесь.
|
||
</Callout>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ТРИ ПОНЯТИЯ */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="terms" title="Три простых понятия" />
|
||
|
||
<Text>
|
||
Прежде чем начать, важно понимать всего три вещи:
|
||
</Text>
|
||
|
||
<Table withTableBorder withColumnBorders mt="md">
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 180 }}>Понятие</Table.Th>
|
||
<Table.Th>Что это простыми словами</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
<Table.Tr>
|
||
<Table.Td><b>Категория</b></Table.Td>
|
||
<Table.Td>
|
||
Раздел заявок, который вы выбираете вверху страницы («Отпуска»,
|
||
«Внебюджетные расходы» и т.д.). Одно дерево всегда строится
|
||
внутри одной категории.
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td><b>Узел</b></Table.Td>
|
||
<Table.Td>
|
||
Один шаг в дереве: кнопка с вариантом ответа, поле ввода текста
|
||
или список для множественного выбора. Узлы соединяются друг с
|
||
другом — у каждого может быть несколько «детей» (следующих
|
||
шагов).
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td><b>Тема заявки</b></Table.Td>
|
||
<Table.Td>
|
||
То, во что в итоге превращается пройденный сотрудником путь по
|
||
дереву. Например, путь «Крым → За свой счёт» превращается в
|
||
конкретную тему заявки со своими согласующими.
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
<Callout title="Главное правило">
|
||
Дерево — это как схема метро: от начальной станции (первого вопроса) до
|
||
конечной (поля ввода текста) должен существовать путь через любые
|
||
промежуточные станции (кнопки-варианты). Ваша задача — построить эти пути.
|
||
</Callout>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ПОРЯДОК СОЗДАНИЯ */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="howto" title="Как создать дерево — по шагам" />
|
||
|
||
<Text>
|
||
Ниже — точный порядок действий от пустой категории до готового,
|
||
работающего дерева.
|
||
</Text>
|
||
|
||
<DocSection id="step-1" title="Шаг 1. Выбрать категорию" level={2} />
|
||
|
||
<Text>
|
||
Откройте страницу «Конструктор деревьев» и в выпадающем списке «Категория»
|
||
выберите нужный раздел. Если подходящей категории ещё нет — обратитесь к
|
||
администратору, чтобы её создали (это отдельная настройка, не относится к
|
||
дереву).
|
||
</Text>
|
||
|
||
<Callout title="Совет">
|
||
Если дерево для этой категории уже существует, вы увидите его сразу после
|
||
выбора. Можно смело редактировать — все изменения сохраняются
|
||
автоматически, ничего не потеряется.
|
||
</Callout>
|
||
|
||
<DocSection id="step-2" title="Шаг 2. Создать первый узел" level={2} />
|
||
|
||
<Text>
|
||
Нажмите кнопку «Добавить корневой узел». Это будет самый первый вопрос,
|
||
который увидит сотрудник. Откроется окно с тремя полями:
|
||
</Text>
|
||
|
||
<Table withTableBorder withColumnBorders mt="xs">
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 180 }}>Поле</Table.Th>
|
||
<Table.Th>Что писать</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
<Table.Tr>
|
||
<Table.Td>Тип узла</Table.Td>
|
||
<Table.Td>Оставьте «Кнопка» — для первого шага почти всегда нужна кнопка</Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td>Название</Table.Td>
|
||
<Table.Td>То, что увидит сотрудник, например «Отпуска»</Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td>Ключ</Table.Td>
|
||
<Table.Td>
|
||
Не трогайте — заполняется автоматически из названия
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
<Text mt="sm">
|
||
Нажмите «Создать». Узел появится в дереве — с него всё и начинается.
|
||
</Text>
|
||
|
||
<DocSection id="step-3" title="Шаг 3. Добавить варианты (ветки)" level={2} />
|
||
|
||
<Text>
|
||
Наведите на созданный узел — рядом появятся кнопки. Нажмите «+», чтобы
|
||
добавить к нему дочерний узел — следующий шаг вопроса. Повторяйте это для
|
||
каждого варианта ответа.
|
||
</Text>
|
||
|
||
<Text>
|
||
Например, если первый узел — «Тип отпуска», добавьте к нему детей:
|
||
«Отпуск», «Отгул», «Больничный». Каждый из них — отдельная кнопка, которую
|
||
увидит сотрудник после выбора первого шага.
|
||
</Text>
|
||
|
||
<Callout title="Важно про DataKey и DataValue" mt="md">
|
||
Для узлов-кнопок в форме есть два поля: <b>DataKey</b> — название того, что
|
||
мы запоминаем (например «тип отпуска»), и <b>DataValue</b> — конкретное
|
||
значение этой кнопки (например «отпуск»). У всех кнопок-веток одного и того
|
||
же вопроса DataKey должен быть одинаковым, а DataValue — у каждой свой.
|
||
Смотрите готовый пример ниже — там всё видно на конкретных значениях.
|
||
</Callout>
|
||
|
||
<DocSection id="step-4" title="Шаг 4. Завершить ветку вводом текста" level={2} />
|
||
|
||
<Text>
|
||
Каждая ветка дерева обязательно должна заканчиваться узлом «Текстовый
|
||
ввод» — это последний шаг, где сотрудник пишет саму заявку своими словами.
|
||
Добавьте такой узел к каждому «листу» дерева (к узлу, у которого больше нет
|
||
вариантов выбора).
|
||
</Text>
|
||
|
||
<Text>
|
||
В форме выберите тип узла «Текстовый ввод» и заполните поле «Подсказка» —
|
||
это пример того, что должен написать сотрудник, чтобы ему было понятнее.
|
||
</Text>
|
||
|
||
<Callout title="Как проверить, что дерево готово">
|
||
Пройдите мысленно (или на бумаге) каждый путь от первого узла до конца.
|
||
Если какой-то путь обрывается на кнопке, не доходя до текстового ввода —
|
||
сотрудник не сможет завершить заявку. Добавьте туда узел ввода.
|
||
</Callout>
|
||
|
||
<DocSection id="step-5" title="Шаг 5. Настроить сообщение согласующему" level={2} />
|
||
|
||
<Text>
|
||
На узле, где заявка «превращается» в конкретную тему (обычно это последний
|
||
узел-кнопка перед вводом текста), можно раскрыть блок «Шаблоны сообщения и
|
||
кода темы» и задать, как будет выглядеть уведомление у согласующего в
|
||
Telegram. Подробно про это — в разделе{' '}
|
||
<Text component="span" fw={600}>«Как писать сообщение согласующему»</Text>{' '}
|
||
ниже. Если ничего не менять — сработает оформление по умолчанию.
|
||
</Text>
|
||
|
||
<DocSection id="step-6" title="Шаг 6. Проверить результат" level={2} />
|
||
|
||
<Text>
|
||
Дерево сохраняется автоматически после каждого действия — отдельной кнопки
|
||
«Сохранить всё» нажимать не нужно. Лучший способ проверить готовое дерево —
|
||
попросить коллегу создать тестовую заявку через бота и убедиться, что все
|
||
вопросы задаются в правильном порядке, а итоговое сообщение согласующему
|
||
выглядит понятно.
|
||
</Text>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ТИПЫ УЗЛОВ */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="node-types" title="Три типа узлов" />
|
||
|
||
<Text>
|
||
При создании или редактировании узла вы выбираете один из трёх типов:
|
||
</Text>
|
||
|
||
<Stack gap="sm" mt="md">
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb={4}>
|
||
<Text size="lg">🔘</Text>
|
||
<Text fw={600}>Кнопка</Text>
|
||
</Group>
|
||
<Text size="sm" c="dimmed">
|
||
Сотрудник нажимает и переходит к следующему шагу. Используется для
|
||
любого выбора из вариантов: регион, тип заявки, филиал и т.д.
|
||
Требует заполнения DataKey и DataValue.
|
||
</Text>
|
||
</Paper>
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb={4}>
|
||
<Text size="lg">📝</Text>
|
||
<Text fw={600}>Текстовый ввод</Text>
|
||
</Group>
|
||
<Text size="sm" c="dimmed">
|
||
Сотрудник печатает текст. Всегда завершает ветку дерева — после
|
||
него бот создаёт заявку. Требует заполнения «Подсказки» —
|
||
примера того, что нужно написать.
|
||
</Text>
|
||
</Paper>
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb={4}>
|
||
<Text size="lg">☑️</Text>
|
||
<Text fw={600}>Мультивыбор</Text>
|
||
</Group>
|
||
<Text size="sm" c="dimmed">
|
||
Сотрудник может отметить сразу несколько вариантов (например,
|
||
несколько систем: «ОКБ» и «1С»). Все отмеченные варианты
|
||
сохранятся вместе, через запятую.
|
||
</Text>
|
||
</Paper>
|
||
</Stack>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ПРИМЕР 1 */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="example-1" title="Пример: дерево «Отпуска»" />
|
||
|
||
<Text>
|
||
Разберём готовый пример целиком — от первого узла до отправки заявки.
|
||
Сценарий: сотрудник выбирает тип отсутствия, затем способ оплаты, затем
|
||
пишет причину.
|
||
</Text>
|
||
|
||
<Timeline active={5} bulletSize={28} lineWidth={2} mt="md">
|
||
<Timeline.Item title="Корневой узел">
|
||
<Text size="sm" c="dimmed">
|
||
Название: <Code>Тип отсутствия</Code>. Тип узла: Кнопка. Это
|
||
«заголовок» дерева — сам по себе кнопкой сотруднику не показывается,
|
||
но от него отходят первые варианты.
|
||
</Text>
|
||
</Timeline.Item>
|
||
<Timeline.Item title="Три дочерних узла-кнопки">
|
||
<Text size="sm" c="dimmed">
|
||
Добавляем к корню три узла: <Code>Отпуск</Code>, <Code>Отгул</Code>,{' '}
|
||
<Code>Больничный</Code>. У всех трёх DataKey одинаковый —{' '}
|
||
<Code>absence_type</Code>, а DataValue разный: <Code>vacation</Code>,{' '}
|
||
<Code>timeoff</Code>, <Code>sickleave</Code>.
|
||
</Text>
|
||
</Timeline.Item>
|
||
<Timeline.Item title="Способ оплаты — для каждой ветки">
|
||
<Text size="sm" c="dimmed">
|
||
К узлу «Отпуск» добавляем два дочерних узла: <Code>За свой счёт</Code>{' '}
|
||
и <Code>В счёт отпуска</Code>. DataKey у обоих —{' '}
|
||
<Code>payment_type</Code>, DataValue — <Code>own_expense</Code> и{' '}
|
||
<Code>vacation_account</Code> соответственно. Аналогично поступаем с
|
||
ветками «Отгул» и «Больничный».
|
||
</Text>
|
||
</Timeline.Item>
|
||
<Timeline.Item title="Текстовый ввод — конец каждой ветки">
|
||
<Text size="sm" c="dimmed">
|
||
К каждому из узлов способа оплаты добавляем узел «Текстовый ввод» с
|
||
подсказкой: <Code>Укажите даты отпуска, например: 22.02.2026 — 25.02.2026</Code>.
|
||
</Text>
|
||
</Timeline.Item>
|
||
<Timeline.Item title="Сообщение согласующему">
|
||
<Text size="sm" c="dimmed">
|
||
На узле способа оплаты (там, где заявка уже точно определена)
|
||
открываем «Шаблоны сообщения и кода темы» и вписываем текст — см.
|
||
пример ниже.
|
||
</Text>
|
||
</Timeline.Item>
|
||
</Timeline>
|
||
|
||
<CodeBlock
|
||
title="Дерево целиком выглядит так"
|
||
code={`Тип отсутствия
|
||
├── Отпуск (absence_type = vacation)
|
||
│ ├── За свой счёт (payment_type = own_expense) → Ввод текста
|
||
│ └── В счёт отпуска (payment_type = vacation_account) → Ввод текста
|
||
├── Отгул (absence_type = timeoff)
|
||
│ ├── За свой счёт (payment_type = own_expense) → Ввод текста
|
||
│ └── В счёт отпуска (payment_type = vacation_account) → Ввод текста
|
||
└── Больничный (absence_type = sickleave)
|
||
└── Официальный (payment_type = official) → Ввод текста`}
|
||
/>
|
||
|
||
<Text mt="sm">
|
||
Что увидит сотрудник в боте: сначала кнопки «Отпуск / Отгул /
|
||
Больничный», затем — «За свой счёт / В счёт отпуска», затем поле для
|
||
ввода дат. Три нажатия и один текст — заявка готова.
|
||
</Text>
|
||
|
||
<CodeBlock
|
||
title="Пример текста сообщения согласующему (поле «Шаблон сообщения»)"
|
||
code={`📋 <b>Тип: {{.absence_type_label}}</b>
|
||
|
||
<b>{{.initiator_name}}</b> просит согласовать: {{.payment_type_label}}
|
||
{{.content}}`}
|
||
/>
|
||
|
||
<Text size="sm" c="dimmed" mt="xs">
|
||
Всё, что в фигурных скобках — подставится автоматически: название узла,
|
||
который выбрал сотрудник, его имя и текст, который он написал. Про этот
|
||
синтаксис подробнее — в разделе ниже.
|
||
</Text>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ПРИМЕР 2 */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="example-2" title="Пример: выбор из нескольких списков" />
|
||
|
||
<Text>
|
||
Более сложный, но частый случай: нужно спросить у сотрудника два
|
||
независимых параметра подряд — например, филиал и тип расхода.
|
||
</Text>
|
||
|
||
<CodeBlock
|
||
title="Структура"
|
||
code={`Внебюджетные расходы
|
||
├── Филиал 1 (branch = f1)
|
||
│ ├── ТМЦ (expense_type = tmc) → Ввод текста
|
||
│ └── Расходы (expense_type = expense) → Ввод текста
|
||
└── Филиал 2 (branch = f2)
|
||
├── ТМЦ (expense_type = tmc) → Ввод текста
|
||
└── Расходы (expense_type = expense) → Ввод текста`}
|
||
/>
|
||
|
||
<Text mt="sm">
|
||
Обратите внимание: узел «ТМЦ» повторяется дважды — под «Филиал 1» и под
|
||
«Филиал 2». Это нормально: узлы с одинаковым названием на разных ветках
|
||
дерева — это разные, независимые узлы, у каждого свой ключ (система
|
||
добавляет к ключу префикс родителя автоматически).
|
||
</Text>
|
||
|
||
<CodeBlock
|
||
title="Пример сообщения согласующему"
|
||
code={`📋 <b>Внебюджетные расходы — {{.branch_label}} ({{.expense_type_label}})</b>
|
||
|
||
<b>{{.initiator_name}}</b>:
|
||
{{.content}}`}
|
||
/>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ШАБЛОНЫ */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="template-basics" title="Как писать сообщение согласующему" />
|
||
|
||
<Text>
|
||
В блоке «Шаблоны сообщения и кода темы» вы пишете обычный текст с
|
||
HTML-разметкой (<Code><b>жирный</b></Code>,{' '}
|
||
<Code><i>курсив</i></Code>) — так, как хотите видеть уведомление
|
||
у согласующего. В нужных местах вставляете «плейсхолдеры» в фигурных
|
||
скобках — они подставляются автоматически.
|
||
</Text>
|
||
|
||
<Table withTableBorder withColumnBorders mt="md">
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 260 }}>Что написать</Table.Th>
|
||
<Table.Th>Что подставится</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
<Table.Tr>
|
||
<Table.Td><Code>{`{{.initiator_name}}`}</Code></Table.Td>
|
||
<Table.Td>Имя сотрудника, который создал заявку</Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td><Code>{`{{.content}}`}</Code></Table.Td>
|
||
<Table.Td>Текст, который сотрудник ввёл на последнем шаге</Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td><Code>{`{{.название_кнопки_label}}`}</Code></Table.Td>
|
||
<Table.Td>
|
||
Название выбранной сотрудником кнопки. Например, если DataKey
|
||
кнопки — <Code>region</Code>, пишите{' '}
|
||
<Code>{`{{.region_label}}`}</Code>, и туда подставится «Крым» или
|
||
«Краснодар» — смотря что выбрал сотрудник
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
<Callout title="Проще всего — по аналогии" mt="md">
|
||
Не нужно запоминать синтаксис. Откройте похожий уже настроенный узел (в
|
||
этой же или другой категории), скопируйте оттуда шаблон и замените
|
||
плейсхолдеры на DataKey ваших узлов.
|
||
</Callout>
|
||
|
||
<Text mt="md">
|
||
Дополнительно доступны несколько простых условий — пригодятся, если
|
||
сообщение должно немного отличаться в зависимости от выбора:
|
||
</Text>
|
||
|
||
<CodeBlock
|
||
title="Показать текст, только если поле заполнено"
|
||
code={`{{if .payment_type_label}}Способ оплаты: {{.payment_type_label}}{{end}}`}
|
||
/>
|
||
|
||
<CodeBlock
|
||
title="Показать разный текст в зависимости от выбора"
|
||
code={`{{if eq .absence_type "vacation"}}Отпуск{{else}}Отгул{{end}}`}
|
||
/>
|
||
|
||
<Text size="sm" c="dimmed" mt="xs">
|
||
Поле «Шаблон кода темы» обычно можно не трогать — если оставить пустым,
|
||
система сама соберёт код заявки из всех выборов сотрудника. Заполняйте его
|
||
только если вам явно сказали, что для этой темы нужен особый код
|
||
(например, если это уже настроенная в системе тема с заранее заданным
|
||
названием).
|
||
</Text>
|
||
|
||
{/* ============================================================ */}
|
||
{/* СОВЕТЫ */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="tips" title="Советы и правила" />
|
||
|
||
<Stack gap="sm" mt="md">
|
||
<TipEntry
|
||
title="Одинаковый DataKey у братьев"
|
||
text="Все узлы-кнопки, отходящие от одного и того же родителя, должны иметь одинаковый DataKey (например, все — region), а DataValue у каждого — свой (crimea, krasnodar). Иначе бот запутается, какой ответ на какой вопрос сохранён."
|
||
/>
|
||
<TipEntry
|
||
title="Каждая ветка должна заканчиваться вводом текста"
|
||
text="Если ветка обрывается на кнопке — сотрудник не сможет закончить заявку. Всегда добавляйте узел «Текстовый ввод» в конце каждого пути."
|
||
/>
|
||
<TipEntry
|
||
title="Название узла — то, что видит сотрудник"
|
||
text="Пишите названия узлов понятно и коротко: то, что вы вводите в поле «Название», один в один появится кнопкой в Telegram."
|
||
/>
|
||
<TipEntry
|
||
title="Ключ трогать не обязательно"
|
||
text="Поле «Ключ» заполняется автоматически из названия — это техническая метка, которую использует система внутри себя. Менять его вручную нужно, только если он получился слишком длинным или непонятным."
|
||
/>
|
||
<TipEntry
|
||
title="Изменения сохраняются сразу"
|
||
text="Не нужно искать кнопку «Сохранить дерево» — каждое действие (добавление, редактирование, перемещение, удаление узла) применяется мгновенно."
|
||
/>
|
||
<TipEntry
|
||
title="Удаление узла удаляет и всё, что под ним"
|
||
text="Если вы удаляете узел, у которого есть дочерние узлы — они удалятся вместе с ним. Система предупредит об этом перед удалением."
|
||
/>
|
||
</Stack>
|
||
|
||
{/* ============================================================ */}
|
||
{/* ДИАГНОСТИКА */}
|
||
{/* ============================================================ */}
|
||
<DocSection id="troubleshooting" title="Если что-то не работает" />
|
||
|
||
<Text>
|
||
Частые ситуации и что с ними делать:
|
||
</Text>
|
||
|
||
<Stack gap="md" mt="md">
|
||
<ErrorEntry
|
||
title="Бот не находит тему заявки после всех вопросов"
|
||
description="Это значит, что набор выборов сотрудника не совпал ни с одной настроенной темой в системе."
|
||
resolution="Проверьте узел, где задан код темы (поле «Код темы» или шаблон кода) — сверьте его с администратором системы, который заводит темы заявок."
|
||
/>
|
||
<ErrorEntry
|
||
title="В сообщении согласующему вместо текста написано «<no value>»"
|
||
description="Шаблон сообщения ссылается на вариант, который сотрудник не выбирал на этом пути."
|
||
resolution="Проверьте, что в дереве действительно есть узел с таким DataKey на пути к этому сообщению, и уберите из шаблона лишние плейсхолдеры."
|
||
/>
|
||
<ErrorEntry
|
||
title="Система не даёт сохранить узел — «ключ уже используется»"
|
||
description="В этой же категории уже есть узел с таким же техническим ключом."
|
||
resolution="Измените название узла (ключ сгенерируется заново) или вручную поправьте поле «Ключ» на уникальное значение."
|
||
/>
|
||
<ErrorEntry
|
||
title="Не получается переместить узел"
|
||
description="Система не разрешает сделать узел «родителем самого себя» — например, перетащить ветку внутрь её же собственного потомка."
|
||
resolution="Выберите другого родителя, который не находится ниже перемещаемого узла по дереву."
|
||
/>
|
||
<ErrorEntry
|
||
title="Сотрудник дошёл до конца, а кнопки «Отправить» нет"
|
||
description="Скорее всего, эта ветка дерева не заканчивается узлом «Текстовый ввод»."
|
||
resolution="Найдите последнюю кнопку в этой ветке и добавьте к ней дочерний узел типа «Текстовый ввод»."
|
||
/>
|
||
</Stack>
|
||
|
||
<Divider mt="xl" />
|
||
|
||
<Text size="sm" c="dimmed" ta="center">
|
||
Остались вопросы — обратитесь к администратору системы согласований.
|
||
</Text>
|
||
</Stack>
|
||
</Box>
|
||
</Box>
|
||
)
|
||
}
|
||
|
||
// ================================================================
|
||
// Вспомогательные компоненты
|
||
// ================================================================
|
||
|
||
function DocSection({ id, title, level = 1 }: { id: string; title: string; level?: number }) {
|
||
return (
|
||
<Box id={id} pt={8}>
|
||
{level === 1 ? (
|
||
<Title order={2}>{title}</Title>
|
||
) : (
|
||
<Title order={3} c="dimmed">{title}</Title>
|
||
)}
|
||
</Box>
|
||
)
|
||
}
|
||
|
||
function CodeBlock({ title, code }: { title: string; code: string }) {
|
||
return (
|
||
<Paper withBorder mt="md">
|
||
<Group justify="space-between" px="sm" py={6} style={{ borderBottom: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Text size="xs" fw={600} c="dimmed" tt="uppercase" lts={0.5}>{title}</Text>
|
||
<CopyButton value={code}>
|
||
{({ copied, copy }) => (
|
||
<Tooltip label={copied ? 'Скопировано' : 'Копировать'}>
|
||
<ActionIcon
|
||
size="xs"
|
||
variant="subtle"
|
||
color={copied ? 'teal' : 'gray'}
|
||
onClick={copy}
|
||
>
|
||
{copied ? <IconCheck size={14} /> : <IconCopy size={14} />}
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
)}
|
||
</CopyButton>
|
||
</Group>
|
||
<Box p="sm">
|
||
<Code block style={{ fontSize: 12, whiteSpace: 'pre-wrap', lineHeight: 1.5 }}>
|
||
{code}
|
||
</Code>
|
||
</Box>
|
||
</Paper>
|
||
)
|
||
}
|
||
|
||
function Callout({ title, children, mt = 'md' }: { title: string; children: React.ReactNode; mt?: string }) {
|
||
return (
|
||
<Alert
|
||
variant="light"
|
||
color="blue"
|
||
icon={<IconBulb size={16} />}
|
||
title={title}
|
||
mt={mt}
|
||
styles={{
|
||
title: { fontSize: 13, fontWeight: 600 },
|
||
message: { fontSize: 13 },
|
||
}}
|
||
>
|
||
{children}
|
||
</Alert>
|
||
)
|
||
}
|
||
|
||
function TipEntry({ title, text }: { title: string; text: string }) {
|
||
return (
|
||
<Group gap="md" align="flex-start" wrap="nowrap">
|
||
<ThemeIcon variant="light" color="teal" size={28} radius="xl" style={{ flexShrink: 0 }}>
|
||
<IconBulb size={16} />
|
||
</ThemeIcon>
|
||
<Box>
|
||
<Text size="sm" fw={600}>{title}</Text>
|
||
<Text size="sm" c="dimmed">{text}</Text>
|
||
</Box>
|
||
</Group>
|
||
)
|
||
}
|
||
|
||
function ErrorEntry({ title, description, resolution }: { title: string; description: string; resolution: string }) {
|
||
return (
|
||
<Paper withBorder p="sm">
|
||
<Group gap="xs" mb={4}>
|
||
<ThemeIcon variant="light" color="orange" size={22} radius="xl">
|
||
<IconAlertTriangle size={13} />
|
||
</ThemeIcon>
|
||
<Text size="sm" fw={600}>{title}</Text>
|
||
</Group>
|
||
<Text size="sm" c="dimmed">{description}</Text>
|
||
<Text size="sm" mt={4}>
|
||
<Text span fw={600}>Что делать: </Text>
|
||
<Text span c="dimmed">{resolution}</Text>
|
||
</Text>
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/FlowTreeGuidePage.tsx-----
|
||
|
||
File: src/pages/flowNodes/FlowTreePage.tsx
|
||
Lines: 210
|
||
-----BEGIN src/pages/flowNodes/FlowTreePage.tsx-----
|
||
import { useState, useMemo } from 'react'
|
||
import {
|
||
Paper,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Select,
|
||
Loader,
|
||
Center,
|
||
Stack,
|
||
Badge,
|
||
Alert,
|
||
Tooltip,
|
||
} from '@mantine/core'
|
||
import { IconPlus, IconInfoCircle, IconBook, IconFolderPlus, IconRefresh } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import {
|
||
useFlowNodesTree,
|
||
useDeleteFlowNode,
|
||
useDuplicateFlowNode,
|
||
useReloadBot,
|
||
} from '@/features/flowNodes/hooks/useFlowNodes'
|
||
import { findParent } from '@/features/flowNodes/utils/treeWalk'
|
||
import type { ApprovalFlowNode, ApprovalTopicCategory } from '@/types/api'
|
||
import { useNavigate } from 'react-router-dom'
|
||
import CategoryCreateModal from "@/pages/flowNodes/components/CategoryCreateModal.tsx";
|
||
import FlowNodeEditModal from "@/pages/flowNodes/components/FlowNodeEditModal.tsx";
|
||
import SortableFlowTree from "@/pages/flowNodes/components/SortableFlowTree.tsx";
|
||
import TreeHealthPanel from "@/pages/flowNodes/components/TreeHealthPanel.tsx";
|
||
|
||
export default function FlowTreePage() {
|
||
const [selectedCategoryId, setSelectedCategoryId] = useState<number | null>(null)
|
||
const [categoryModalOpened, setCategoryModalOpened] = useState(false)
|
||
|
||
const [editModal, setEditModal] = useState<{
|
||
opened: boolean
|
||
parentNode: ApprovalFlowNode | null
|
||
editNode: ApprovalFlowNode | null
|
||
}>({ opened: false, parentNode: null, editNode: null })
|
||
|
||
const { data: categoriesData } = useCategories({ limit: 1000, is_active: true })
|
||
const categories = categoriesData?.data || []
|
||
|
||
const { data: treeData, isLoading: treeLoading } = useFlowNodesTree(selectedCategoryId)
|
||
const tree = treeData?.data || []
|
||
|
||
const deleteFlowNode = useDeleteFlowNode()
|
||
const duplicateFlowNode = useDuplicateFlowNode()
|
||
const reloadBot = useReloadBot()
|
||
|
||
const navigate = useNavigate()
|
||
|
||
const selectedCategory = useMemo<ApprovalTopicCategory | null>(
|
||
() => categories.find((c) => c.id === selectedCategoryId) || null,
|
||
[categories, selectedCategoryId]
|
||
)
|
||
|
||
const categoryOptions = categories.map((c) => ({ value: String(c.id), label: `${c.name} (${c.code})` }))
|
||
|
||
const countNodes = (nodes: ApprovalFlowNode[]): number => {
|
||
let count = nodes.length
|
||
for (const n of nodes) if (n.children) count += countNodes(n.children)
|
||
return count
|
||
}
|
||
const totalNodes = countNodes(tree)
|
||
|
||
const handleEdit = (node: ApprovalFlowNode) => {
|
||
const parent = findParent(tree, node.id!)
|
||
setEditModal({ opened: true, parentNode: parent, editNode: node })
|
||
}
|
||
|
||
const handleAddChild = (parent: ApprovalFlowNode) => {
|
||
setEditModal({ opened: true, parentNode: parent, editNode: null })
|
||
}
|
||
|
||
const handleAddRoot = () => {
|
||
setEditModal({ opened: true, parentNode: null, editNode: null })
|
||
}
|
||
|
||
const handleDelete = (node: ApprovalFlowNode) => {
|
||
modals.openConfirmModal({
|
||
title: 'Удалить этот шаг?',
|
||
children: (
|
||
<Text size="sm">
|
||
Удалить шаг <b>{node.label}</b>? Все шаги, которые идут после него, тоже удалятся.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteFlowNode.mutate(node.id!),
|
||
})
|
||
}
|
||
|
||
const handleDuplicate = (node: ApprovalFlowNode) => duplicateFlowNode.mutate(node.id!)
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>
|
||
Конструктор тем
|
||
</Text>
|
||
<Group>
|
||
{selectedCategory && <Badge size="lg" variant="light">{totalNodes} шагов</Badge>}
|
||
<Tooltip label="Заставить бота немедленно перечитать разделы/деревья/темы из базы, не дожидаясь автоматической проверки">
|
||
<Button
|
||
variant="light"
|
||
color="orange"
|
||
leftSection={<IconRefresh size={16} />}
|
||
onClick={() => reloadBot.mutate()}
|
||
loading={reloadBot.isPending}
|
||
>
|
||
Обновить бота
|
||
</Button>
|
||
</Tooltip>
|
||
<Button variant="light" leftSection={<IconBook size={16} />} onClick={() => navigate('/guide/flow-trees')}>
|
||
Руководство
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
<Paper withBorder p="md">
|
||
<Group align="end" gap="sm">
|
||
<Select
|
||
label="Раздел заявок"
|
||
placeholder="Выберите раздел, дерево которого будете настраивать"
|
||
data={categoryOptions}
|
||
value={selectedCategoryId ? String(selectedCategoryId) : null}
|
||
onChange={(v) => setSelectedCategoryId(v ? Number(v) : null)}
|
||
searchable
|
||
style={{ flex: 1 }}
|
||
/>
|
||
<Tooltip label="Завести новый раздел заявок, не выходя отсюда">
|
||
<Button
|
||
variant="default"
|
||
leftSection={<IconFolderPlus size={16} />}
|
||
onClick={() => setCategoryModalOpened(true)}
|
||
>
|
||
Новый раздел
|
||
</Button>
|
||
</Tooltip>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{selectedCategoryId && (
|
||
<Paper withBorder p="md">
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Group gap="xs">
|
||
{treeLoading && <Loader size="xs" />}
|
||
</Group>
|
||
<Button leftSection={<IconPlus size={16} />} onClick={handleAddRoot} disabled={tree.length > 0}>
|
||
Добавить первый вопрос
|
||
</Button>
|
||
</Group>
|
||
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="sm">
|
||
Перетаскивайте шаги за значок ⠿ слева, чтобы менять порядок и вложенность — тяните
|
||
влево/вправо во время перетаскивания, чтобы изменить уровень. Первый шаг дерева
|
||
(с пометкой «начало дерева») не перетаскивается.
|
||
</Text>
|
||
</Alert>
|
||
|
||
{treeLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : tree.length === 0 ? (
|
||
<Center p={40}>
|
||
<Stack gap="sm" align="center">
|
||
<Text c="dimmed">В этом разделе пока нет вопросов</Text>
|
||
<Button leftSection={<IconPlus size={16} />} onClick={handleAddRoot}>
|
||
Добавить первый вопрос
|
||
</Button>
|
||
</Stack>
|
||
</Center>
|
||
) : (
|
||
<SortableFlowTree
|
||
tree={tree}
|
||
onEdit={handleEdit}
|
||
onAddChild={handleAddChild}
|
||
onDelete={handleDelete}
|
||
onDuplicate={handleDuplicate}
|
||
/>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{selectedCategoryId && tree.length > 0 && <TreeHealthPanel categoryId={selectedCategoryId} tree={tree} />}
|
||
|
||
{selectedCategoryId && (
|
||
<FlowNodeEditModal
|
||
categoryId={selectedCategoryId}
|
||
tree={tree}
|
||
parentNode={editModal.parentNode}
|
||
editNode={editModal.editNode}
|
||
opened={editModal.opened}
|
||
onClose={() => setEditModal({ opened: false, parentNode: null, editNode: null })}
|
||
/>
|
||
)}
|
||
|
||
<CategoryCreateModal
|
||
opened={categoryModalOpened}
|
||
onClose={() => setCategoryModalOpened(false)}
|
||
onCreated={(newId) => setSelectedCategoryId(newId)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/FlowTreePage.tsx-----
|
||
|
||
File: src/pages/flowNodes/components/CategoryCreateModal.tsx
|
||
Lines: 120
|
||
-----BEGIN src/pages/flowNodes/components/CategoryCreateModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import { Modal, Stack, TextInput, Textarea, Group, Button, Text, Alert } from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { IconInfoCircle } from '@tabler/icons-react'
|
||
import { useCreateCategory } from '@/features/categories/hooks/useCategories'
|
||
import type { CreateCategoryRequest } from '@/api/categories'
|
||
|
||
interface CategoryCreateModalProps {
|
||
opened: boolean
|
||
onClose: () => void
|
||
onCreated: (categoryId: number) => void
|
||
}
|
||
|
||
const translitMap: Record<string, string> = {
|
||
а: 'a', б: 'b', в: 'v', г: 'g', д: 'd', е: 'e', ё: 'yo', ж: 'zh', з: 'z', и: 'i', й: 'y',
|
||
к: 'k', л: 'l', м: 'm', н: 'n', о: 'o', п: 'p', р: 'r', с: 's', т: 't', у: 'u', ф: 'f',
|
||
х: 'h', ц: 'ts', ч: 'ch', ш: 'sh', щ: 'sch', ъ: '', ы: 'y', ь: '', э: 'e', ю: 'yu', я: 'ya',
|
||
}
|
||
|
||
function slugify(text: string): string {
|
||
return text
|
||
.toLowerCase()
|
||
.split('')
|
||
.map((ch) => translitMap[ch] ?? ch)
|
||
.join('')
|
||
.replace(/[\s-]+/g, '_')
|
||
.replace(/[^a-z0-9_]/g, '')
|
||
.replace(/_+/g, '_')
|
||
.replace(/^_+|_+$/g, '')
|
||
// Код раздела попадает в Telegram callback_data КАЖДОЙ кнопки внутри
|
||
// этой категории (формат "appr:{код_раздела}:{ключ_шага}", лимит
|
||
// Telegram — 64 байта на всю строку) — держим его коротким, иначе
|
||
// он съедает бюджет, который нужен для ключей узлов вглубь дерева.
|
||
.substring(0, 20)
|
||
}
|
||
|
||
// Создание новой категории (раздела заявок) прямо из конструктора дерева —
|
||
// требование "полной автономности": админ не должен переходить в другой
|
||
// раздел, чтобы завести новый вид заявки.
|
||
export default function CategoryCreateModal({ opened, onClose, onCreated }: CategoryCreateModalProps) {
|
||
const createCategory = useCreateCategory()
|
||
|
||
const form = useForm({
|
||
initialValues: { name: '', code: '', description: '' },
|
||
validate: {
|
||
name: (v) => (!v || v.length < 2 ? 'Введите название раздела' : null),
|
||
code: (v) => (!v || v.length < 2 ? 'Технический код должен быть заполнен' : null),
|
||
},
|
||
})
|
||
|
||
useEffect(() => {
|
||
if (opened) form.reset()
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [opened])
|
||
|
||
useEffect(() => {
|
||
form.setFieldValue('code', slugify(form.values.name))
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [form.values.name])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
const payload: CreateCategoryRequest = {
|
||
name: values.name,
|
||
code: values.code,
|
||
description: values.description || undefined,
|
||
is_active: true,
|
||
}
|
||
const result = await createCategory.mutateAsync(payload)
|
||
// categoriesApi.create возвращает ApprovalTopicCategory без обёртки
|
||
// (apiClient.post<ApprovalTopicCategory>), axios кладёт его в response.data.
|
||
const newId = result?.data?.id
|
||
if (newId) onCreated(newId)
|
||
onClose()
|
||
}
|
||
|
||
return (
|
||
<Modal opened={opened} onClose={onClose} title={<Text fw={700}>Новый раздел заявок</Text>}>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="xs">
|
||
Раздел — это то, что сотрудник увидит в главном меню бота (например, «Отпуска» или
|
||
«Возвраты»). Внутри одного раздела вы потом соберёте дерево вопросов.
|
||
</Text>
|
||
</Alert>
|
||
|
||
<TextInput
|
||
label="Название раздела"
|
||
placeholder="Например: Возвраты товара"
|
||
description="То, что увидит сотрудник в списке заявок"
|
||
required
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Технический код"
|
||
description="Заполняется само из названия. Трогать не нужно."
|
||
disabled
|
||
{...form.getInputProps('code')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Описание (необязательно)"
|
||
placeholder="Короткая заметка для себя, сотрудники её не видят"
|
||
minRows={2}
|
||
{...form.getInputProps('description')}
|
||
/>
|
||
|
||
<Group justify="flex-end" mt="sm">
|
||
<Button variant="default" onClick={onClose}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={createCategory.isPending}>
|
||
Создать раздел
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/components/CategoryCreateModal.tsx-----
|
||
|
||
File: src/pages/flowNodes/components/DataFlowExplainer.tsx
|
||
Lines: 462
|
||
-----BEGIN src/pages/flowNodes/components/DataFlowExplainer.tsx-----
|
||
import {
|
||
Paper,
|
||
Stack,
|
||
Text,
|
||
Code,
|
||
Box,
|
||
Group,
|
||
Badge,
|
||
Alert,
|
||
Divider,
|
||
Table,
|
||
ThemeIcon,
|
||
Collapse,
|
||
ActionIcon,
|
||
} from '@mantine/core'
|
||
import { useState } from 'react'
|
||
import {
|
||
IconArrowRight,
|
||
IconDatabase,
|
||
IconCode,
|
||
IconMessage,
|
||
IconAlertTriangle,
|
||
IconCheck,
|
||
IconChevronDown,
|
||
IconChevronRight, IconBulb,
|
||
} from '@tabler/icons-react'
|
||
|
||
interface DataFlowExplainerProps {
|
||
dataKey?: string
|
||
dataValue?: string
|
||
label?: string
|
||
nodeType: 'button' | 'input' | 'multiselect'
|
||
}
|
||
|
||
export default function DataFlowExplainer({
|
||
dataKey,
|
||
dataValue,
|
||
label,
|
||
nodeType,
|
||
}: DataFlowExplainerProps) {
|
||
const [showDetails, setShowDetails] = useState(false)
|
||
|
||
// Примеры из реальных тем
|
||
const examples = [
|
||
{
|
||
label: 'Крым',
|
||
dataKey: 'region',
|
||
dataValue: 'crimea',
|
||
description: 'Выбор региона',
|
||
category: 'region',
|
||
},
|
||
{
|
||
label: 'Ф1',
|
||
dataKey: 'branch',
|
||
dataValue: 'f1',
|
||
description: 'Выбор филиала',
|
||
category: 'branch',
|
||
},
|
||
{
|
||
label: 'За свой счёт',
|
||
dataKey: 'payment_type',
|
||
dataValue: 'own_expense',
|
||
description: 'Тип оплаты',
|
||
category: 'payment',
|
||
},
|
||
{
|
||
label: 'ТМЦ',
|
||
dataKey: 'expense_type',
|
||
dataValue: 'tmc',
|
||
description: 'Тип расхода',
|
||
category: 'expense',
|
||
},
|
||
{
|
||
label: 'На один день',
|
||
dataKey: 'duration_type',
|
||
dataValue: 'single_day',
|
||
description: 'Длительность',
|
||
category: 'duration',
|
||
},
|
||
]
|
||
|
||
// Определяем, есть ли конфликт с существующими ключами
|
||
const isDuplicateKey = examples.some(
|
||
(e) => e.dataKey === dataKey && e.dataValue === dataValue
|
||
)
|
||
|
||
return (
|
||
<Paper withBorder p="md" bg="blue.0">
|
||
<Stack gap="md">
|
||
{/* Заголовок */}
|
||
<Group justify="space-between">
|
||
<Group gap="xs">
|
||
<ThemeIcon color="blue" variant="light" size="lg">
|
||
<IconBulb size={20} />
|
||
</ThemeIcon>
|
||
<div>
|
||
<Text fw={600} size="sm">
|
||
Что такое DataKey и DataValue?
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
Краткое объяснение — нажми, чтобы узнать больше
|
||
</Text>
|
||
</div>
|
||
</Group>
|
||
<ActionIcon
|
||
variant="subtle"
|
||
onClick={() => setShowDetails(!showDetails)}
|
||
>
|
||
{showDetails ? (
|
||
<IconChevronDown size={20} />
|
||
) : (
|
||
<IconChevronRight size={20} />
|
||
)}
|
||
</ActionIcon>
|
||
</Group>
|
||
|
||
{/* Краткое объяснение (всегда видно) */}
|
||
<Box>
|
||
<Text size="sm" mb="xs">
|
||
<b>DataKey</b> и <b>DataValue</b> — это пара "ключ-значение", которая
|
||
сохраняется в память пользователя, когда он нажимает на этот узел.
|
||
</Text>
|
||
<Text size="sm">
|
||
Позже эти значения используются для:
|
||
</Text>
|
||
<Group gap="xs" mt="xs">
|
||
<Badge color="green" variant="light" leftSection={<IconCode size={12} />}>
|
||
Формирования кода темы
|
||
</Badge>
|
||
<Badge color="violet" variant="light" leftSection={<IconMessage size={12} />}>
|
||
Сообщения согласующему
|
||
</Badge>
|
||
<Badge color="orange" variant="light" leftSection={<IconDatabase size={12} />}>
|
||
Сохранения в заявке
|
||
</Badge>
|
||
</Group>
|
||
</Box>
|
||
|
||
{/* Интерактивный превью */}
|
||
{dataKey && dataValue && (
|
||
<Paper withBorder p="sm" bg="white">
|
||
<Text size="xs" fw={600} c="dimmed" mb="xs">
|
||
📊 Что произойдёт, когда пользователь нажмёт "{label || 'этот узел'}":
|
||
</Text>
|
||
|
||
{/* Поток данных */}
|
||
<Stack gap="xs">
|
||
{/* Шаг 1: Нажатие */}
|
||
<Group gap="xs" wrap="nowrap">
|
||
<ThemeIcon size="sm" color="blue" variant="light">
|
||
<Text size="xs" fw={700}>1</Text>
|
||
</ThemeIcon>
|
||
<Text size="xs" style={{ flex: 1 }}>
|
||
Пользователь нажимает <b>"{label || '...'}"</b>
|
||
</Text>
|
||
</Group>
|
||
|
||
<Box ml={20}>
|
||
<IconArrowRight size={14} style={{ color: 'gray' }} />
|
||
</Box>
|
||
|
||
{/* Шаг 2: Сохранение */}
|
||
<Group gap="xs" wrap="nowrap">
|
||
<ThemeIcon size="sm" color="green" variant="light">
|
||
<Text size="xs" fw={700}>2</Text>
|
||
</ThemeIcon>
|
||
<Text size="xs" style={{ flex: 1 }}>
|
||
В память сохраняется:{' '}
|
||
<Code>{dataKey} = "{dataValue}"</Code>
|
||
</Text>
|
||
</Group>
|
||
|
||
<Box ml={20}>
|
||
<IconArrowRight size={14} style={{ color: 'gray' }} />
|
||
</Box>
|
||
|
||
{/* Шаг 3: Автоматический label */}
|
||
<Group gap="xs" wrap="nowrap">
|
||
<ThemeIcon size="sm" color="cyan" variant="light">
|
||
<Text size="xs" fw={700}>3</Text>
|
||
</ThemeIcon>
|
||
<Text size="xs" style={{ flex: 1 }}>
|
||
Автоматически добавляется:{' '}
|
||
<Code>{dataKey}_label = "{label || '...'}"</Code>
|
||
</Text>
|
||
</Group>
|
||
|
||
<Box ml={20}>
|
||
<IconArrowRight size={14} style={{ color: 'gray' }} />
|
||
</Box>
|
||
|
||
{/* Шаг 4: Использование */}
|
||
<Group gap="xs" wrap="nowrap">
|
||
<ThemeIcon size="sm" color="violet" variant="light">
|
||
<Text size="xs" fw={700}>4</Text>
|
||
</ThemeIcon>
|
||
<Text size="xs" style={{ flex: 1 }}>
|
||
Эти значения можно использовать в шаблонах темы:
|
||
</Text>
|
||
</Group>
|
||
|
||
<Box ml={36}>
|
||
<Code block style={{ fontSize: 11 }}>
|
||
{`В message_template:
|
||
"{{.${dataKey}}}" → "${dataValue}"
|
||
"{{.${dataKey}_label}}" → "${label || '...'}"
|
||
|
||
В code_template:
|
||
"{{.${dataKey}}}" → "${dataValue}"`}
|
||
</Code>
|
||
</Box>
|
||
</Stack>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Развёрнутое объяснение */}
|
||
<Collapse expanded={showDetails}>
|
||
<Stack gap="md" mt="md">
|
||
<Divider label="Подробное объяснение" labelPosition="center" />
|
||
|
||
{/* Зачем это нужно */}
|
||
<Box>
|
||
<Text size="sm" fw={600} mb="xs">
|
||
🎯 Зачем это нужно?
|
||
</Text>
|
||
<Text size="xs" mb="xs">
|
||
Представьте, что пользователь создаёт заявку "Отпуск на один день за свой счёт".
|
||
Система должна понять, <b>какую именно тему</b> использовать и <b>как отформатировать
|
||
сообщение</b> для согласующего. Для этого она собирает "память" пользователя —
|
||
map <Code>collected</Code>, куда по пути попадают все DataKey/DataValue.
|
||
</Text>
|
||
</Box>
|
||
|
||
{/* Реальный пример */}
|
||
<Box>
|
||
<Text size="sm" fw={600} mb="xs">
|
||
📖 Реальный пример (тема "Отпуск")
|
||
</Text>
|
||
<Text size="xs" mb="xs">
|
||
Пользователь проходит путь: <b>Отпуск → На один день → За свой счёт → Ввод текста</b>
|
||
</Text>
|
||
|
||
<Table withTableBorder withColumnBorders>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th>Шаг</Table.Th>
|
||
<Table.Th>Узел (Label)</Table.Th>
|
||
<Table.Th>DataKey</Table.Th>
|
||
<Table.Th>DataValue</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
<Table.Tr>
|
||
<Table.Td>1</Table.Td>
|
||
<Table.Td>Отпуск</Table.Td>
|
||
<Table.Td><Code>absence_type</Code></Table.Td>
|
||
<Table.Td><Code>vacation</Code></Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td>2</Table.Td>
|
||
<Table.Td>На один день</Table.Td>
|
||
<Table.Td><Code>duration_type</Code></Table.Td>
|
||
<Table.Td><Code>single_day</Code></Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td>3</Table.Td>
|
||
<Table.Td>За свой счёт</Table.Td>
|
||
<Table.Td><Code>payment_type</Code></Table.Td>
|
||
<Table.Td><Code>own_expense</Code></Table.Td>
|
||
</Table.Tr>
|
||
<Table.Tr>
|
||
<Table.Td>4</Table.Td>
|
||
<Table.Td>Ввод текста</Table.Td>
|
||
<Table.Td><Code>content</Code></Table.Td>
|
||
<Table.Td><i>(текст пользователя)</i></Table.Td>
|
||
</Table.Tr>
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
<Text size="xs" mt="xs" fw={600}>
|
||
Итоговый collected:
|
||
</Text>
|
||
<Code block style={{ fontSize: 11 }}>
|
||
{`{
|
||
"absence_type": "vacation",
|
||
"absence_type_label": "Отпуск", ← автоматически из Label
|
||
"duration_type": "single_day",
|
||
"duration_type_label": "На один день", ← автоматически
|
||
"payment_type": "own_expense",
|
||
"payment_type_label": "За свой счёт", ← автоматически
|
||
"content": "22.02.2026"
|
||
}`}
|
||
</Code>
|
||
</Box>
|
||
|
||
{/* Как это используется */}
|
||
<Box>
|
||
<Text size="sm" fw={600} mb="xs">
|
||
🔧 Как это используется?
|
||
</Text>
|
||
|
||
<Text size="xs" fw={600} mt="xs" mb={4}>
|
||
1. Формирование кода темы (code_template):
|
||
</Text>
|
||
<Code block style={{ fontSize: 11 }}>
|
||
{`Шаблон: vacation_{{.duration_type}}_full_day_{{.payment_type}}
|
||
Результат: vacation_single_day_full_day_own_expense
|
||
|
||
Этот код ищет в БД конкретную тему для заявки.`}
|
||
</Code>
|
||
|
||
<Text size="xs" fw={600} mt="xs" mb={4}>
|
||
2. Сообщение согласующему (message_template):
|
||
</Text>
|
||
<Code block style={{ fontSize: 11 }}>
|
||
{`Шаблон:
|
||
📋 <b>Тип: Отпуск</b>
|
||
<b>{{.initiator_name}}</b>: прошу согласовать отпуск
|
||
{{.content}}
|
||
<i>{{.payment_type_label}}</i>
|
||
|
||
Результат:
|
||
📋 <b>Тип: Отпуск</b>
|
||
<b>Иванов И.И.</b>: прошу согласовать отпуск
|
||
22.02.2026
|
||
<i>За свой счёт</i>`}
|
||
</Code>
|
||
</Box>
|
||
|
||
{/* Правила */}
|
||
<Alert icon={<IconAlertTriangle size={16} />} color="yellow" variant="light">
|
||
<Text size="xs" fw={600} mb="xs">
|
||
⚠️ Правила, которые нужно соблюдать:
|
||
</Text>
|
||
<Stack gap={4}>
|
||
<Text size="xs">
|
||
<b>1. DataKey должен быть осмысленным.</b> Используйте понятные имена:{' '}
|
||
<Code>region</Code>, <Code>branch</Code>, <Code>payment_type</Code>.
|
||
Не используйте <Code>x</Code>, <Code>val</Code>, <Code>data</Code>.
|
||
</Text>
|
||
<Text size="xs">
|
||
<b>2. DataValue должен быть уникальным в рамках одного DataKey.</b>{' '}
|
||
Если у вас есть два узла с <Code>region=crimea</Code> и{' '}
|
||
<Code>region=krasnodar</Code> — это правильно. Но если оба будут{' '}
|
||
<Code>region=crimea</Code> — система не сможет их различить.
|
||
</Text>
|
||
<Text size="xs">
|
||
<b>3. Используйте snake_case.</b> Только lowercase, цифры и подчёркивания:{' '}
|
||
<Code>own_expense</Code> ✅, <Code>OwnExpense</Code> ❌,{' '}
|
||
<Code>own-expense</Code> ❌.
|
||
</Text>
|
||
<Text size="xs">
|
||
<b>4. Один DataKey на одном уровне дерева.</b> Если на одном уровне
|
||
несколько кнопок — у всех должен быть одинаковый DataKey, но разные DataValue.
|
||
Например, три кнопки "Крым/Краснодар/Беларусь" — все с <Code>region</Code>,
|
||
но с разными значениями.
|
||
</Text>
|
||
<Text size="xs">
|
||
<b>5. Label — это то, что видит пользователь.</b> DataValue — техническое
|
||
значение. Они могут отличаться: Label="За свой счёт", DataValue="own_expense".
|
||
</Text>
|
||
</Stack>
|
||
</Alert>
|
||
|
||
{/* Типичные ошибки */}
|
||
<Box>
|
||
<Text size="sm" fw={600} mb="xs">
|
||
❌ Типичные ошибки:
|
||
</Text>
|
||
<Stack gap="xs">
|
||
<Paper withBorder p="xs" bg="red.0">
|
||
<Text size="xs">
|
||
<b>Ошибка:</b> Два узла на одном уровне с одинаковыми DataKey и DataValue
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
Последствие: система не сможет различить, какую ветку выбрал пользователь
|
||
</Text>
|
||
</Paper>
|
||
<Paper withBorder p="xs" bg="red.0">
|
||
<Text size="xs">
|
||
<b>Ошибка:</b> Разные DataKey на одном уровне (например, у одной кнопки{' '}
|
||
<Code>region</Code>, у другой <Code>area</Code>)
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
Последствие: в collected появятся два разных ключа, что сломает шаблоны
|
||
</Text>
|
||
</Paper>
|
||
<Paper withBorder p="xs" bg="red.0">
|
||
<Text size="xs">
|
||
<b>Ошибка:</b> DataValue с пробелами или заглавными буквами
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
Последствие: код темы будет некорректным, заявка не создастся
|
||
</Text>
|
||
</Paper>
|
||
<Paper withBorder p="xs" bg="red.0">
|
||
<Text size="xs">
|
||
<b>Ошибка:</b> Пустой DataKey или DataValue у кнопки
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
Последствие: данные не сохранятся, шаблон не сможет их использовать
|
||
</Text>
|
||
</Paper>
|
||
</Stack>
|
||
</Box>
|
||
|
||
{/* Правильные примеры */}
|
||
<Box>
|
||
<Text size="sm" fw={600} mb="xs">
|
||
✅ Правильные примеры из реальных тем:
|
||
</Text>
|
||
<Table withTableBorder withColumnBorders>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th>Label</Table.Th>
|
||
<Table.Th>DataKey</Table.Th>
|
||
<Table.Th>DataValue</Table.Th>
|
||
<Table.Th>Комментарий</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{examples.map((ex, i) => (
|
||
<Table.Tr key={i}>
|
||
<Table.Td>{ex.label}</Table.Td>
|
||
<Table.Td><Code>{ex.dataKey}</Code></Table.Td>
|
||
<Table.Td><Code>{ex.dataValue}</Code></Table.Td>
|
||
<Table.Td>{ex.description}</Table.Td>
|
||
</Table.Tr>
|
||
))}
|
||
</Table.Tbody>
|
||
</Table>
|
||
</Box>
|
||
|
||
{/* Подсказка по текущему узлу */}
|
||
{dataKey && dataValue && label && (
|
||
<Alert
|
||
icon={<IconCheck size={16} />}
|
||
color={isDuplicateKey ? 'blue' : 'green'}
|
||
variant="light"
|
||
>
|
||
<Text size="xs">
|
||
{isDuplicateKey ? (
|
||
<>
|
||
💡 Ваш узел похож на существующий пример. Убедитесь, что это именно то,
|
||
что вам нужно.
|
||
</>
|
||
) : (
|
||
<>
|
||
✅ Отлично! Ваш узел <b>"{label}"</b> с{' '}
|
||
<Code>{dataKey}="{dataValue}"</Code> выглядит корректно.
|
||
В шаблонах можно использовать <Code>{`{{.${dataKey}}}`}</Code> и{' '}
|
||
<Code>{`{{.${dataKey}_label}}`}</Code>.
|
||
</>
|
||
)}
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
</Stack>
|
||
</Collapse>
|
||
</Stack>
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/components/DataFlowExplainer.tsx-----
|
||
|
||
File: src/pages/flowNodes/components/FlowNodeEditModal.tsx
|
||
Lines: 833
|
||
-----BEGIN src/pages/flowNodes/components/FlowNodeEditModal.tsx-----
|
||
import { useEffect, useMemo, useState } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Textarea,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Badge,
|
||
Paper,
|
||
Select,
|
||
Code,
|
||
Alert,
|
||
Box,
|
||
Collapse,
|
||
ActionIcon,
|
||
Divider,
|
||
Loader,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
IconAlertCircle,
|
||
IconAlertTriangle,
|
||
IconInfoCircle,
|
||
IconChevronDown,
|
||
IconChevronRight,
|
||
IconWand,
|
||
IconEye,
|
||
IconCircleCheck,
|
||
IconCirclePlus,
|
||
IconPlus,
|
||
} from '@tabler/icons-react'
|
||
import { useCreateFlowNode, useUpdateFlowNode, usePreviewFlow } from '@/features/flowNodes/hooks/useFlowNodes'
|
||
import { useCreateTopic } from '@/features/topics/hooks/useTopics'
|
||
import { useCategory } from '@/features/categories/hooks/useCategories'
|
||
import type { CreateTopicRequest } from '@/api/topics'
|
||
import {
|
||
collectFromPath,
|
||
collectLeafPaths,
|
||
generateDraftMessageTemplate,
|
||
getPathToNode,
|
||
pathLabel,
|
||
findMissingKeysInCodeTemplate,
|
||
buildMissingKeySegment,
|
||
} from '@/features/flowNodes/utils/treeWalk'
|
||
import type { ApprovalFlowNode } from '@/types/api'
|
||
|
||
interface FlowNodeEditModalProps {
|
||
categoryId: number
|
||
tree: ApprovalFlowNode[]
|
||
parentNode: ApprovalFlowNode | null
|
||
editNode: ApprovalFlowNode | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
const NODE_TYPE_OPTIONS = [
|
||
{ value: 'button', label: '🔘 Кнопка — сотрудник нажимает и переходит к следующему вопросу' },
|
||
{ value: 'input', label: '📝 Текстовый ввод — сотрудник пишет заявку своими словами (конец пути)' },
|
||
{ value: 'multiselect', label: '☑️ Можно выбрать несколько вариантов сразу' },
|
||
]
|
||
|
||
const TRANSLIT_MAP: Record<string, string> = {
|
||
а: 'a', б: 'b', в: 'v', г: 'g', д: 'd', е: 'e', ё: 'yo', ж: 'zh', з: 'z', и: 'i', й: 'y',
|
||
к: 'k', л: 'l', м: 'm', н: 'n', о: 'o', п: 'p', р: 'r', с: 's', т: 't', у: 'u', ф: 'f',
|
||
х: 'h', ц: 'ts', ч: 'ch', ш: 'sh', щ: 'sch', ъ: '', ы: 'y', ь: '', э: 'e', ю: 'yu', я: 'ya',
|
||
}
|
||
|
||
function transliterate(text: string): string {
|
||
return text.toLowerCase().split('').map((ch) => TRANSLIT_MAP[ch] ?? ch).join('')
|
||
}
|
||
|
||
function slugify(label: string): string {
|
||
if (!label?.trim()) return ''
|
||
return transliterate(label.trim())
|
||
.replace(/[\s-]+/g, '_')
|
||
.replace(/[^a-z0-9_]/g, '')
|
||
.replace(/_+/g, '_')
|
||
.replace(/^_+|_+$/g, '')
|
||
.substring(0, 50)
|
||
}
|
||
|
||
// Ключ узла попадает в Telegram callback_data ("appr:{код_раздела}:{ключ}"),
|
||
// а у него жёсткий лимит 64 байта на всю строку. Поэтому ключ короче и НЕ
|
||
// собирается из цепочки всех родителей (иначе длина растёт с каждым уровнем
|
||
// вложенности и легко перешагивает лимит на 4-5 шаге — именно так ломался
|
||
// ваш тест: "категория_кнопка1_вложенная1" вышло за 64 байта, Telegram
|
||
// отклонил сообщение целиком, а ошибка нигде не показывалась).
|
||
const KEY_MAX_LEN = 20
|
||
|
||
function shortSlug(label: string): string {
|
||
return slugify(label).substring(0, KEY_MAX_LEN)
|
||
}
|
||
|
||
// Уникальный короткий ключ в пределах категории: если базовый слаг уже
|
||
// занят (например, два узла с одинаковым названием "Вложенная 1" на разных
|
||
// ветках — это нормально и допустимо), добавляем числовой суффикс.
|
||
function uniqueShortKey(label: string, existingKeys: string[], skipKey?: string): string {
|
||
const base = shortSlug(label) || 'shag'
|
||
if (!existingKeys.includes(base) || base === skipKey) return base
|
||
let n = 2
|
||
while (existingKeys.includes(`${base}_${n}`) && `${base}_${n}` !== skipKey) {
|
||
n++
|
||
}
|
||
return `${base}_${n}`
|
||
}
|
||
|
||
function collectAllKeys(nodes: ApprovalFlowNode[]): string[] {
|
||
const keys: string[] = []
|
||
for (const node of nodes) {
|
||
if (node.key) keys.push(node.key)
|
||
if (node.children) keys.push(...collectAllKeys(node.children))
|
||
}
|
||
return keys
|
||
}
|
||
|
||
export default function FlowNodeEditModal({
|
||
categoryId,
|
||
tree,
|
||
parentNode,
|
||
editNode,
|
||
opened,
|
||
onClose,
|
||
}: FlowNodeEditModalProps) {
|
||
const createFlowNode = useCreateFlowNode()
|
||
const updateFlowNode = useUpdateFlowNode()
|
||
const createTopic = useCreateTopic()
|
||
const previewFlow = usePreviewFlow(categoryId)
|
||
const { data: category } = useCategory(categoryId)
|
||
|
||
const [showAdvanced, setShowAdvanced] = useState(false)
|
||
const [showTemplates, setShowTemplates] = useState(false)
|
||
const [previewLeafKey, setPreviewLeafKey] = useState<string | null>(null)
|
||
|
||
const isEditMode = editNode !== null
|
||
// Корень дерева категории — узел без родителя. Только на нём имеют
|
||
// смысл шаблоны сообщения/кода: DynamicTopic на бэкенде читает их
|
||
// ИСКЛЮЧИТЕЛЬНО с узла с parent_id = null (см. approvalflow.NewDynamicTopic).
|
||
const isRootNode = parentNode === null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
key: '',
|
||
label: '',
|
||
nodeType: 'button' as 'button' | 'input' | 'multiselect',
|
||
data_key: '',
|
||
data_value: '',
|
||
input_key: 'content',
|
||
input_hint: '',
|
||
multi_select_key: '',
|
||
multi_select_value: '',
|
||
topic_code: '',
|
||
message_template: '',
|
||
code_template: '',
|
||
auto_generate_key: true,
|
||
},
|
||
validate: {
|
||
key: (v) => {
|
||
if (!v || v.length < 2) return 'Слишком короткий технический ключ'
|
||
if (!/^[a-z0-9_]+$/.test(v)) return 'Только латинские буквы, цифры и подчёркивания'
|
||
if (isRootNode && category?.code && v !== category.code) {
|
||
return 'Подождите загрузку раздела — ключ первого шага подставится сам'
|
||
}
|
||
// "appr:" + код раздела + ":" + ключ уходит в Telegram callback_data,
|
||
// у которого жёсткий лимит 64 байта. 60 вместо 64 — небольшой запас.
|
||
const categoryCodeLen = category?.code?.length || 0
|
||
const callbackLen = 'appr:'.length + categoryCodeLen + 1 + v.length
|
||
if (callbackLen > 60) {
|
||
return `Ключ слишком длинный для Telegram (осталось ${60 - 'appr:'.length - categoryCodeLen - 1} символов) — сократите название`
|
||
}
|
||
const existingKeys = collectAllKeys(tree)
|
||
if (existingKeys.includes(v) && (!editNode || editNode.key !== v)) {
|
||
return 'Такой ключ уже есть в этой категории — измените название'
|
||
}
|
||
return null
|
||
},
|
||
label: (v, values) => {
|
||
// У узла "текстовый ввод" название нигде не показывается
|
||
// сотруднику — бот выводит InputHint, а не Label. Название
|
||
// тут чисто для вашего удобства в конструкторе, необязательно.
|
||
if (values.nodeType === 'input') return null
|
||
return !v || v.length < 1 ? 'Название обязательно' : null
|
||
},
|
||
data_key: (v, values) => {
|
||
// Раньше это была декоративная проверка, которая ничего не
|
||
// блокировала (только жёлтое предупреждение) — из-за этого
|
||
// можно было сохранить кнопку без "что запомнить", и тогда
|
||
// РАЗНЫЕ кнопки на бэкенде дают ОДИНАКОВЫЙ код темы (бот не
|
||
// видит разницы между ними). Теперь это жёсткая проверка.
|
||
if (values.nodeType === 'button' && !v) {
|
||
return 'Обязательно для кнопки — иначе бот не отличит эту кнопку от других, и разные пути могут привести к одной и той же теме'
|
||
}
|
||
return null
|
||
},
|
||
data_value: (v, values) => {
|
||
if (values.nodeType === 'button' && !v) {
|
||
return 'Обязательно для кнопки — у каждой кнопки должно быть своё значение'
|
||
}
|
||
return null
|
||
},
|
||
multi_select_key: (v, values) =>
|
||
values.nodeType === 'multiselect' && !v
|
||
? 'Обязательно для мультивыбора — иначе бот не запомнит выбранные варианты'
|
||
: null,
|
||
multi_select_value: (v, values) =>
|
||
values.nodeType === 'multiselect' && !v
|
||
? 'Обязательно для мультивыбора — у каждого варианта должно быть своё значение'
|
||
: null,
|
||
input_hint: (v, values) =>
|
||
values.nodeType === 'input' && (!v || v.length < 5) ? 'Подсказка должна быть не короче 5 символов' : null,
|
||
},
|
||
})
|
||
|
||
// Ближайшие "братья" (уже существующие соседние кнопки того же родителя) —
|
||
// используем, чтобы подсказать DataKey автоматически: у всех кнопок
|
||
// одного вопроса DataKey обязан совпадать.
|
||
const siblingDataKey = useMemo(() => {
|
||
const siblings = parentNode?.children || (parentNode === null ? [] : [])
|
||
const withKey = siblings.find((s) => s.data_key)
|
||
return withKey?.data_key || ''
|
||
}, [parentNode])
|
||
|
||
const siblingMultiKey = useMemo(() => {
|
||
const siblings = parentNode?.children || []
|
||
const withKey = siblings.find((s) => s.multi_select_key)
|
||
return withKey?.multi_select_key || ''
|
||
}, [parentNode])
|
||
|
||
// Автогенерация ключа из названия — КРОМЕ корневого узла: его ключ
|
||
// ОБЯЗАН совпадать с кодом категории. Причина: когда сотрудник нажимает
|
||
// кнопку раздела в главном меню бота, бот ищет самый первый узел дерева
|
||
// по nodeKey == код категории (см. HandleCallback в telegram_service) —
|
||
// у Topic просто нет отдельного способа узнать реальный ключ корня.
|
||
// Если ключ корня не совпадёт с кодом раздела — бот не найдёт начало
|
||
// дерева и покажет "node not found" в логах, а сотрудник не увидит
|
||
// следующий шаг после нажатия кнопки раздела.
|
||
useEffect(() => {
|
||
if (isRootNode) {
|
||
if (category?.code && form.values.key !== category.code) {
|
||
form.setFieldValue('key', category.code)
|
||
}
|
||
return
|
||
}
|
||
if (form.values.auto_generate_key) {
|
||
// Для текстового ввода название необязательно — если его нет,
|
||
// используем понятный технический суффикс вместо пустого ключа.
|
||
const baseLabel = form.values.label || (form.values.nodeType === 'input' ? 'Текст' : '')
|
||
if (baseLabel) {
|
||
const existingKeys = collectAllKeys(tree)
|
||
const key = uniqueShortKey(baseLabel, existingKeys, editNode?.key)
|
||
if (key !== form.values.key) {
|
||
form.setFieldValue('key', key)
|
||
}
|
||
}
|
||
}
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [form.values.label, form.values.nodeType, form.values.auto_generate_key, isRootNode, category?.code, tree, editNode])
|
||
|
||
// Автоподстановка DataKey/DataValue при смене типа/названия
|
||
useEffect(() => {
|
||
if (form.values.nodeType === 'button') {
|
||
if (!form.values.data_key) form.setFieldValue('data_key', siblingDataKey || '')
|
||
if (!form.values.data_value) form.setFieldValue('data_value', slugify(form.values.label))
|
||
} else if (form.values.nodeType === 'multiselect') {
|
||
if (!form.values.multi_select_key) form.setFieldValue('multi_select_key', siblingMultiKey || '')
|
||
if (!form.values.multi_select_value) form.setFieldValue('multi_select_value', slugify(form.values.label))
|
||
} else if (form.values.nodeType === 'input') {
|
||
if (!form.values.input_key) form.setFieldValue('input_key', 'content')
|
||
}
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [form.values.nodeType, form.values.label, siblingDataKey, siblingMultiKey])
|
||
|
||
// Заполнение формы при редактировании / сброс при создании
|
||
useEffect(() => {
|
||
if (editNode) {
|
||
let nodeType: 'button' | 'input' | 'multiselect' = 'button'
|
||
if (editNode.is_input) nodeType = 'input'
|
||
else if (editNode.is_multi_select) nodeType = 'multiselect'
|
||
|
||
form.setValues({
|
||
key: editNode.key || '',
|
||
label: editNode.label || '',
|
||
nodeType,
|
||
data_key: editNode.data_key || '',
|
||
data_value: editNode.data_value || '',
|
||
input_key: editNode.input_key || 'content',
|
||
input_hint: editNode.input_hint || '',
|
||
multi_select_key: editNode.multi_select_key || '',
|
||
multi_select_value: editNode.multi_select_value || '',
|
||
topic_code: editNode.topic_code || '',
|
||
message_template: editNode.message_template || '',
|
||
code_template: editNode.code_template || '',
|
||
auto_generate_key: false,
|
||
})
|
||
setShowTemplates(!!(editNode.message_template || editNode.code_template))
|
||
setShowAdvanced(!!editNode.topic_code)
|
||
} else {
|
||
form.reset()
|
||
const baseKey = parentNode?.key || ''
|
||
form.setValues({
|
||
key: baseKey ? `${baseKey}_new` : 'new_node',
|
||
label: '',
|
||
nodeType: 'button',
|
||
data_key: '',
|
||
data_value: '',
|
||
input_key: 'content',
|
||
input_hint: '',
|
||
multi_select_key: '',
|
||
multi_select_value: '',
|
||
topic_code: '',
|
||
message_template: '',
|
||
code_template: '',
|
||
auto_generate_key: true,
|
||
})
|
||
setShowTemplates(false)
|
||
setShowAdvanced(false)
|
||
}
|
||
previewFlow.reset()
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [editNode, parentNode, opened])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
const payload = {
|
||
key: values.key,
|
||
// label в БД NOT NULL — если оставили пустым (разрешено только
|
||
// для текстового ввода), подставляем нейтральное значение.
|
||
label: values.label || (values.nodeType === 'input' ? 'Текст' : values.label),
|
||
data_key: values.data_key || null,
|
||
data_value: values.data_value || null,
|
||
is_input: values.nodeType === 'input',
|
||
input_key: values.nodeType === 'input' ? values.input_key : null,
|
||
input_hint: values.nodeType === 'input' ? values.input_hint : null,
|
||
is_multi_select: values.nodeType === 'multiselect',
|
||
multi_select_key: values.nodeType === 'multiselect' ? values.multi_select_key : null,
|
||
multi_select_value: values.nodeType === 'multiselect' ? values.multi_select_value : null,
|
||
topic_code: values.topic_code || null,
|
||
message_template: isRootNode ? values.message_template || null : null,
|
||
code_template: isRootNode ? values.code_template || null : null,
|
||
}
|
||
|
||
if (isEditMode && editNode?.id) {
|
||
await updateFlowNode.mutateAsync({ id: editNode.id, ...payload })
|
||
} else {
|
||
await createFlowNode.mutateAsync({
|
||
category_id: categoryId,
|
||
parent_id: parentNode?.id || null,
|
||
...payload,
|
||
})
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isSubmitting = createFlowNode.isPending || updateFlowNode.isPending
|
||
const nodeType = form.values.nodeType
|
||
|
||
const warnings = useMemo(() => {
|
||
const warns: string[] = []
|
||
if (nodeType === 'button' && !form.values.data_key) {
|
||
warns.push('У кнопки нет «что запомнить» — без этого бот не поймёт, что выбрал сотрudnik. Заполните поля ниже.')
|
||
}
|
||
if (nodeType === 'multiselect' && !form.values.multi_select_key) {
|
||
warns.push('Не заполнено, что запоминать при мультивыборе.')
|
||
}
|
||
return warns
|
||
}, [nodeType, form.values.data_key, form.values.multi_select_key])
|
||
|
||
// ============================================================
|
||
// Черновик пути для предпросмотра (виртуальный узел = текущие
|
||
// значения формы, ещё не сохранённые)
|
||
// ============================================================
|
||
const pathToParent = useMemo(() => {
|
||
if (!parentNode?.id) return []
|
||
return getPathToNode(tree, parentNode.id)
|
||
}, [tree, parentNode])
|
||
|
||
const virtualNode: ApprovalFlowNode = {
|
||
...(editNode || {}),
|
||
data_key: form.values.data_key || undefined,
|
||
data_value: form.values.data_value || undefined,
|
||
multi_select_key: form.values.multi_select_key || undefined,
|
||
multi_select_value: form.values.multi_select_value || undefined,
|
||
is_input: nodeType === 'input',
|
||
} as ApprovalFlowNode
|
||
|
||
const currentPathCollected = useMemo(
|
||
() => collectFromPath([...pathToParent, virtualNode]),
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
[pathToParent, form.values.data_key, form.values.data_value, form.values.multi_select_key, form.values.multi_select_value, nodeType]
|
||
)
|
||
|
||
const handleCheckThisStep = () => {
|
||
previewFlow.mutate({ collected: currentPathCollected })
|
||
}
|
||
|
||
const handleCreateTopicFromPreview = async () => {
|
||
if (!previewFlow.data?.code) return
|
||
// Намеренно НЕ передаём message_template/code_template/is_tree_root на
|
||
// самой теме: боевой код (approvalflow.DynamicTopic) читает шаблоны
|
||
// только с корневого узла дерева, а не с ApprovalTopic — см. FlowNodeEditModal
|
||
// раздел "Сообщение согласующему" (isRootNode). Заполнение этих полей
|
||
// здесь ничего бы не включило и только запутало бы админа.
|
||
const payload: CreateTopicRequest = {
|
||
category_id: categoryId,
|
||
code: previewFlow.data.code,
|
||
name: form.values.label || previewFlow.data.code,
|
||
is_active: true,
|
||
}
|
||
await createTopic.mutateAsync(payload)
|
||
previewFlow.mutate({ collected: currentPathCollected })
|
||
}
|
||
|
||
// ============================================================
|
||
// Для корневого узла: список готовых веток дерева для предпросмотра
|
||
// ============================================================
|
||
const leafOptions = useMemo(() => {
|
||
if (!isRootNode) return []
|
||
return collectLeafPaths(tree).map((path) => ({
|
||
value: path.map((n) => n.id).join('-'),
|
||
label: pathLabel(path),
|
||
collected: collectFromPath(path),
|
||
}))
|
||
}, [isRootNode, tree])
|
||
|
||
// НОВОЕ: автообнаружение "в дереве есть данные, которых нет в шаблоне
|
||
// кода" — то, что раньше приходилось замечать самому и чинить руками
|
||
// (см. случай с filiale Ф1/Ф2, которые не попадали в код темы).
|
||
const missingCodeKeys = useMemo(() => {
|
||
if (!isRootNode || !editNode) return []
|
||
return findMissingKeysInCodeTemplate(editNode, form.values.code_template)
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [isRootNode, editNode, form.values.code_template])
|
||
|
||
const handleAddMissingKey = (key: string) => {
|
||
form.setFieldValue('code_template', (form.values.code_template || '') + buildMissingKeySegment(key))
|
||
}
|
||
|
||
const handleAddAllMissingKeys = () => {
|
||
const addition = missingCodeKeys.map(buildMissingKeySegment).join('')
|
||
form.setFieldValue('code_template', (form.values.code_template || '') + addition)
|
||
}
|
||
|
||
const handleGenerateDraft = () => {
|
||
if (!editNode && !parentNode) return
|
||
const rootForDraft = editNode || { label: form.values.label, children: [] }
|
||
form.setFieldValue('message_template', generateDraftMessageTemplate(rootForDraft as ApprovalFlowNode))
|
||
}
|
||
|
||
const handlePreviewLeaf = (leafKey: string | null) => {
|
||
setPreviewLeafKey(leafKey)
|
||
const option = leafOptions.find((o) => o.value === leafKey)
|
||
if (option) {
|
||
previewFlow.mutate({ collected: option.collected })
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>{isEditMode ? 'Изменить шаг' : 'Новый шаг'}</Text>
|
||
{parentNode && (
|
||
<Badge variant="light" color="gray">
|
||
после: {parentNode.label}
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
{warnings.length > 0 && (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="yellow" variant="light">
|
||
<Stack gap={4}>
|
||
{warnings.map((w, i) => (
|
||
<Text key={i} size="sm">
|
||
⚠️ {w}
|
||
</Text>
|
||
))}
|
||
</Stack>
|
||
</Alert>
|
||
)}
|
||
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">
|
||
1. Тип шага
|
||
</Text>
|
||
<Select
|
||
data={NODE_TYPE_OPTIONS}
|
||
value={form.values.nodeType}
|
||
onChange={(v) => form.setFieldValue('nodeType', (v as any) || 'button')}
|
||
/>
|
||
</Paper>
|
||
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">
|
||
{nodeType === 'input' ? '2. Название шага (для вас, необязательно)' : '2. Что увидит сотрудник'}
|
||
</Text>
|
||
<Stack gap="sm">
|
||
<TextInput
|
||
label="Название"
|
||
placeholder={nodeType === 'input' ? 'Текст' : 'Крым, ТМЦ, В счёт отпуска...'}
|
||
description={
|
||
nodeType === 'input'
|
||
? 'Сотрудник это не видит — бот показывает подсказку из следующего блока. Можно оставить пустым, тогда шаг просто назовётся «Текст»'
|
||
: 'Текст на кнопке (или заголовок вопроса для первого шага)'
|
||
}
|
||
required={nodeType !== 'input'}
|
||
{...form.getInputProps('label')}
|
||
/>
|
||
{isRootNode && (
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="xs">
|
||
Это первый шаг дерева — по нему бот находит начало сценария, когда
|
||
сотрудник нажимает кнопку раздела в главном меню. Технический ключ этого
|
||
шага всегда равен коду раздела:{' '}
|
||
<Code>{category?.code || '…'}</Code> — менять его нельзя, это сделано
|
||
автоматически.
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{(nodeType === 'button' || nodeType === 'multiselect') && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">
|
||
3. Что запомнить при нажатии
|
||
</Text>
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light" mb="sm">
|
||
<Text size="xs">
|
||
Если у этого вопроса уже есть другие варианты ответа — поле «что запомнить» уже
|
||
подставлено само (оно должно быть одинаковым у всех кнопок одного вопроса).
|
||
Меняйте только «значение» — оно у каждой кнопки своё.
|
||
</Text>
|
||
<Text size="xs" mt={4}>
|
||
«Название» этой кнопки (из блока выше) — это то, что покажется согласующему
|
||
в сообщении, если в шаблоне используется <Code>{`{{.${form.values.data_key || 'ключ'}_label}}`}</Code>.
|
||
Переименуете кнопку — текст сообщения обновится сам, без правки шаблона.
|
||
</Text>
|
||
</Alert>
|
||
{nodeType === 'button' ? (
|
||
<Group gap="sm" align="end">
|
||
<TextInput
|
||
label="Что запомнить (например: регион)"
|
||
style={{ flex: 1 }}
|
||
{...form.getInputProps('data_key')}
|
||
/>
|
||
<TextInput
|
||
label="Значение этой кнопки (например: crimea)"
|
||
style={{ flex: 1 }}
|
||
{...form.getInputProps('data_value')}
|
||
/>
|
||
</Group>
|
||
) : (
|
||
<Group gap="sm" align="end">
|
||
<TextInput
|
||
label="Что запомнить (например: системы)"
|
||
style={{ flex: 1 }}
|
||
{...form.getInputProps('multi_select_key')}
|
||
/>
|
||
<TextInput
|
||
label="Значение этого варианта"
|
||
style={{ flex: 1 }}
|
||
{...form.getInputProps('multi_select_value')}
|
||
/>
|
||
</Group>
|
||
)}
|
||
</Paper>
|
||
)}
|
||
|
||
{nodeType === 'input' && (
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">
|
||
3. Подсказка для сотрудника
|
||
</Text>
|
||
<Textarea
|
||
label="Пример того, что нужно написать"
|
||
placeholder="Опишите изменения: текущие данные → новые данные"
|
||
minRows={3}
|
||
required
|
||
{...form.getInputProps('input_hint')}
|
||
/>
|
||
</Paper>
|
||
)}
|
||
|
||
{/* Живой предпросмотр этого конкретного шага — только там, где уже
|
||
можно посчитать код (обычно на текстовом вводе, но доступно и раньше) */}
|
||
<Paper withBorder p="md" bg="gray.0">
|
||
<Group justify="space-between" mb="xs">
|
||
<Text size="sm" fw={600}>
|
||
Проверка: что получится на этом пути
|
||
</Text>
|
||
<Button
|
||
size="xs"
|
||
variant="light"
|
||
leftSection={<IconEye size={14} />}
|
||
onClick={handleCheckThisStep}
|
||
loading={previewFlow.isPending}
|
||
>
|
||
Проверить
|
||
</Button>
|
||
</Group>
|
||
{previewFlow.data && (
|
||
<Stack gap={6}>
|
||
{previewFlow.data.incomplete ? (
|
||
<Text size="xs" c="dimmed">
|
||
Пока не хватает выборов на предыдущих шагах, чтобы определить тему заявки —
|
||
это нормально, если вы ещё не дошли до конца ветки.
|
||
</Text>
|
||
) : (
|
||
<>
|
||
<Text size="xs">
|
||
Код темы: <Code>{previewFlow.data.code}</Code>
|
||
</Text>
|
||
{previewFlow.data.topic_exists ? (
|
||
<Group gap={4}>
|
||
<IconCircleCheck size={14} color="var(--mantine-color-teal-6)" />
|
||
<Text size="xs" c="teal">
|
||
Такая тема уже настроена в системе ({previewFlow.data.topic_name})
|
||
</Text>
|
||
</Group>
|
||
) : (
|
||
<Group gap="xs">
|
||
<Text size="xs" c="orange">
|
||
⚠️ Темы с таким кодом пока нет — без неё бот не сможет отправить
|
||
заявку согласующим.
|
||
</Text>
|
||
<Button
|
||
size="compact-xs"
|
||
leftSection={<IconCirclePlus size={12} />}
|
||
onClick={handleCreateTopicFromPreview}
|
||
loading={createTopic.isPending}
|
||
>
|
||
Создать тему
|
||
</Button>
|
||
</Group>
|
||
)}
|
||
<Divider my={4} />
|
||
<Text size="xs" fw={600}>
|
||
Так будет выглядеть сообщение согласующему:
|
||
</Text>
|
||
<Paper withBorder p={6} bg="white">
|
||
<Text size="xs" style={{ whiteSpace: 'pre-wrap' }}>
|
||
{previewFlow.data.message}
|
||
</Text>
|
||
</Paper>
|
||
</>
|
||
)}
|
||
</Stack>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* Дополнительно: технический ключ + код проверки прав */}
|
||
<Paper withBorder p="md">
|
||
<Group
|
||
justify="space-between"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => setShowAdvanced(!showAdvanced)}
|
||
>
|
||
<Group gap="xs">
|
||
{showAdvanced ? <IconChevronDown size={16} /> : <IconChevronRight size={16} />}
|
||
<Text size="sm" fw={600}>
|
||
Дополнительно (обычно не нужно трогать)
|
||
</Text>
|
||
</Group>
|
||
</Group>
|
||
<Collapse expanded={showAdvanced}>
|
||
<Stack gap="sm" mt="sm">
|
||
<TextInput
|
||
label="Технический ключ"
|
||
description={
|
||
isRootNode
|
||
? 'Всегда равен коду раздела — не редактируется'
|
||
: 'Заполняется само из названия'
|
||
}
|
||
disabled={isRootNode || form.values.auto_generate_key}
|
||
{...form.getInputProps('key')}
|
||
/>
|
||
<TextInput
|
||
label="Кто видит эту кнопку (необязательно)"
|
||
placeholder="non_budget_f1"
|
||
description={
|
||
<Text size="xs">
|
||
Если заполнить — эту конкретную кнопку увидят только сотрудники, у
|
||
которых есть право на такую тему. Не влияет на то, в какую тему попадёт
|
||
заявка — код темы считается автоматически по всем ответам сотрудника.
|
||
</Text>
|
||
}
|
||
{...form.getInputProps('topic_code')}
|
||
/>
|
||
{nodeType === 'input' && (
|
||
<TextInput
|
||
label="Куда сохранить введённый текст"
|
||
description="Обычно content — меняйте, только если знаете зачем"
|
||
{...form.getInputProps('input_key')}
|
||
/>
|
||
)}
|
||
</Stack>
|
||
</Collapse>
|
||
</Paper>
|
||
|
||
{/* Шаблоны — ТОЛЬКО на корневом узле дерева */}
|
||
{isRootNode && (
|
||
<Paper withBorder p="md">
|
||
<Group
|
||
justify="space-between"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => setShowTemplates(!showTemplates)}
|
||
>
|
||
<Group gap="xs">
|
||
{showTemplates ? <IconChevronDown size={16} /> : <IconChevronRight size={16} />}
|
||
<Text size="sm" fw={600}>
|
||
Сообщение согласующему и код темы
|
||
</Text>
|
||
</Group>
|
||
</Group>
|
||
<Collapse expanded={showTemplates}>
|
||
<Stack gap="sm" mt="sm">
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="xs">
|
||
Это ОДНО сообщение на всё дерево этого раздела, а не на одну ветку.
|
||
Чтобы текст отличался в зависимости от выбора сотрудника — используйте
|
||
условия (кнопка ниже сама расставит их за вас на основе первого вопроса
|
||
в дереве, дальше можно поправить руками).
|
||
</Text>
|
||
</Alert>
|
||
|
||
<Group justify="flex-end">
|
||
<Button
|
||
size="xs"
|
||
variant="light"
|
||
leftSection={<IconWand size={14} />}
|
||
onClick={handleGenerateDraft}
|
||
>
|
||
Сформировать черновик
|
||
</Button>
|
||
</Group>
|
||
|
||
<Textarea
|
||
label="Текст сообщения согласующему"
|
||
minRows={6}
|
||
styles={{ input: { fontFamily: 'monospace', fontSize: 12 } }}
|
||
{...form.getInputProps('message_template')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Код темы (обычно оставляйте пустым)"
|
||
description="Если не трогать — система сама соберёт код из всех выборов сотрудника"
|
||
minRows={2}
|
||
styles={{ input: { fontFamily: 'monospace', fontSize: 12 } }}
|
||
{...form.getInputProps('code_template')}
|
||
/>
|
||
|
||
{missingCodeKeys.length > 0 && (
|
||
<Alert icon={<IconAlertTriangle size={16} />} color="orange" variant="light">
|
||
<Stack gap={6}>
|
||
<Text size="xs">
|
||
В дереве есть шаги, запоминающие данные, которых нет в шаблоне
|
||
кода выше — темы для таких веток могут случайно совпасть с
|
||
другими (бот их не различит):
|
||
</Text>
|
||
<Group gap={6}>
|
||
{missingCodeKeys.map((key) => (
|
||
<Badge
|
||
key={key}
|
||
variant="light"
|
||
color="orange"
|
||
style={{ cursor: 'pointer' }}
|
||
rightSection={<IconPlus size={10} />}
|
||
onClick={() => handleAddMissingKey(key)}
|
||
>
|
||
{key}
|
||
</Badge>
|
||
))}
|
||
</Group>
|
||
{missingCodeKeys.length > 1 && (
|
||
<Button
|
||
size="compact-xs"
|
||
variant="light"
|
||
color="orange"
|
||
onClick={handleAddAllMissingKeys}
|
||
>
|
||
Добавить все в шаблон
|
||
</Button>
|
||
)}
|
||
</Stack>
|
||
</Alert>
|
||
)}
|
||
|
||
{leafOptions.length > 0 && (
|
||
<>
|
||
<Divider label="Проверить готовую ветку" />
|
||
<Select
|
||
placeholder="Выберите путь для проверки"
|
||
data={leafOptions.map((o) => ({ value: o.value, label: o.label }))}
|
||
value={previewLeafKey}
|
||
onChange={handlePreviewLeaf}
|
||
searchable
|
||
/>
|
||
{previewFlow.isPending && <Loader size="xs" />}
|
||
{previewFlow.data && !previewFlow.data.incomplete && (
|
||
<Paper withBorder p={6} bg="white">
|
||
<Text size="xs" c="dimmed">
|
||
Код: <Code>{previewFlow.data.code}</Code>
|
||
</Text>
|
||
<Text size="xs" mt={4} style={{ whiteSpace: 'pre-wrap' }}>
|
||
{previewFlow.data.message}
|
||
</Text>
|
||
</Paper>
|
||
)}
|
||
</>
|
||
)}
|
||
</Stack>
|
||
</Collapse>
|
||
</Paper>
|
||
)}
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/components/FlowNodeEditModal.tsx-----
|
||
|
||
File: src/pages/flowNodes/components/SortableFlowTree.tsx
|
||
Lines: 268
|
||
-----BEGIN src/pages/flowNodes/components/SortableFlowTree.tsx-----
|
||
import { useMemo, useState } from 'react'
|
||
import {
|
||
DndContext,
|
||
DragOverlay,
|
||
PointerSensor,
|
||
useSensor,
|
||
useSensors,
|
||
closestCenter,
|
||
type DragStartEvent,
|
||
type DragMoveEvent,
|
||
type DragOverEvent,
|
||
type DragEndEvent,
|
||
} from '@dnd-kit/core'
|
||
import { SortableContext, verticalListSortingStrategy, useSortable } from '@dnd-kit/sortable'
|
||
import { CSS } from '@dnd-kit/utilities'
|
||
import { Paper, Group, Text, ActionIcon, Tooltip, Badge, Box, Alert } from '@mantine/core'
|
||
import {
|
||
IconGripVertical,
|
||
IconPlus,
|
||
IconEdit,
|
||
IconTrash,
|
||
IconCopy,
|
||
IconChevronDown,
|
||
IconChevronRight,
|
||
IconArrowsMove,
|
||
} from '@tabler/icons-react'
|
||
import type { ApprovalFlowNode } from '@/types/api'
|
||
import { useReorderNodes } from '@/features/flowNodes/hooks/useFlowNodes'
|
||
import {buildReorderPlan, FlatFlowNode, flattenTree, getProjection} from "@/features/flowNodes/utils/flattenTree.ts";
|
||
|
||
const INDENTATION = 24
|
||
|
||
interface SortableFlowTreeProps {
|
||
tree: ApprovalFlowNode[]
|
||
onEdit: (node: ApprovalFlowNode) => void
|
||
onAddChild: (parent: ApprovalFlowNode) => void
|
||
onDelete: (node: ApprovalFlowNode) => void
|
||
onDuplicate: (node: ApprovalFlowNode) => void
|
||
}
|
||
|
||
function nodeIcon(node: ApprovalFlowNode): string {
|
||
if (node.is_input) return '📝'
|
||
if (node.is_multi_select) return '☑️'
|
||
return '🔘'
|
||
}
|
||
|
||
function nodeKindLabel(node: ApprovalFlowNode): string {
|
||
if (node.is_input) return 'Текстовый ввод — здесь сотрудник пишет заявку'
|
||
if (node.is_multi_select) return 'Можно выбрать несколько вариантов'
|
||
return 'Кнопка'
|
||
}
|
||
|
||
export default function SortableFlowTree({ tree, onEdit, onAddChild, onDelete, onDuplicate }: SortableFlowTreeProps) {
|
||
const [collapsed, setCollapsed] = useState<Set<number>>(new Set())
|
||
const [activeId, setActiveId] = useState<number | null>(null)
|
||
const [overId, setOverId] = useState<number | null>(null)
|
||
const [offsetX, setOffsetX] = useState(0)
|
||
const reorder = useReorderNodes()
|
||
|
||
const flatItems = useMemo(() => flattenTree(tree, collapsed), [tree, collapsed])
|
||
const sortableIds = useMemo(() => flatItems.map((n) => n.id!), [flatItems])
|
||
|
||
const sensors = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }))
|
||
|
||
const projected = useMemo(() => {
|
||
if (activeId == null || overId == null) return null
|
||
return getProjection(flatItems, activeId, overId, offsetX, INDENTATION)
|
||
}, [flatItems, activeId, overId, offsetX])
|
||
|
||
const activeNode = flatItems.find((n) => n.id === activeId) || null
|
||
const projectedParentLabel = projected
|
||
? flatItems.find((n) => n.id === projected.parentId)?.label || null
|
||
: null
|
||
|
||
const toggleCollapse = (id: number) => {
|
||
setCollapsed((prev) => {
|
||
const next = new Set(prev)
|
||
if (next.has(id)) next.delete(id)
|
||
else next.add(id)
|
||
return next
|
||
})
|
||
}
|
||
|
||
const handleDragStart = (event: DragStartEvent) => {
|
||
setActiveId(event.active.id as number)
|
||
setOverId(event.active.id as number)
|
||
setOffsetX(0)
|
||
}
|
||
|
||
const handleDragMove = (event: DragMoveEvent) => {
|
||
setOffsetX(event.delta.x)
|
||
}
|
||
|
||
const handleDragOver = (event: DragOverEvent) => {
|
||
setOverId((event.over?.id as number) ?? null)
|
||
}
|
||
|
||
const handleDragEnd = (event: DragEndEvent) => {
|
||
const { active, over } = event
|
||
const currentProjected = projected
|
||
|
||
setActiveId(null)
|
||
setOverId(null)
|
||
setOffsetX(0)
|
||
|
||
if (!over || !currentProjected) return
|
||
|
||
const activeIdNum = active.id as number
|
||
const overIdNum = over.id as number
|
||
const activeNodeBefore = flatItems.find((n) => n.id === activeIdNum)
|
||
if (!activeNodeBefore) return
|
||
|
||
const noParentChange = (activeNodeBefore.parent_id ?? null) === currentProjected.parentId
|
||
const droppedOnSelf = activeIdNum === overIdNum
|
||
if (noParentChange && droppedOnSelf) return
|
||
|
||
const ops = buildReorderPlan(tree, activeIdNum, currentProjected.parentId, overIdNum)
|
||
if (ops.length > 0) {
|
||
reorder.mutate(ops)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<DndContext
|
||
sensors={sensors}
|
||
collisionDetection={closestCenter}
|
||
onDragStart={handleDragStart}
|
||
onDragMove={handleDragMove}
|
||
onDragOver={handleDragOver}
|
||
onDragEnd={handleDragEnd}
|
||
>
|
||
{activeNode && (
|
||
<Alert color="blue" variant="light" mb={6} icon={<IconArrowsMove size={16} />}>
|
||
<Text size="xs">
|
||
«{activeNode.label}» станет шагом внутри «{projectedParentLabel || '…'}» — потяните влево/вправо,
|
||
чтобы поменять уровень вложенности
|
||
</Text>
|
||
</Alert>
|
||
)}
|
||
<SortableContext items={sortableIds} strategy={verticalListSortingStrategy}>
|
||
<Box>
|
||
{flatItems.map((node) => (
|
||
<SortableRow
|
||
key={node.id}
|
||
node={node}
|
||
hasChildren={!!node.children?.length}
|
||
collapsed={node.id != null && collapsed.has(node.id)}
|
||
onToggleCollapse={() => node.id != null && toggleCollapse(node.id)}
|
||
onEdit={onEdit}
|
||
onAddChild={onAddChild}
|
||
onDelete={onDelete}
|
||
onDuplicate={onDuplicate}
|
||
/>
|
||
))}
|
||
</Box>
|
||
</SortableContext>
|
||
<DragOverlay>
|
||
{activeNode ? (
|
||
<Paper withBorder p="xs" shadow="md">
|
||
<Group gap={6}>
|
||
<IconGripVertical size={14} />
|
||
<Text size="lg">{nodeIcon(activeNode)}</Text>
|
||
<Text fw={600}>{activeNode.label}</Text>
|
||
</Group>
|
||
</Paper>
|
||
) : null}
|
||
</DragOverlay>
|
||
</DndContext>
|
||
)
|
||
}
|
||
|
||
interface SortableRowProps {
|
||
node: FlatFlowNode
|
||
hasChildren: boolean
|
||
collapsed: boolean
|
||
onToggleCollapse: () => void
|
||
onEdit: (node: ApprovalFlowNode) => void
|
||
onAddChild: (parent: ApprovalFlowNode) => void
|
||
onDelete: (node: ApprovalFlowNode) => void
|
||
onDuplicate: (node: ApprovalFlowNode) => void
|
||
}
|
||
|
||
function SortableRow({ node, hasChildren, collapsed, onToggleCollapse, onEdit, onAddChild, onDelete, onDuplicate }: SortableRowProps) {
|
||
const isRoot = node.depth === 0
|
||
const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
|
||
id: node.id!,
|
||
disabled: isRoot, // корень дерева не перетаскивается — его ключ жёстко привязан к коду раздела
|
||
})
|
||
|
||
const style = {
|
||
transform: CSS.Translate.toString(transform),
|
||
transition,
|
||
marginLeft: node.depth * INDENTATION,
|
||
opacity: isDragging ? 0.4 : 1,
|
||
}
|
||
|
||
return (
|
||
<div ref={setNodeRef} style={style}>
|
||
<Paper withBorder p="xs" mb={4} bg={isRoot ? 'var(--mantine-color-blue-0)' : undefined}>
|
||
<Group justify="space-between" wrap="nowrap">
|
||
<Group gap={6} wrap="nowrap" style={{ minWidth: 0 }}>
|
||
{!isRoot ? (
|
||
<ActionIcon
|
||
variant="subtle"
|
||
size="sm"
|
||
{...attributes}
|
||
{...listeners}
|
||
style={{ cursor: 'grab', touchAction: 'none' }}
|
||
>
|
||
<IconGripVertical size={14} />
|
||
</ActionIcon>
|
||
) : (
|
||
<Tooltip label="Первый шаг дерева нельзя перемещать">
|
||
<Box w={28} />
|
||
</Tooltip>
|
||
)}
|
||
{hasChildren ? (
|
||
<ActionIcon size="sm" variant="subtle" onClick={onToggleCollapse}>
|
||
{collapsed ? <IconChevronRight size={14} /> : <IconChevronDown size={14} />}
|
||
</ActionIcon>
|
||
) : (
|
||
<Box w={22} />
|
||
)}
|
||
<Text size="lg">{nodeIcon(node)}</Text>
|
||
<Box style={{ minWidth: 0 }}>
|
||
<Group gap={6}>
|
||
<Text fw={600} truncate>
|
||
{node.label}
|
||
</Text>
|
||
{isRoot && (
|
||
<Badge size="xs" color="blue" variant="light">
|
||
начало дерева
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
<Text size="xs" c="dimmed">
|
||
{nodeKindLabel(node)}
|
||
{node.data_key ? ` · запоминает: ${node.data_key} = ${node.data_value}` : ''}
|
||
</Text>
|
||
</Box>
|
||
</Group>
|
||
|
||
<Group gap={2} wrap="nowrap">
|
||
<Tooltip label="Добавить следующий шаг после этой кнопки">
|
||
<ActionIcon variant="subtle" size="sm" color="blue" onClick={() => onAddChild(node)}>
|
||
<IconPlus size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Изменить">
|
||
<ActionIcon variant="subtle" size="sm" onClick={() => onEdit(node)}>
|
||
<IconEdit size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Сделать копию этого шага со всеми вложенными">
|
||
<ActionIcon variant="subtle" size="sm" onClick={() => onDuplicate(node)}>
|
||
<IconCopy size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить (вместе со всеми вложенными шагами)">
|
||
<ActionIcon variant="subtle" size="sm" color="red" onClick={() => onDelete(node)}>
|
||
<IconTrash size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Group>
|
||
</Paper>
|
||
</div>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/components/SortableFlowTree.tsx-----
|
||
|
||
File: src/pages/flowNodes/components/TreeHealthPanel.tsx
|
||
Lines: 151
|
||
-----BEGIN src/pages/flowNodes/components/TreeHealthPanel.tsx-----
|
||
import { useState } from 'react'
|
||
import { Paper, Group, Text, Button, Table, Badge, Loader, Alert } from '@mantine/core'
|
||
import { IconStethoscope, IconInfoCircle, IconCirclePlus } from '@tabler/icons-react'
|
||
import { flowNodesApi, type PreviewFlowResponse } from '@/api/flowNodes'
|
||
import { useCreateTopic } from '@/features/topics/hooks/useTopics'
|
||
import type { CreateTopicRequest } from '@/api/topics'
|
||
import { collectFromPath, collectLeafPaths, pathLabel } from '@/features/flowNodes/utils/treeWalk'
|
||
import type { ApprovalFlowNode } from '@/types/api'
|
||
|
||
interface TreeHealthPanelProps {
|
||
categoryId: number
|
||
tree: ApprovalFlowNode[]
|
||
}
|
||
|
||
interface HealthRow {
|
||
key: string
|
||
label: string
|
||
result: PreviewFlowResponse | null
|
||
error?: boolean
|
||
}
|
||
|
||
// Проходит по каждой готовой ветке дерева ("от начала до текстового ввода")
|
||
// и проверяет через реальный движок бэкенда, есть ли для неё настроенная
|
||
// тема. Так администратор видит проблему ДО того, как сотрудник наткнётся
|
||
// на неё в боте — а не после жалобы, что "заявка не отправляется".
|
||
export default function TreeHealthPanel({ categoryId, tree }: TreeHealthPanelProps) {
|
||
const [rows, setRows] = useState<HealthRow[] | null>(null)
|
||
const [checking, setChecking] = useState(false)
|
||
const createTopic = useCreateTopic()
|
||
|
||
const runCheck = async () => {
|
||
setChecking(true)
|
||
const leafPaths = collectLeafPaths(tree)
|
||
const results = await Promise.all(
|
||
leafPaths.map(async (path) => {
|
||
const key = path.map((n) => n.id).join('-')
|
||
const label = pathLabel(path)
|
||
try {
|
||
const response = await flowNodesApi.preview(categoryId, {
|
||
collected: collectFromPath(path),
|
||
})
|
||
return { key, label, result: response.data } as HealthRow
|
||
} catch {
|
||
return { key, label, result: null, error: true } as HealthRow
|
||
}
|
||
})
|
||
)
|
||
setRows(results)
|
||
setChecking(false)
|
||
}
|
||
|
||
const handleCreateTopic = async (row: HealthRow) => {
|
||
if (!row.result?.code) return
|
||
const payload: CreateTopicRequest = {
|
||
category_id: categoryId,
|
||
code: row.result.code,
|
||
name: row.label,
|
||
is_active: true,
|
||
}
|
||
await createTopic.mutateAsync(payload)
|
||
runCheck()
|
||
}
|
||
|
||
const missingCount = rows?.filter((r) => r.result && !r.result.incomplete && !r.result.topic_exists).length || 0
|
||
|
||
return (
|
||
<Paper withBorder p="md">
|
||
<Group justify="space-between" mb="sm">
|
||
<Text fw={600}>Проверка дерева</Text>
|
||
<Button
|
||
size="xs"
|
||
variant="light"
|
||
leftSection={<IconStethoscope size={14} />}
|
||
onClick={runCheck}
|
||
loading={checking}
|
||
>
|
||
Проверить все ветки
|
||
</Button>
|
||
</Group>
|
||
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light" mb="sm">
|
||
<Text size="xs">
|
||
Пройдёт по каждому возможному пути в дереве и проверит, для всех ли есть настроенная тема
|
||
заявки. Если для какого-то пути темы нет — заявку по нему бот не сможет отправить.
|
||
</Text>
|
||
</Alert>
|
||
|
||
{rows && missingCount > 0 && (
|
||
<Alert color="orange" variant="light" mb="sm">
|
||
<Text size="sm">Не хватает тем для {missingCount} путей — см. таблицу ниже.</Text>
|
||
</Alert>
|
||
)}
|
||
{rows && missingCount === 0 && (
|
||
<Alert color="teal" variant="light" mb="sm">
|
||
<Text size="sm">Все ветки дерева ведут к настроенным темам ✅</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
{checking && <Loader size="sm" />}
|
||
|
||
{rows && (
|
||
<Table striped withTableBorder>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th>Путь</Table.Th>
|
||
<Table.Th>Код темы</Table.Th>
|
||
<Table.Th>Статус</Table.Th>
|
||
<Table.Th />
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{rows.map((row) => (
|
||
<Table.Tr key={row.key}>
|
||
<Table.Td>
|
||
<Text size="xs">{row.label}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="xs" ff="monospace">
|
||
{row.result?.code || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
{row.error ? (
|
||
<Badge color="red">Ошибка проверки</Badge>
|
||
) : row.result?.incomplete ? (
|
||
<Badge color="gray">Путь не завершён</Badge>
|
||
) : row.result?.topic_exists ? (
|
||
<Badge color="teal">Есть тема</Badge>
|
||
) : (
|
||
<Badge color="orange">Темы нет</Badge>
|
||
)}
|
||
</Table.Td>
|
||
<Table.Td>
|
||
{row.result && !row.result.incomplete && !row.result.topic_exists && (
|
||
<Button
|
||
size="compact-xs"
|
||
leftSection={<IconCirclePlus size={12} />}
|
||
onClick={() => handleCreateTopic(row)}
|
||
loading={createTopic.isPending}
|
||
>
|
||
Создать
|
||
</Button>
|
||
)}
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))}
|
||
</Table.Tbody>
|
||
</Table>
|
||
)}
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/flowNodes/components/TreeHealthPanel.tsx-----
|
||
|
||
File: src/pages/hierarchies/HierarchiesPage.tsx
|
||
Lines: 631
|
||
-----BEGIN src/pages/hierarchies/HierarchiesPage.tsx-----
|
||
import { useState, useMemo } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
Select,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
SegmentedControl,
|
||
Badge,
|
||
Alert,
|
||
ScrollArea,
|
||
Pagination,
|
||
Checkbox,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconPencil,
|
||
IconTrash,
|
||
IconPlus,
|
||
IconInfoCircle,
|
||
IconUsers,
|
||
} from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { notifications } from '@mantine/notifications'
|
||
import {
|
||
useHierarchies,
|
||
useDeleteHierarchy,
|
||
useUpdateHierarchy, HIERARCHIES_QUERY_KEY,
|
||
} from '@/features/hierarchies/hooks/useHierarchies'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useDepartments } from '@/features/departments/hooks/useDepartments'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import {
|
||
groupHierarchiesIntoChains,
|
||
SCOPE_COLORS,
|
||
SCOPE_LABELS,
|
||
type ChainGroup,
|
||
} from '@/features/hierarchies/utils'
|
||
import ChainVisualization from './components/ChainVisualization'
|
||
import ChainDuplicateModal from './components/ChainDuplicateModal'
|
||
import HierarchyEditModal from './components/HierarchyEditModal'
|
||
import PersonDuplicateModal from './components/PersonDuplicateModal'
|
||
import type { UserHierarchy } from '@/types/api'
|
||
import { hierarchiesApi } from '@/api/hierarchies'
|
||
import { useQueryClient } from '@tanstack/react-query'
|
||
|
||
const LIMIT = 20
|
||
|
||
type ViewMode = 'chains' | 'table'
|
||
|
||
export default function HierarchiesPage() {
|
||
const [viewMode, setViewMode] = useState<ViewMode>('chains')
|
||
const [page, setPage] = useState(1)
|
||
|
||
// Фильтры
|
||
const [subordinateFilter, setSubordinateFilter] = useState<string | null>(null)
|
||
const [departmentFilter, setDepartmentFilter] = useState<string | null>(null)
|
||
const [categoryFilter, setCategoryFilter] = useState<string | null>(null)
|
||
const [topicFilter, setTopicFilter] = useState<string | null>(null)
|
||
|
||
// Массовое удаление
|
||
const [selectedIds, setSelectedIds] = useState<number[]>([])
|
||
const [isDeleting, setIsDeleting] = useState(false)
|
||
|
||
// Модалки
|
||
const [editHierarchy, setEditHierarchy] = useState<UserHierarchy | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
const [presetGroup, setPresetGroup] = useState<ChainGroup | null>(null)
|
||
const [duplicateGroup, setDuplicateGroup] = useState<ChainGroup | null>(null)
|
||
const [duplicateModalOpened, setDuplicateModalOpened] = useState(false)
|
||
const [personDuplicateOpened, setPersonDuplicateOpened] = useState(false)
|
||
|
||
const { data: categoryTopics } = useTopics({
|
||
limit: 1000,
|
||
...(categoryFilter && { category_id: Number(categoryFilter) }),
|
||
})
|
||
|
||
const { data, isLoading, isFetching } = useHierarchies({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(subordinateFilter && { subordinate_id: Number(subordinateFilter) }),
|
||
...(departmentFilter && { department_id: Number(departmentFilter) }),
|
||
...(categoryFilter && { topic_category_id: Number(categoryFilter) }),
|
||
...(topicFilter && { topic_id: Number(topicFilter) }),
|
||
})
|
||
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const { data: departments } = useDepartments()
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
const { data: topics } = useTopics({ limit: 1000 })
|
||
|
||
const deleteHierarchy = useDeleteHierarchy()
|
||
const updateHierarchy = useUpdateHierarchy()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const chains = useMemo(() => {
|
||
if (!data?.data) return []
|
||
return groupHierarchiesIntoChains(data.data)
|
||
}, [data])
|
||
|
||
const enrichedChains = useMemo(() => {
|
||
return chains.map((chain) => {
|
||
let scopeObjectName = 'Все темы'
|
||
if (chain.scopeType === 'category' && chain.scopeObjectId) {
|
||
const cat = categories?.data?.find((c) => c.id === chain.scopeObjectId)
|
||
scopeObjectName = cat?.name || `Категория #${chain.scopeObjectId}`
|
||
} else if (chain.scopeType === 'topic' && chain.scopeObjectId) {
|
||
const topic = topics?.data?.find((t) => t.id === chain.scopeObjectId)
|
||
scopeObjectName = topic?.name || `Тема #${chain.scopeObjectId}`
|
||
}
|
||
return { ...chain, scopeObjectName }
|
||
})
|
||
}, [chains, categories, topics])
|
||
|
||
const userOptions =
|
||
users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || `Пользователь #${u.id}`,
|
||
})) || []
|
||
|
||
const departmentOptions =
|
||
departments?.data?.map((d) => ({
|
||
value: String(d.id),
|
||
label: d.name || '',
|
||
})) || []
|
||
|
||
const categoryOptions =
|
||
categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const topicOptions =
|
||
(categoryFilter ? categoryTopics?.data : topics?.data)?.map((t) => ({
|
||
value: String(t.id),
|
||
label: t.name || '',
|
||
})) || []
|
||
|
||
const handleSelectAll = () => {
|
||
if (selectedIds.length === data?.data?.length) {
|
||
setSelectedIds([])
|
||
} else {
|
||
setSelectedIds(data?.data?.map((h) => h.id!) || [])
|
||
}
|
||
}
|
||
|
||
const handleSelectOne = (id: number) => {
|
||
setSelectedIds((prev) =>
|
||
prev.includes(id) ? prev.filter((x) => x !== id) : [...prev, id]
|
||
)
|
||
}
|
||
|
||
const handleFilterChange =
|
||
(setter: (value: string | null) => void) => (value: string | null) => {
|
||
setter(value)
|
||
setPage(1)
|
||
setSelectedIds([])
|
||
}
|
||
|
||
const queryClient = useQueryClient()
|
||
|
||
const handleBulkDelete = () => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите массовое удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить <strong>{selectedIds.length}</strong>{' '}
|
||
записей? Это действие необратимо.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить все', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red', loading: isDeleting },
|
||
onConfirm: async () => {
|
||
setIsDeleting(true)
|
||
try {
|
||
// Удаляем напрямую через API, не вызывая мутацию поштучно
|
||
await Promise.all(selectedIds.map((id) => hierarchiesApi.delete(id)))
|
||
|
||
// Обновляем список один раз
|
||
queryClient.invalidateQueries({ queryKey: [HIERARCHIES_QUERY_KEY] })
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: `Успешно удалено записей: ${selectedIds.length}`,
|
||
color: 'green',
|
||
})
|
||
setSelectedIds([])
|
||
} catch (error) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Не удалось удалить некоторые записи',
|
||
color: 'red',
|
||
})
|
||
} finally {
|
||
setIsDeleting(false)
|
||
}
|
||
},
|
||
})
|
||
}
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить эту связь?
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: async () => {
|
||
await deleteHierarchy.mutateAsync(id)
|
||
},
|
||
})
|
||
}
|
||
|
||
const handleEditStep = (id: number) => {
|
||
const hierarchy = data?.data?.find((h) => h.id === id)
|
||
if (hierarchy) {
|
||
setEditHierarchy(hierarchy)
|
||
}
|
||
}
|
||
|
||
const handleAddStep = (group: ChainGroup) => {
|
||
setPresetGroup(group)
|
||
setCreateModalOpened(true)
|
||
}
|
||
|
||
const handleDuplicateChain = (group: ChainGroup) => {
|
||
setDuplicateGroup(group)
|
||
setDuplicateModalOpened(true)
|
||
}
|
||
|
||
const handleCloseModal = () => {
|
||
setEditHierarchy(null)
|
||
setCreateModalOpened(false)
|
||
setPresetGroup(null)
|
||
}
|
||
|
||
const handleCloseDuplicateModal = () => {
|
||
setDuplicateGroup(null)
|
||
setDuplicateModalOpened(false)
|
||
}
|
||
|
||
const isAllSelected =
|
||
(data?.data?.length ?? 0) > 0 && selectedIds.length === (data?.data?.length ?? 0)
|
||
const isIndeterminate =
|
||
selectedIds.length > 0 && selectedIds.length < (data?.data?.length || 0)
|
||
|
||
const handleBulkUpdateSystem = async (group: ChainGroup, targetSystem: string | null) => {
|
||
try {
|
||
// Обновляем все шаги в выбранной цепочке асинхронно
|
||
await Promise.all(
|
||
group.steps.map((step) =>
|
||
updateHierarchy.mutateAsync({
|
||
id: step.id!,
|
||
subordinate_id: step.subordinate_id,
|
||
approver_id: step.approver_id,
|
||
department_id: step.department_id,
|
||
topic_category_id: step.topic_category_id,
|
||
topic_id: step.topic_id,
|
||
priority: step.priority,
|
||
target_system: targetSystem, // Применяем новую систему
|
||
})
|
||
)
|
||
)
|
||
} catch (error) {
|
||
console.error("Ошибка при массовом обновлении систем цепочки", error)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
{/* Заголовок */}
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Иерархия согласований</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
<SegmentedControl
|
||
value={viewMode}
|
||
onChange={(v) => {
|
||
setViewMode(v as ViewMode)
|
||
setSelectedIds([])
|
||
}}
|
||
data={[
|
||
{ value: 'chains', label: 'Цепочки' },
|
||
{ value: 'table', label: 'Таблица' },
|
||
]}
|
||
/>
|
||
<Tooltip label="Скопировать все цепочки одного сотрудника для другого — например, для нового сотрудника с такой же ролью">
|
||
<Button
|
||
variant="light"
|
||
leftSection={<IconUsers size={16} />}
|
||
onClick={() => setPersonDuplicateOpened(true)}
|
||
>
|
||
Дублировать по сотруднику
|
||
</Button>
|
||
</Tooltip>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => {
|
||
setPresetGroup(null)
|
||
setCreateModalOpened(true)
|
||
}}
|
||
>
|
||
Добавить связь
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="sm">
|
||
Иерархия определяет порядок согласования заявок. Каждая цепочка показывает,
|
||
через каких согласующих проходит заявка от конкретного сотрудника.
|
||
</Text>
|
||
</Alert>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Stack gap="md">
|
||
<Group gap="md" align="flex-end">
|
||
<Select
|
||
label="Сотрудник"
|
||
placeholder="Все пользователи"
|
||
data={userOptions}
|
||
value={subordinateFilter}
|
||
onChange={handleFilterChange(setSubordinateFilter)}
|
||
clearable
|
||
searchable
|
||
style={{ flex: 1, minWidth: 250 }}
|
||
/>
|
||
<Select
|
||
label="Отдел"
|
||
placeholder="Все отделы"
|
||
data={departmentOptions}
|
||
value={departmentFilter}
|
||
onChange={handleFilterChange(setDepartmentFilter)}
|
||
clearable
|
||
style={{ flex: 1, minWidth: 200 }}
|
||
/>
|
||
</Group>
|
||
<Group gap="md" align="flex-end">
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Все категории"
|
||
data={categoryOptions}
|
||
value={categoryFilter}
|
||
onChange={(v) => {
|
||
handleFilterChange(setCategoryFilter)(v)
|
||
setTopicFilter(null)
|
||
}}
|
||
clearable
|
||
searchable
|
||
style={{ flex: 1, minWidth: 200 }}
|
||
/>
|
||
<Select
|
||
label="Тема"
|
||
placeholder="Все темы"
|
||
data={topicOptions}
|
||
value={topicFilter}
|
||
onChange={handleFilterChange(setTopicFilter)}
|
||
clearable
|
||
searchable
|
||
style={{ flex: 1, minWidth: 200 }}
|
||
/>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Контент */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : viewMode === 'chains' ? (
|
||
<ScrollArea p="md">
|
||
<Stack gap="md">
|
||
{enrichedChains.length === 0 ? (
|
||
<Center p={40}>
|
||
<Text c="dimmed">Связи не найдены</Text>
|
||
</Center>
|
||
) : (
|
||
enrichedChains.map((chain) => (
|
||
<ChainVisualization
|
||
key={chain.key}
|
||
group={chain}
|
||
onEditStep={handleEditStep}
|
||
onDeleteStep={handleDelete}
|
||
onAddStep={handleAddStep}
|
||
onDuplicateChain={handleDuplicateChain}
|
||
onBulkUpdateSystem={handleBulkUpdateSystem}
|
||
/>
|
||
))
|
||
)}
|
||
</Stack>
|
||
</ScrollArea>
|
||
) : (
|
||
<>
|
||
{selectedIds.length > 0 && (
|
||
<Box
|
||
p="sm"
|
||
bg="red.0"
|
||
style={{ borderBottom: '1px solid var(--mantine-color-red-3)' }}
|
||
>
|
||
<Group justify="space-between">
|
||
<Text size="sm" fw={500}>
|
||
Выбрано записей: <strong>{selectedIds.length}</strong>
|
||
</Text>
|
||
<Group gap="xs">
|
||
<Button
|
||
variant="subtle"
|
||
size="xs"
|
||
onClick={() => setSelectedIds([])}
|
||
>
|
||
Снять выделение
|
||
</Button>
|
||
<Button
|
||
color="red"
|
||
size="xs"
|
||
leftSection={<IconTrash size={14} />}
|
||
onClick={handleBulkDelete}
|
||
loading={isDeleting}
|
||
>
|
||
Удалить выбранные
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 50 }}>
|
||
<Checkbox
|
||
checked={isAllSelected}
|
||
indeterminate={isIndeterminate}
|
||
onChange={handleSelectAll}
|
||
/>
|
||
</Table.Th>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Подчинённый</Table.Th>
|
||
<Table.Th>Согласующий</Table.Th>
|
||
<Table.Th>Отдел</Table.Th>
|
||
<Table.Th>Область</Table.Th>
|
||
<Table.Th>Объект</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Порядок</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={9}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Связи не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
data?.data?.map((h) => {
|
||
const scopeType = h.topic_id
|
||
? 'topic'
|
||
: h.topic_category_id
|
||
? 'category'
|
||
: 'global'
|
||
let scopeObjectName = 'Все темы'
|
||
if (scopeType === 'category' && h.topic_category_id) {
|
||
const cat = categories?.data?.find(
|
||
(c) => c.id === h.topic_category_id
|
||
)
|
||
scopeObjectName = cat?.name || `#${h.topic_category_id}`
|
||
} else if (scopeType === 'topic' && h.topic_id) {
|
||
const topic = topics?.data?.find(
|
||
(t) => t.id === h.topic_id
|
||
)
|
||
scopeObjectName = topic?.name || `#${h.topic_id}`
|
||
}
|
||
|
||
return (
|
||
<Table.Tr
|
||
key={h.id}
|
||
style={{
|
||
backgroundColor: selectedIds.includes(h.id!)
|
||
? 'var(--mantine-color-blue-0)'
|
||
: undefined,
|
||
}}
|
||
>
|
||
<Table.Td>
|
||
<Checkbox
|
||
checked={selectedIds.includes(h.id!)}
|
||
onChange={() => handleSelectOne(h.id!)}
|
||
/>
|
||
</Table.Td>
|
||
<Table.Td>{h.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" fw={500}>
|
||
{h.subordinate?.full_name || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" fw={500}>
|
||
{h.approver?.full_name || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm">
|
||
{h.department?.name || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
size="xs"
|
||
color={
|
||
SCOPE_COLORS[
|
||
scopeType as keyof typeof SCOPE_COLORS
|
||
]
|
||
}
|
||
variant="light"
|
||
>
|
||
{
|
||
SCOPE_LABELS[
|
||
scopeType as keyof typeof SCOPE_LABELS
|
||
]
|
||
}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={1}>
|
||
{scopeObjectName}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge variant="light" color="gray">
|
||
#{h.priority}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditHierarchy(h)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(h.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
)
|
||
})
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
</>
|
||
)}
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={(newPage) => {
|
||
setPage(newPage)
|
||
setSelectedIds([])
|
||
}}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
{/* Модалки */}
|
||
<HierarchyEditModal
|
||
hierarchy={editHierarchy}
|
||
opened={editHierarchy !== null}
|
||
onClose={handleCloseModal}
|
||
/>
|
||
|
||
<HierarchyEditModal
|
||
hierarchy={null}
|
||
presetGroup={presetGroup}
|
||
opened={createModalOpened}
|
||
onClose={handleCloseModal}
|
||
/>
|
||
|
||
<ChainDuplicateModal
|
||
group={duplicateGroup}
|
||
opened={duplicateModalOpened}
|
||
onClose={handleCloseDuplicateModal}
|
||
/>
|
||
|
||
<PersonDuplicateModal
|
||
opened={personDuplicateOpened}
|
||
onClose={() => setPersonDuplicateOpened(false)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/hierarchies/HierarchiesPage.tsx-----
|
||
|
||
File: src/pages/hierarchies/components/ChainDuplicateModal.tsx
|
||
Lines: 526
|
||
-----BEGIN src/pages/hierarchies/components/ChainDuplicateModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Select,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Paper,
|
||
Divider,
|
||
ActionIcon,
|
||
Badge,
|
||
Avatar,
|
||
Box,
|
||
Radio,
|
||
Alert,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
IconInfoCircle,
|
||
IconPlus,
|
||
IconTrash,
|
||
IconCopy,
|
||
IconChevronRight,
|
||
} from '@tabler/icons-react'
|
||
import { notifications } from '@mantine/notifications'
|
||
import { useCreateHierarchy } from '@/features/hierarchies/hooks/useHierarchies'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useDepartments } from '@/features/departments/hooks/useDepartments'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import { useAllSystemOptions } from '@/features/hierarchies/hooks/useSystemOptions' // 👈 ИМПОРТИРОВАЛИ ХУК
|
||
import type { ChainGroup } from '@/features/hierarchies/utils'
|
||
|
||
interface ChainDuplicateModalProps {
|
||
group: ChainGroup | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
type ScopeType = 'global' | 'category' | 'topic'
|
||
|
||
interface StepForm {
|
||
approver_id: number | null
|
||
priority: number
|
||
target_system: string | null // 👈 ДОБАВИЛИ ПОЛЕ В ИНТЕРФЕЙС
|
||
}
|
||
|
||
export default function ChainDuplicateModal({
|
||
group,
|
||
opened,
|
||
onClose,
|
||
}: ChainDuplicateModalProps) {
|
||
const createHierarchy = useCreateHierarchy()
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const { data: departments } = useDepartments()
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
|
||
// Подтягиваем доступные системы
|
||
const { options: systemOptions } = useAllSystemOptions()
|
||
|
||
const { data: allTopics } = useTopics({ limit: 1000 })
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
subordinate_id: null as number | null,
|
||
department_id: null as number | null,
|
||
scope_type: 'global' as ScopeType,
|
||
topic_category_id: null as number | null,
|
||
topic_id: null as number | null,
|
||
steps: [] as StepForm[],
|
||
},
|
||
validate: {
|
||
subordinate_id: (v) => (v === null ? 'Выберите инициатора' : null),
|
||
department_id: (v) => (v === null ? 'Выберите отдел' : null),
|
||
topic_category_id: (v, values) => {
|
||
if (
|
||
(values.scope_type === 'category' || values.scope_type === 'topic') &&
|
||
v === null
|
||
) {
|
||
return 'Выберите категорию'
|
||
}
|
||
return null
|
||
},
|
||
topic_id: (v, values) => {
|
||
if (values.scope_type === 'topic' && v === null) {
|
||
return 'Выберите тему'
|
||
}
|
||
return null
|
||
},
|
||
steps: {
|
||
approver_id: (v) => (v === null ? 'Выберите согласующего' : null),
|
||
},
|
||
},
|
||
})
|
||
|
||
const { data: categoryTopics } = useTopics({
|
||
limit: 1000,
|
||
...(form.values.topic_category_id && { category_id: form.values.topic_category_id }),
|
||
})
|
||
|
||
useEffect(() => {
|
||
if (group && opened) {
|
||
let resolvedCategoryId: number | null = null
|
||
if (group.scopeType === 'category') {
|
||
resolvedCategoryId = group.scopeObjectId
|
||
} else if (group.scopeType === 'topic') {
|
||
const matchedTopic = allTopics?.data?.find((t) => t.id === group.scopeObjectId)
|
||
resolvedCategoryId = matchedTopic?.category_id || null
|
||
}
|
||
|
||
form.setValues({
|
||
subordinate_id: group.subordinateId,
|
||
department_id: group.departmentId,
|
||
scope_type: group.scopeType,
|
||
topic_category_id: resolvedCategoryId,
|
||
topic_id: group.scopeType === 'topic' ? group.scopeObjectId : null,
|
||
steps: group.steps.map((s, idx) => ({
|
||
approver_id: s.approver_id || null,
|
||
priority: idx,
|
||
target_system: s.target_system || null, // 👈 ИНИЦИАЛИЗИРУЕМ ИЗ БД
|
||
})),
|
||
})
|
||
}
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [group, opened, allTopics])
|
||
|
||
const handleScopeTypeChange = (value: ScopeType) => {
|
||
form.setFieldValue('scope_type', value)
|
||
if (value === 'global') {
|
||
form.setFieldValue('topic_category_id', null)
|
||
form.setFieldValue('topic_id', null)
|
||
} else if (value === 'category') {
|
||
form.setFieldValue('topic_id', null)
|
||
}
|
||
}
|
||
|
||
const addStep = () => {
|
||
form.insertListItem('steps', {
|
||
approver_id: null,
|
||
priority: form.values.steps.length,
|
||
target_system: null, // 👈 ИНИЦИАЛИЗИРУЕМ ДЛЯ НОВОГО ШАГА
|
||
})
|
||
}
|
||
|
||
const removeStep = (index: number) => {
|
||
form.removeListItem('steps', index)
|
||
form.values.steps.forEach((_, idx) => {
|
||
form.setFieldValue(`steps.${idx}.priority`, idx)
|
||
})
|
||
}
|
||
|
||
const userOptions =
|
||
users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || `Пользователь #${u.id}`,
|
||
})) || []
|
||
|
||
const departmentOptions =
|
||
departments?.data?.map((d) => ({
|
||
value: String(d.id),
|
||
label: d.name || '',
|
||
})) || []
|
||
|
||
const categoryOptions =
|
||
categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const topicOptions =
|
||
categoryTopics?.data?.map((t) => ({
|
||
value: String(t.id),
|
||
label: t.name || '',
|
||
})) || []
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (values.steps.length === 0) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Добавьте хотя бы один шаг согласования',
|
||
color: 'red',
|
||
})
|
||
return
|
||
}
|
||
|
||
try {
|
||
for (const step of values.steps) {
|
||
await createHierarchy.mutateAsync({
|
||
subordinate_id: values.subordinate_id!,
|
||
approver_id: step.approver_id!,
|
||
department_id: values.department_id!,
|
||
priority: step.priority,
|
||
target_system: step.target_system || null, // 👈 ОТПРАВЛЯЕМ СИСТЕМУ
|
||
topic_category_id:
|
||
values.scope_type === 'global'
|
||
? null
|
||
: values.scope_type === 'category'
|
||
? values.topic_category_id
|
||
: null,
|
||
topic_id: values.scope_type === 'topic' ? values.topic_id : null,
|
||
})
|
||
}
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: `Цепочка дублирована (${values.steps.length} шагов)`,
|
||
color: 'green',
|
||
})
|
||
onClose()
|
||
} catch (error) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Не удалось дублировать цепочку',
|
||
color: 'red',
|
||
})
|
||
}
|
||
}
|
||
|
||
const isSubmitting = createHierarchy.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group gap="xs">
|
||
<IconCopy size={20} />
|
||
<Text fw={600}>Дублирование цепочки</Text>
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
centered
|
||
>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="sm">
|
||
Создайте новую цепочку на основе существующей. Вы можете изменить
|
||
инициатора, отдел, область действия и согласующих.
|
||
</Text>
|
||
</Alert>
|
||
|
||
{/* Общие параметры */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm" c="dark">
|
||
Общие параметры
|
||
</Text>
|
||
<Stack gap="sm">
|
||
<Select
|
||
label="Инициатор"
|
||
placeholder="Выберите пользователя"
|
||
data={userOptions}
|
||
value={
|
||
form.values.subordinate_id
|
||
? String(form.values.subordinate_id)
|
||
: null
|
||
}
|
||
onChange={(v) =>
|
||
form.setFieldValue(
|
||
'subordinate_id',
|
||
v ? Number(v) : null
|
||
)
|
||
}
|
||
searchable
|
||
required
|
||
error={form.errors.subordinate_id}
|
||
/>
|
||
|
||
<Select
|
||
label="Отдел"
|
||
placeholder="Выберите отдел"
|
||
data={departmentOptions}
|
||
value={
|
||
form.values.department_id
|
||
? String(form.values.department_id)
|
||
: null
|
||
}
|
||
onChange={(v) =>
|
||
form.setFieldValue(
|
||
'department_id',
|
||
v ? Number(v) : null
|
||
)
|
||
}
|
||
searchable
|
||
required
|
||
error={form.errors.department_id}
|
||
/>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Область действия */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm" c="dark">
|
||
Область действия
|
||
</Text>
|
||
<Stack gap="sm">
|
||
<Radio.Group
|
||
value={form.values.scope_type}
|
||
onChange={(v) => handleScopeTypeChange(v as ScopeType)}
|
||
>
|
||
<Stack gap="xs">
|
||
<Radio
|
||
value="global"
|
||
label="Глобальное правило"
|
||
description="Для всех тем согласований"
|
||
/>
|
||
<Radio
|
||
value="category"
|
||
label="Для категории тем"
|
||
description="Только для тем выбранной категории"
|
||
/>
|
||
<Radio
|
||
value="topic"
|
||
label="Для конкретной темы"
|
||
description="Только для выбранной темы"
|
||
/>
|
||
</Stack>
|
||
</Radio.Group>
|
||
|
||
{(form.values.scope_type === 'category' ||
|
||
form.values.scope_type === 'topic') && (
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Выберите категорию"
|
||
data={categoryOptions}
|
||
value={
|
||
form.values.topic_category_id
|
||
? String(form.values.topic_category_id)
|
||
: null
|
||
}
|
||
onChange={(v) => {
|
||
form.setFieldValue(
|
||
'topic_category_id',
|
||
v ? Number(v) : null
|
||
)
|
||
form.setFieldValue('topic_id', null)
|
||
}}
|
||
searchable
|
||
required
|
||
error={form.errors.topic_category_id}
|
||
/>
|
||
)}
|
||
|
||
{form.values.scope_type === 'topic' && (
|
||
<Select
|
||
label="Тема"
|
||
placeholder="Выберите тему"
|
||
data={topicOptions}
|
||
value={
|
||
form.values.topic_id
|
||
? String(form.values.topic_id)
|
||
: null
|
||
}
|
||
onChange={(v) =>
|
||
form.setFieldValue('topic_id', v ? Number(v) : null)
|
||
}
|
||
searchable
|
||
required
|
||
disabled={!form.values.topic_category_id}
|
||
error={form.errors.topic_id}
|
||
/>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Шаги согласования */}
|
||
<Paper withBorder p="md">
|
||
<Group justify="space-between" mb="sm">
|
||
<Text size="sm" fw={600} c="dark">
|
||
Шаги согласования
|
||
</Text>
|
||
<Button
|
||
variant="subtle"
|
||
size="xs"
|
||
leftSection={<IconPlus size={14} />}
|
||
onClick={addStep}
|
||
>
|
||
Добавить шаг
|
||
</Button>
|
||
</Group>
|
||
|
||
<Stack gap="sm">
|
||
{form.values.steps.length === 0 ? (
|
||
<Box py="md">
|
||
<Text size="sm" c="dimmed" ta="center">
|
||
Нет шагов согласования. Добавьте хотя бы один.
|
||
</Text>
|
||
</Box>
|
||
) : (
|
||
form.values.steps.map((step, index) => (
|
||
<Paper
|
||
key={index}
|
||
withBorder
|
||
p="sm"
|
||
style={{
|
||
borderColor: 'var(--mantine-color-gray-3)',
|
||
backgroundColor: 'var(--mantine-color-gray-0)',
|
||
}}
|
||
>
|
||
<Group gap="sm" align="flex-start">
|
||
<Avatar
|
||
size="sm"
|
||
radius="xl"
|
||
color="blue"
|
||
variant="filled"
|
||
mt={4}
|
||
>
|
||
{index + 1}
|
||
</Avatar>
|
||
|
||
<Stack gap="xs" style={{ flex: 1 }}>
|
||
<Group gap="xs">
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color="gray"
|
||
tt="none"
|
||
>
|
||
Шаг {index + 1}
|
||
</Badge>
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color="gray"
|
||
tt="none"
|
||
>
|
||
Priority: {step.priority}
|
||
</Badge>
|
||
</Group>
|
||
|
||
<Group grow gap="xs">
|
||
<Select
|
||
placeholder="Выберите согласующего"
|
||
data={userOptions}
|
||
value={step.approver_id ? String(step.approver_id) : null}
|
||
onChange={(v) =>
|
||
form.setFieldValue(`steps.${index}.approver_id`, v ? Number(v) : null)
|
||
}
|
||
searchable
|
||
error={
|
||
Array.isArray(form.errors.steps) && form.errors.steps[index]
|
||
? (form.errors.steps[index] as any)?.approver_id
|
||
: undefined
|
||
}
|
||
/>
|
||
|
||
{/* 👈 ДОБАВЛЕННЫЙ ВЫБОР СИСТЕМЫ */}
|
||
<Select
|
||
placeholder="Система: Все (по умолчанию)"
|
||
data={[
|
||
{ value: 'all', label: 'Система: Все' },
|
||
...systemOptions.map((s) => ({ value: s.value, label: `Система: ${s.label}` })),
|
||
]}
|
||
value={step.target_system || 'all'}
|
||
onChange={(v) =>
|
||
form.setFieldValue(
|
||
`steps.${index}.target_system`,
|
||
(v === 'all' || !v) ? null : v
|
||
)
|
||
}
|
||
clearable
|
||
/>
|
||
</Group>
|
||
</Stack>
|
||
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="red"
|
||
size="md"
|
||
mt={4}
|
||
onClick={() => removeStep(index)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Group>
|
||
</Paper>
|
||
))
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Предпросмотр */}
|
||
{form.values.steps.length > 0 && (
|
||
<Paper withBorder p="md" bg="gray.0">
|
||
<Text size="xs" fw={600} c="dimmed" mb="xs" tt="uppercase">
|
||
Предпросмотр цепочки
|
||
</Text>
|
||
<Group gap="xs" wrap="nowrap" style={{ overflowX: 'auto' }}>
|
||
<Badge variant="light" color="gray" tt="none">
|
||
{users?.data?.find(
|
||
(u) => u.id === form.values.subordinate_id
|
||
)?.full_name || 'Инициатор'}
|
||
</Badge>
|
||
{form.values.steps.map((step, index) => (
|
||
<Group key={index} gap={4} wrap="nowrap">
|
||
<IconChevronRight
|
||
size={14}
|
||
color="var(--mantine-color-gray-5)"
|
||
/>
|
||
<Badge variant="light" color="blue" tt="none">
|
||
{users?.data?.find(
|
||
(u) => u.id === step.approver_id
|
||
)?.full_name || `Шаг ${index + 1}`}
|
||
{step.target_system && ` (${step.target_system})`}
|
||
</Badge>
|
||
</Group>
|
||
))}
|
||
</Group>
|
||
</Paper>
|
||
)}
|
||
|
||
<Divider />
|
||
|
||
<Group justify="flex-end" gap="sm">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
Дублировать цепочку
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/hierarchies/components/ChainDuplicateModal.tsx-----
|
||
|
||
File: src/pages/hierarchies/components/ChainVisualization.tsx
|
||
Lines: 323
|
||
-----BEGIN src/pages/hierarchies/components/ChainVisualization.tsx-----
|
||
// ChainVisualization.tsx
|
||
import {useMemo, useState} from 'react'
|
||
import {
|
||
Paper,
|
||
Group,
|
||
Stack,
|
||
Text,
|
||
Badge,
|
||
ActionIcon,
|
||
Avatar,
|
||
Box,
|
||
Divider,
|
||
Tooltip,
|
||
Select,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconChevronRight,
|
||
IconPencil,
|
||
IconTrash,
|
||
IconWorld,
|
||
IconCategory,
|
||
IconFileText,
|
||
IconCopy,
|
||
IconPlus,
|
||
IconServer,
|
||
} from '@tabler/icons-react'
|
||
import type { ChainGroup } from '@/features/hierarchies/utils'
|
||
import { SCOPE_COLORS, SCOPE_LABELS } from '@/features/hierarchies/utils'
|
||
import {
|
||
useCategorySystemOptions,
|
||
ALL_SYSTEMS_VALUE,
|
||
useAllSystemOptions
|
||
} from '@/features/hierarchies/hooks/useSystemOptions'
|
||
import {useTopics} from "@/features/topics/hooks/useTopics.ts";
|
||
|
||
interface ChainVisualizationProps {
|
||
group: ChainGroup
|
||
onEditStep: (hierarchyId: number) => void
|
||
onDeleteStep: (hierarchyId: number) => void
|
||
onAddStep: (group: ChainGroup) => void
|
||
onDuplicateChain: (group: ChainGroup) => void
|
||
onBulkUpdateSystem?: (group: ChainGroup, targetSystem: string | null) => void
|
||
}
|
||
|
||
const ScopeIcon = ({ type }: { type: string }) => {
|
||
switch (type) {
|
||
case 'global':
|
||
return <IconWorld size={13} />
|
||
case 'category':
|
||
return <IconCategory size={13} />
|
||
case 'topic':
|
||
return <IconFileText size={13} />
|
||
default:
|
||
return <IconWorld size={13} />
|
||
}
|
||
}
|
||
|
||
// Внутри компонента ChainVisualization:
|
||
export default function ChainVisualization({
|
||
group,
|
||
onEditStep,
|
||
onDeleteStep,
|
||
onAddStep,
|
||
onDuplicateChain,
|
||
onBulkUpdateSystem,
|
||
}: ChainVisualizationProps) {
|
||
// Получаем все темы, чтобы уметь мапить topicId -> categoryId, если scopeType === 'topic'
|
||
const { data: allTopics } = useTopics({ limit: 1000 })
|
||
|
||
const resolvedCategoryId = useMemo(() => {
|
||
if (group.scopeType === 'category') {
|
||
return group.scopeObjectId
|
||
}
|
||
if (group.scopeType === 'topic' && group.scopeObjectId && allTopics?.data) {
|
||
const foundTopic = allTopics.data.find(t => t.id === group.scopeObjectId)
|
||
return foundTopic?.category_id || null
|
||
}
|
||
return null
|
||
}, [group.scopeType, group.scopeObjectId, allTopics?.data])
|
||
|
||
// Если цепочка глобальная (resolvedCategoryId === null), берем вообще все системы через useAllSystemOptions,
|
||
// иначе — системы конкретной категории через useCategorySystemOptions.
|
||
const categoryOptionsResult = useCategorySystemOptions(resolvedCategoryId)
|
||
const allOptionsResult = useAllSystemOptions(group.scopeType === 'global')
|
||
|
||
const systemOptions = group.scopeType === 'global' ? allOptionsResult.options : categoryOptionsResult.options
|
||
|
||
console.log(`[ChainVisualization] Группа ${group.key} (scope: ${group.scopeType}): resolvedCategoryId = ${resolvedCategoryId}, доступно систем:`, systemOptions)
|
||
|
||
// Текущая система цепочки (если у всех шагов одинаковая система, иначе 'all')
|
||
const currentChainSystem = group.steps.every(
|
||
(s) => s.target_system === group.steps[0]?.target_system
|
||
)
|
||
? group.steps[0]?.target_system || ALL_SYSTEMS_VALUE
|
||
: ALL_SYSTEMS_VALUE
|
||
|
||
// Формируем опции для Select
|
||
const selectData = [
|
||
{ value: ALL_SYSTEMS_VALUE, label: 'Система: Все' },
|
||
...systemOptions.map((opt) => ({
|
||
value: opt.value,
|
||
label: `Система: ${opt.label}`,
|
||
})),
|
||
]
|
||
|
||
return (
|
||
<Paper
|
||
withBorder
|
||
p="lg"
|
||
style={{
|
||
backgroundColor: 'var(--mantine-color-white)',
|
||
borderColor: 'var(--mantine-color-gray-3)',
|
||
}}
|
||
>
|
||
{/* Заголовок группы */}
|
||
<Group justify="space-between" mb="lg">
|
||
<Group gap="md">
|
||
<Avatar size="md" radius="xl" color="gray" variant="filled">
|
||
{group.subordinateName.charAt(0).toUpperCase()}
|
||
</Avatar>
|
||
|
||
<Stack gap={0}>
|
||
<Text fw={600} size="sm" c="dark">
|
||
{group.subordinateName}
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
{group.departmentName}
|
||
</Text>
|
||
</Stack>
|
||
|
||
<Divider orientation="vertical" />
|
||
|
||
<Badge
|
||
variant="outline"
|
||
color={SCOPE_COLORS[group.scopeType]}
|
||
leftSection={<ScopeIcon type={group.scopeType} />}
|
||
size="sm"
|
||
tt="none"
|
||
>
|
||
{SCOPE_LABELS[group.scopeType]}: {group.scopeObjectName}
|
||
</Badge>
|
||
|
||
{/* Выпадающий список систем отображается ТОЛЬКО если у темы/категории есть заданные systems */}
|
||
{systemOptions.length > 0 && (
|
||
<Select
|
||
size="xs"
|
||
leftSection={<IconServer size={14} />}
|
||
data={selectData}
|
||
value={currentChainSystem}
|
||
onChange={(val) => {
|
||
const newSystem = val === ALL_SYSTEMS_VALUE ? "" : val
|
||
if (onBulkUpdateSystem) {
|
||
onBulkUpdateSystem(group, newSystem)
|
||
}
|
||
}}
|
||
style={{ width: 180 }}
|
||
/>
|
||
)}
|
||
</Group>
|
||
|
||
<Group gap="xs">
|
||
<Tooltip label="Добавить шаг" withArrow>
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="gray"
|
||
size="md"
|
||
onClick={() => onAddStep(group)}
|
||
>
|
||
<IconPlus size={18} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Дублировать цепочку" withArrow>
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="gray"
|
||
size="md"
|
||
onClick={() => onDuplicateChain(group)}
|
||
>
|
||
<IconCopy size={18} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Group>
|
||
|
||
<Divider mb="lg" />
|
||
|
||
{/* Цепочка согласования */}
|
||
<Box style={{ overflowX: 'auto' }}>
|
||
<Group gap={0} wrap="nowrap" align="stretch">
|
||
{/* Карточка инициатора */}
|
||
<Paper
|
||
withBorder
|
||
p="md"
|
||
style={{
|
||
minWidth: 180,
|
||
borderColor: 'var(--mantine-color-gray-3)',
|
||
backgroundColor: 'var(--mantine-color-gray-0)',
|
||
}}
|
||
>
|
||
<Stack gap="xs" align="center">
|
||
<Text
|
||
size="xs"
|
||
fw={600}
|
||
c="dimmed"
|
||
tt="uppercase"
|
||
style={{ letterSpacing: '0.5px' }}
|
||
>
|
||
Инициатор
|
||
</Text>
|
||
<Avatar size="md" radius="xl" color="gray" variant="filled">
|
||
{group.subordinateName.charAt(0).toUpperCase()}
|
||
</Avatar>
|
||
<Text size="sm" fw={500} ta="center" lineClamp={2} c="dark">
|
||
{group.subordinateName}
|
||
</Text>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Шаги согласования */}
|
||
{group.steps.map((step, index) => (
|
||
<Group key={step.id} gap={0} wrap="nowrap" align="stretch">
|
||
<Stack
|
||
gap={2}
|
||
align="center"
|
||
justify="center"
|
||
px="xs"
|
||
style={{ minWidth: 60 }}
|
||
>
|
||
<IconChevronRight size={20} color="var(--mantine-color-gray-5)" />
|
||
<Badge size="xs" variant="light" color="gray" tt="none">
|
||
{index + 1}
|
||
</Badge>
|
||
</Stack>
|
||
|
||
{/* Карточка согласующего */}
|
||
<Paper
|
||
withBorder
|
||
p="md"
|
||
style={{
|
||
minWidth: 180,
|
||
borderColor: 'var(--mantine-color-gray-3)',
|
||
backgroundColor: 'var(--mantine-color-white)',
|
||
cursor: 'pointer',
|
||
transition: 'border-color 0.15s ease',
|
||
position: 'relative',
|
||
}}
|
||
onClick={() => onEditStep(step.id!)}
|
||
onMouseEnter={(e) => {
|
||
e.currentTarget.style.borderColor = 'var(--mantine-color-blue-5)'
|
||
}}
|
||
onMouseLeave={(e) => {
|
||
e.currentTarget.style.borderColor = 'var(--mantine-color-gray-3)'
|
||
}}
|
||
>
|
||
<Stack gap="xs" align="center">
|
||
<Group gap={6}>
|
||
<Text
|
||
size="xs"
|
||
fw={600}
|
||
c="dimmed"
|
||
tt="uppercase"
|
||
style={{ letterSpacing: '0.5px' }}
|
||
>
|
||
Шаг {index + 1}
|
||
</Text>
|
||
<Badge size="xs" variant="light" color="gray" tt="none">
|
||
#{step.priority}
|
||
</Badge>
|
||
</Group>
|
||
|
||
<Avatar size="md" radius="xl" color="blue" variant="filled">
|
||
{step.approver?.full_name?.charAt(0).toUpperCase() || '?'}
|
||
</Avatar>
|
||
|
||
<Text size="sm" fw={500} ta="center" lineClamp={2} c="dark">
|
||
{step.approver?.full_name || '—'}
|
||
</Text>
|
||
|
||
{/* Бейдж конкретной целевой системы для шага (если выбрано) */}
|
||
{step.target_system && (
|
||
<Badge size="xs" color="cyan" variant="light">
|
||
Система: {step.target_system}
|
||
</Badge>
|
||
)}
|
||
|
||
<Divider style={{ width: '100%', margin: '4px 0' }} />
|
||
|
||
<Group gap="xs" justify="center">
|
||
<Tooltip label="Редактировать" withArrow>
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="gray"
|
||
size="sm"
|
||
onClick={(e) => {
|
||
e.stopPropagation()
|
||
onEditStep(step.id!)
|
||
}}
|
||
>
|
||
<IconPencil size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить" withArrow>
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="red"
|
||
size="sm"
|
||
onClick={(e) => {
|
||
e.stopPropagation()
|
||
onDeleteStep(step.id!)
|
||
}}
|
||
>
|
||
<IconTrash size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
</Group>
|
||
))}
|
||
</Group>
|
||
</Box>
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/hierarchies/components/ChainVisualization.tsx-----
|
||
|
||
File: src/pages/hierarchies/components/HierarchyEditModal.tsx
|
||
Lines: 420
|
||
-----BEGIN src/pages/hierarchies/components/HierarchyEditModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Select,
|
||
NumberInput,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Badge,
|
||
Paper,
|
||
Alert,
|
||
Radio,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { IconInfoCircle, IconAlertCircle, IconCopy } from '@tabler/icons-react'
|
||
import { notifications } from '@mantine/notifications'
|
||
import {
|
||
useCreateHierarchy,
|
||
useUpdateHierarchy
|
||
} from '@/features/hierarchies/hooks/useHierarchies'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useDepartments } from '@/features/departments/hooks/useDepartments'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import type { UserHierarchy } from '@/types/api'
|
||
import type { ChainGroup } from '@/features/hierarchies/utils'
|
||
import { useAllSystemOptions } from '@/features/hierarchies/hooks/useSystemOptions'
|
||
|
||
interface HierarchyEditModalProps {
|
||
hierarchy: UserHierarchy | null
|
||
presetGroup?: ChainGroup | null // Для добавления шага в существующую группу
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
type ScopeType = 'global' | 'category' | 'topic'
|
||
|
||
export default function HierarchyEditModal({
|
||
hierarchy,
|
||
presetGroup,
|
||
opened,
|
||
onClose
|
||
}: HierarchyEditModalProps) {
|
||
const createHierarchy = useCreateHierarchy()
|
||
const updateHierarchy = useUpdateHierarchy()
|
||
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const { data: departments } = useDepartments()
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
const { options: systemOptions } = useAllSystemOptions()
|
||
|
||
const isEditMode = hierarchy !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
subordinate_id: null as number | null,
|
||
approver_id: null as number | null,
|
||
department_id: null as number | null,
|
||
scope_type: 'global' as ScopeType,
|
||
topic_category_id: null as number | null,
|
||
topic_id: null as number | null,
|
||
priority: 0,
|
||
target_system: null as string | null
|
||
},
|
||
validate: {
|
||
subordinate_id: (v) => (v === null ? 'Выберите подчинённого' : null),
|
||
approver_id: (v) => (v === null ? 'Выберите согласующего' : null),
|
||
// department_id/topic_category_id/topic_id заблокированы в режиме
|
||
// редактирования (см. disabled ниже) — если их всё же валидировать
|
||
// как обязательные, а на самой записи значение почему-то пустое,
|
||
// форма зависает намертво: поле нельзя ни заполнить (заблокировано),
|
||
// ни пропустить (обязательное).
|
||
department_id: (v) => (!isEditMode && v === null ? 'Выберите отдел' : null),
|
||
topic_category_id: (v, values) => {
|
||
if (isEditMode) return null
|
||
if ((values.scope_type === 'category' || values.scope_type === 'topic') && v === null) {
|
||
return 'Выберите категорию'
|
||
}
|
||
return null
|
||
},
|
||
topic_id: (v, values) => {
|
||
if (isEditMode) return null
|
||
if (values.scope_type === 'topic' && v === null) {
|
||
return 'Выберите тему'
|
||
}
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
// Темы выбранной категории — для выпадающего списка "Тема" при создании.
|
||
const { data: categoryTopics } = useTopics({
|
||
limit: 1000,
|
||
...(form.values.topic_category_id && { category_id: form.values.topic_category_id }),
|
||
})
|
||
|
||
// Полный список тем без фильтра — нужен, чтобы восстановить
|
||
// topic_category_id по topic_id (см. useEffect ниже), когда сама
|
||
// категория не сохранена явно — и на записи из БД (режим редактирования),
|
||
// и в presetGroup (добавление шага в существующую цепочку с областью
|
||
// действия "тема" — это и был баг №5).
|
||
const { data: allTopics } = useTopics({ limit: 1000 })
|
||
|
||
// Заполняем форму данными
|
||
useEffect(() => {
|
||
if (hierarchy) {
|
||
let scopeType: ScopeType = 'global'
|
||
if (hierarchy.topic_id) scopeType = 'topic'
|
||
else if (hierarchy.topic_category_id) scopeType = 'category'
|
||
|
||
let resolvedCategoryId = hierarchy.topic_category_id || null
|
||
if (scopeType === 'topic' && !resolvedCategoryId && allTopics?.data) {
|
||
const matchedTopic = allTopics.data.find((t) => t.id === hierarchy.topic_id)
|
||
resolvedCategoryId = matchedTopic?.category_id || null
|
||
}
|
||
|
||
form.setValues({
|
||
subordinate_id: hierarchy.subordinate_id || null,
|
||
approver_id: hierarchy.approver_id || null,
|
||
department_id: hierarchy.department_id || null,
|
||
scope_type: scopeType,
|
||
topic_category_id: resolvedCategoryId,
|
||
topic_id: hierarchy.topic_id || null,
|
||
target_system: hierarchy.target_system || null,
|
||
priority: hierarchy.priority ?? 0,
|
||
})
|
||
} else if (presetGroup) {
|
||
let resolvedCategoryId: number | null = null
|
||
if (presetGroup.scopeType === 'category') {
|
||
resolvedCategoryId = presetGroup.scopeObjectId
|
||
} else if (presetGroup.scopeType === 'topic') {
|
||
const matchedTopic = allTopics?.data?.find((t) => t.id === presetGroup.scopeObjectId)
|
||
resolvedCategoryId = matchedTopic?.category_id || null
|
||
}
|
||
|
||
form.setValues({
|
||
subordinate_id: presetGroup.subordinateId,
|
||
department_id: presetGroup.departmentId,
|
||
scope_type: presetGroup.scopeType,
|
||
topic_category_id: resolvedCategoryId,
|
||
topic_id: presetGroup.scopeType === 'topic' ? presetGroup.scopeObjectId : null,
|
||
priority: presetGroup.steps.length, // Следующий priority
|
||
approver_id: null,
|
||
})
|
||
} else {
|
||
form.reset()
|
||
}
|
||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||
}, [hierarchy, presetGroup, opened, allTopics])
|
||
|
||
const handleScopeTypeChange = (value: ScopeType) => {
|
||
form.setFieldValue('scope_type', value)
|
||
if (value === 'global') {
|
||
form.setFieldValue('topic_category_id', null)
|
||
form.setFieldValue('topic_id', null)
|
||
} else if (value === 'category') {
|
||
form.setFieldValue('topic_id', null)
|
||
}
|
||
}
|
||
|
||
// Опции
|
||
const userOptions = users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || `Пользователь #${u.id}`,
|
||
})) || []
|
||
|
||
const departmentOptions = departments?.data?.map((d) => ({
|
||
value: String(d.id),
|
||
label: d.name || '',
|
||
})) || []
|
||
|
||
const categoryOptions = categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const topicOptions = categoryTopics?.data?.map((t) => ({
|
||
value: String(t.id),
|
||
label: t.name || '',
|
||
})) || []
|
||
|
||
const buildPayload = (values: typeof form.values) => ({
|
||
subordinate_id: values.subordinate_id!,
|
||
approver_id: values.approver_id!,
|
||
department_id: values.department_id!,
|
||
priority: values.priority,
|
||
target_system: values.target_system || null,
|
||
topic_category_id: values.scope_type === 'global' ? null :
|
||
values.scope_type === 'category' ? values.topic_category_id : null,
|
||
topic_id: values.scope_type === 'topic' ? values.topic_id : null,
|
||
})
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
const payload = buildPayload(values)
|
||
|
||
if (isEditMode && hierarchy?.id) {
|
||
await updateHierarchy.mutateAsync({
|
||
id: hierarchy.id,
|
||
...payload,
|
||
})
|
||
} else {
|
||
await createHierarchy.mutateAsync(payload)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
// НОВОЕ (пункт 3): дублирование прямо из окна редактирования — создаёт
|
||
// новую запись с теми же значениями, что сейчас на экране, не трогая
|
||
// ту, что редактируется. Доступно только в режиме редактирования —
|
||
// дублировать ещё не сохранённую форму нечего.
|
||
const handleDuplicate = async () => {
|
||
if (!isEditMode) return
|
||
try {
|
||
await createHierarchy.mutateAsync(buildPayload(form.values))
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: 'Связь продублирована — можно найти копию в списке и отредактировать при необходимости',
|
||
color: 'green',
|
||
})
|
||
onClose()
|
||
} catch (error) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Не удалось продублировать связь',
|
||
color: 'red',
|
||
})
|
||
}
|
||
}
|
||
|
||
const isSubmitting = createHierarchy.isPending || updateHierarchy.isPending
|
||
const hasErrors = Object.keys(form.errors).length > 0
|
||
|
||
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование связи' : 'Добавление связи'}
|
||
</Text>
|
||
{hierarchy && <Badge variant="light">ID: {hierarchy.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
{hasErrors && (
|
||
<Alert icon={<IconAlertCircle size={16} />} color="red" variant="light">
|
||
<Text size="sm">Проверьте поля, отмеченные красным, ниже.</Text>
|
||
</Alert>
|
||
)}
|
||
|
||
<Select
|
||
label="Сотрудник (инициатор)"
|
||
placeholder="Выберите пользователя"
|
||
data={userOptions}
|
||
value={form.values.subordinate_id ? String(form.values.subordinate_id) : null}
|
||
onChange={(v) => form.setFieldValue('subordinate_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
disabled={!!presetGroup}
|
||
description="Пользователь, для которого настраивается согласование"
|
||
error={form.errors.subordinate_id}
|
||
/>
|
||
|
||
{/* Отдел */}
|
||
<Select
|
||
label="Отдел"
|
||
placeholder="Выберите отдел"
|
||
data={departmentOptions}
|
||
value={form.values.department_id ? String(form.values.department_id) : null}
|
||
onChange={(v) => form.setFieldValue('department_id', v ? Number(v) : null)}
|
||
searchable
|
||
required={!isEditMode}
|
||
disabled={isEditMode || !!presetGroup}
|
||
error={form.errors.department_id}
|
||
/>
|
||
|
||
{/* Согласующий */}
|
||
<Select
|
||
label="Согласующий"
|
||
placeholder="Выберите пользователя"
|
||
data={userOptions}
|
||
value={form.values.approver_id ? String(form.values.approver_id) : null}
|
||
onChange={(v) => form.setFieldValue('approver_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
description="Пользователь, который будет согласовывать заявки"
|
||
error={form.errors.approver_id}
|
||
/>
|
||
|
||
{/* Область действия */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={500} mb="sm">
|
||
Область действия
|
||
</Text>
|
||
<Radio.Group
|
||
value={form.values.scope_type}
|
||
onChange={(v) => handleScopeTypeChange(v as ScopeType)}
|
||
>
|
||
<Stack gap="xs">
|
||
<Radio
|
||
value="global"
|
||
label="Глобальное правило"
|
||
description="Для всех тем согласований"
|
||
disabled={isEditMode}
|
||
/>
|
||
<Radio
|
||
value="category"
|
||
label="Для категории тем"
|
||
description="Только для тем выбранной категории"
|
||
disabled={isEditMode}
|
||
/>
|
||
<Radio
|
||
value="topic"
|
||
label="Для конкретной темы"
|
||
description="Только для выбранной темы"
|
||
disabled={isEditMode}
|
||
/>
|
||
</Stack>
|
||
</Radio.Group>
|
||
</Paper>
|
||
|
||
{/* Категория */}
|
||
{(form.values.scope_type === 'category' || form.values.scope_type === 'topic') && (
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Выберите категорию"
|
||
data={categoryOptions}
|
||
value={form.values.topic_category_id ? String(form.values.topic_category_id) : null}
|
||
onChange={(v) => {
|
||
form.setFieldValue('topic_category_id', v ? Number(v) : null)
|
||
form.setFieldValue('topic_id', null)
|
||
}}
|
||
searchable
|
||
required={!isEditMode}
|
||
disabled={isEditMode || !!presetGroup}
|
||
error={form.errors.topic_category_id}
|
||
/>
|
||
)}
|
||
|
||
{/* Тема */}
|
||
{form.values.scope_type === 'topic' && (
|
||
<Select
|
||
label="Тема"
|
||
placeholder="Выберите тему"
|
||
data={topicOptions}
|
||
value={form.values.topic_id ? String(form.values.topic_id) : null}
|
||
onChange={(v) => form.setFieldValue('topic_id', v ? Number(v) : null)}
|
||
searchable
|
||
required={!isEditMode}
|
||
disabled={!form.values.topic_category_id || isEditMode || !!presetGroup}
|
||
description={!form.values.topic_category_id && !isEditMode ? 'Сначала выберите категорию' : undefined}
|
||
error={form.errors.topic_id}
|
||
/>
|
||
)}
|
||
|
||
<Select
|
||
label="Целевая система шага"
|
||
placeholder="Все системы (по умолчанию)"
|
||
data={[
|
||
{ value: 'all', label: 'Все системы' },
|
||
...systemOptions.map((s) => ({ value: s.value, label: s.label })),
|
||
]}
|
||
value={form.values.target_system || 'all'}
|
||
onChange={(v) => form.setFieldValue('target_system', (v === 'all' || !v) ? "" : v)}
|
||
description="Укажите систему, если данный шаг согласующего применяется только к определенной системе"
|
||
/>
|
||
|
||
{/* Priority */}
|
||
<NumberInput
|
||
label="Порядок шага (priority)"
|
||
description="0 = первый шаг, 1 = второй и т.д."
|
||
value={form.values.priority}
|
||
onChange={(v) => form.setFieldValue('priority', Number(v) || 0)}
|
||
min={0}
|
||
required
|
||
/>
|
||
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="sm">
|
||
Шаги выполняются последовательно в порядке возрастания priority.
|
||
Заявка переходит к следующему согласующему только после одобрения предыдущим.
|
||
{isEditMode && ' Область действия и отдел при редактировании не меняются — чтобы поменять их, удалите связь и создайте новую.'}
|
||
</Text>
|
||
</Alert>
|
||
|
||
{/* Кнопки */}
|
||
<Group justify="space-between" mt="md">
|
||
{isEditMode ? (
|
||
<Button
|
||
variant="light"
|
||
color="teal"
|
||
leftSection={<IconCopy size={16} />}
|
||
onClick={handleDuplicate}
|
||
disabled={isSubmitting}
|
||
>
|
||
Дублировать
|
||
</Button>
|
||
) : (
|
||
<div />
|
||
)}
|
||
<Group>
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/hierarchies/components/HierarchyEditModal.tsx-----
|
||
|
||
File: src/pages/hierarchies/components/PersonDuplicateModal.tsx
|
||
Lines: 197
|
||
-----BEGIN src/pages/hierarchies/components/PersonDuplicateModal.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Select,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Paper,
|
||
Alert,
|
||
Badge,
|
||
Loader,
|
||
Center,
|
||
} from '@mantine/core'
|
||
import { IconInfoCircle, IconUsers } from '@tabler/icons-react'
|
||
import { notifications } from '@mantine/notifications'
|
||
import { useHierarchies, useCreateHierarchy } from '@/features/hierarchies/hooks/useHierarchies'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
|
||
interface PersonDuplicateModalProps {
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
// 0 — заведомо несуществующий id пользователя, чтобы не дёргать хук
|
||
// условно (нарушает Rules of Hooks) и не гадать, как бэкенд обработает
|
||
// limit:0 — просто явно просим "ничего не найдётся".
|
||
const NO_USER_SENTINEL = 0
|
||
|
||
export default function PersonDuplicateModal({ opened, onClose }: PersonDuplicateModalProps) {
|
||
const [sourceId, setSourceId] = useState<string | null>(null)
|
||
const [targetId, setTargetId] = useState<string | null>(null)
|
||
const [isDuplicating, setIsDuplicating] = useState(false)
|
||
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
const { data: topics } = useTopics({ limit: 1000 })
|
||
const createHierarchy = useCreateHierarchy()
|
||
|
||
// Все связи исходного сотрудника — по всем областям действия сразу
|
||
// (глобальные + по категориям + по темам), без пагинации.
|
||
const { data: sourceHierarchies, isLoading: sourceLoading } = useHierarchies({
|
||
subordinate_id: sourceId ? Number(sourceId) : NO_USER_SENTINEL,
|
||
limit: 1000,
|
||
})
|
||
|
||
const sourceRows = sourceId ? sourceHierarchies?.data || [] : []
|
||
|
||
const userOptions = users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || `Пользователь #${u.id}`,
|
||
})) || []
|
||
|
||
const describeScope = (h: { topic_id?: number | null; topic_category_id?: number | null }) => {
|
||
if (h.topic_id) {
|
||
const t = topics?.data?.find((t) => t.id === h.topic_id)
|
||
return `Тема: ${t?.name || `#${h.topic_id}`}`
|
||
}
|
||
if (h.topic_category_id) {
|
||
const c = categories?.data?.find((c) => c.id === h.topic_category_id)
|
||
return `Категория: ${c?.name || `#${h.topic_category_id}`}`
|
||
}
|
||
return 'Глобально'
|
||
}
|
||
|
||
const handleClose = () => {
|
||
setSourceId(null)
|
||
setTargetId(null)
|
||
onClose()
|
||
}
|
||
|
||
const handleDuplicate = async () => {
|
||
if (!sourceId || !targetId || sourceRows.length === 0) return
|
||
setIsDuplicating(true)
|
||
try {
|
||
// Последовательно, а не Promise.all — чтобы не заваливать API
|
||
// залпом при большом количестве связей у сотрудника, и чтобы
|
||
// при ошибке было понятно, на какой именно записи остановились.
|
||
for (const h of sourceRows) {
|
||
if (!h.approver_id || !h.department_id) continue
|
||
await createHierarchy.mutateAsync({
|
||
subordinate_id: Number(targetId),
|
||
approver_id: h.approver_id,
|
||
department_id: h.department_id,
|
||
priority: h.priority ?? 0,
|
||
topic_category_id: h.topic_category_id ?? null,
|
||
topic_id: h.topic_id ?? null,
|
||
})
|
||
}
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: `Продублировано связей: ${sourceRows.length}`,
|
||
color: 'green',
|
||
})
|
||
handleClose()
|
||
} catch (error) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: 'Не удалось продублировать связи — часть могла успеть создаться, проверьте список',
|
||
color: 'red',
|
||
})
|
||
} finally {
|
||
setIsDuplicating(false)
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={handleClose}
|
||
title={
|
||
<Group gap="xs">
|
||
<IconUsers size={20} />
|
||
<Text fw={600}>Дублировать все связи сотрудника</Text>
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
centered
|
||
>
|
||
<Stack gap="md">
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light">
|
||
<Text size="sm">
|
||
Скопирует ВСЕ цепочки согласования выбранного сотрудника — глобальные, по
|
||
категориям и по темам — для нового сотрудника. Отдел, согласующие,
|
||
категории/темы и порядок шагов сохранятся как на образце.
|
||
</Text>
|
||
</Alert>
|
||
|
||
<Select
|
||
label="От кого копировать (образец)"
|
||
placeholder="Выберите сотрудника, чьи связи нужно скопировать"
|
||
data={userOptions.filter((o) => o.value !== targetId)}
|
||
value={sourceId}
|
||
onChange={setSourceId}
|
||
searchable
|
||
required
|
||
/>
|
||
|
||
<Select
|
||
label="Кому назначить такие же связи"
|
||
placeholder="Выберите нового сотрудника"
|
||
data={userOptions.filter((o) => o.value !== sourceId)}
|
||
value={targetId}
|
||
onChange={setTargetId}
|
||
searchable
|
||
required
|
||
disabled={!sourceId}
|
||
/>
|
||
|
||
{sourceId && (
|
||
<Paper withBorder p="md" bg="gray.0">
|
||
<Text size="xs" fw={600} c="dimmed" mb="xs" tt="uppercase">
|
||
Будет продублировано
|
||
</Text>
|
||
{sourceLoading ? (
|
||
<Center p="md">
|
||
<Loader size="sm" />
|
||
</Center>
|
||
) : sourceRows.length === 0 ? (
|
||
<Text size="sm" c="dimmed">
|
||
У этого сотрудника нет ни одной настроенной связи — дублировать нечего.
|
||
</Text>
|
||
) : (
|
||
<Stack gap={6}>
|
||
{sourceRows.map((h) => (
|
||
<Group key={h.id} justify="space-between" wrap="nowrap">
|
||
<Text size="sm">
|
||
{h.approver?.full_name || `Согласующий #${h.approver_id}`}
|
||
</Text>
|
||
<Badge size="xs" variant="light" color="gray" tt="none">
|
||
{describeScope(h)}
|
||
</Badge>
|
||
</Group>
|
||
))}
|
||
</Stack>
|
||
)}
|
||
</Paper>
|
||
)}
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={handleClose} disabled={isDuplicating}>
|
||
Отмена
|
||
</Button>
|
||
<Button
|
||
onClick={handleDuplicate}
|
||
loading={isDuplicating}
|
||
disabled={!sourceId || !targetId || sourceRows.length === 0}
|
||
>
|
||
{sourceRows.length > 0 ? `Продублировать (${sourceRows.length})` : 'Продублировать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/hierarchies/components/PersonDuplicateModal.tsx-----
|
||
|
||
File: src/pages/notifications/NotificationsPage.tsx
|
||
Lines: 44
|
||
-----BEGIN src/pages/notifications/NotificationsPage.tsx-----
|
||
import { Stack, Tabs, Text, Alert } from '@mantine/core'
|
||
import { IconSend, IconHistory, IconLock } from '@tabler/icons-react'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
import SendNotificationForm from './components/SendNotificationForm'
|
||
import NotificationsHistoryTable from './components/NotificationsHistoryTable'
|
||
|
||
export default function NotificationsPage() {
|
||
const { user } = useAuth()
|
||
const isObserver = user?.is_observer === true
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Text size="xl" fw={700}>Уведомления</Text>
|
||
|
||
<Tabs defaultValue={isObserver ? 'history' : 'send'}>
|
||
<Tabs.List>
|
||
{!isObserver && (
|
||
<Tabs.Tab value="send" leftSection={<IconSend size={16} />}>
|
||
Отправить
|
||
</Tabs.Tab>
|
||
)}
|
||
<Tabs.Tab value="history" leftSection={<IconHistory size={16} />}>
|
||
История
|
||
</Tabs.Tab>
|
||
</Tabs.List>
|
||
|
||
{!isObserver && (
|
||
<Tabs.Panel value="send" pt="md">
|
||
<SendNotificationForm />
|
||
</Tabs.Panel>
|
||
)}
|
||
|
||
<Tabs.Panel value="history" pt="md">
|
||
<NotificationsHistoryTable />
|
||
</Tabs.Panel>
|
||
</Tabs>
|
||
|
||
{isObserver && (
|
||
<Alert color="blue" variant="light" icon={<IconLock size={16} />}>
|
||
В режиме наблюдателя доступен только просмотр истории уведомлений
|
||
</Alert>
|
||
)}
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/notifications/NotificationsPage.tsx-----
|
||
|
||
File: src/pages/notifications/components/NotificationDetailsModal.tsx
|
||
Lines: 74
|
||
-----BEGIN src/pages/notifications/components/NotificationDetailsModal.tsx-----
|
||
import { useNotification } from '@/features/notifications/hooks/useNotifications'
|
||
import { Modal, Stack, Text, Badge, ScrollArea, Table, Divider, Loader, Center } from '@mantine/core'
|
||
|
||
interface Props {
|
||
notificationId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
const RECIPIENT_STATUS_LABELS: Record<string, { label: string; color: string }> = {
|
||
pending: { label: 'В очереди', color: 'gray' },
|
||
sent: { label: 'Доставлено', color: 'green' },
|
||
failed: { label: 'Ошибка', color: 'red' },
|
||
}
|
||
|
||
export default function NotificationDetailsModal({ notificationId, opened, onClose }: Props) {
|
||
const { data: notification, isLoading } = useNotification(notificationId)
|
||
|
||
return (
|
||
<Modal opened={opened} onClose={onClose} title="Детали уведомления" size="lg">
|
||
{isLoading || !notification ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<Stack gap="md">
|
||
<Stack gap={4}>
|
||
<Text fw={600}>{notification.title}</Text>
|
||
<div
|
||
style={{ fontSize: 14 }}
|
||
dangerouslySetInnerHTML={{ __html: notification.message_html }}
|
||
/>
|
||
</Stack>
|
||
|
||
<Divider label="Получатели" labelPosition="left" />
|
||
|
||
<ScrollArea h={300}>
|
||
<Table striped>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th>Пользователь</Table.Th>
|
||
<Table.Th style={{ width: 120 }}>Статус</Table.Th>
|
||
<Table.Th>Ошибка</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{(notification.recipients || []).map((r) => {
|
||
const statusInfo = RECIPIENT_STATUS_LABELS[r.status || ''] || {
|
||
label: r.status || '—',
|
||
color: 'gray',
|
||
}
|
||
return (
|
||
<Table.Tr key={r.id}>
|
||
<Table.Td>{r.user?.full_name || `ID ${r.user_id}`}</Table.Td>
|
||
<Table.Td>
|
||
<Badge color={statusInfo.color} variant="light" size="sm">
|
||
{statusInfo.label}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="xs" c="red">
|
||
{r.error_message || ''}
|
||
</Text>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
)
|
||
})}
|
||
</Table.Tbody>
|
||
</Table>
|
||
</ScrollArea>
|
||
</Stack>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/notifications/components/NotificationDetailsModal.tsx-----
|
||
|
||
File: src/pages/notifications/components/NotificationsHistoryTable.tsx
|
||
Lines: 124
|
||
-----BEGIN src/pages/notifications/components/NotificationsHistoryTable.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper, Table, Badge, Group, Text, Pagination, Loader, Center, Box, Stack,
|
||
} from '@mantine/core'
|
||
import NotificationDetailsModal from './NotificationDetailsModal'
|
||
import { useNotifications } from '@/features/notifications/hooks/useNotifications'
|
||
|
||
const LIMIT = 20
|
||
|
||
const STATUS_LABELS: Record<string, { label: string; color: string }> = {
|
||
pending: { label: 'В очереди', color: 'gray' },
|
||
sending: { label: 'Отправляется', color: 'blue' },
|
||
completed: { label: 'Завершено', color: 'green' },
|
||
failed: { label: 'Ошибка', color: 'red' },
|
||
}
|
||
|
||
export default function NotificationsHistoryTable() {
|
||
const [page, setPage] = useState(1)
|
||
const [selectedId, setSelectedId] = useState<number | null>(null)
|
||
|
||
const { data, isLoading } = useNotifications({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
})
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Заголовок</Table.Th>
|
||
<Table.Th style={{ width: 120 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 160 }}>Доставлено</Table.Th>
|
||
<Table.Th style={{ width: 160 }}>Дата отправки</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={5}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Уведомления не отправлялись</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((n) => {
|
||
const statusInfo = STATUS_LABELS[n.status || ''] || {
|
||
label: n.status || '—',
|
||
color: 'gray',
|
||
}
|
||
return (
|
||
<Table.Tr
|
||
key={n.id}
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => setSelectedId(n.id!)}
|
||
>
|
||
<Table.Td>{n.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text fw={500}>{n.title}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge color={statusInfo.color} variant="light">
|
||
{statusInfo.label}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap={6}>
|
||
<Badge color="green" variant="light" size="sm">
|
||
{n.sent_count ?? 0}
|
||
</Badge>
|
||
{(n.failed_count ?? 0) > 0 && (
|
||
<Badge color="red" variant="light" size="sm">
|
||
{n.failed_count} ошибок
|
||
</Badge>
|
||
)}
|
||
<Text size="xs" c="dimmed">
|
||
из {n.total_count ?? 0}
|
||
</Text>
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">
|
||
{n.sent_at ? new Date(n.sent_at).toLocaleString('ru-RU') : '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
)
|
||
})
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination value={page} onChange={setPage} total={totalPages} withEdges />
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
<NotificationDetailsModal
|
||
notificationId={selectedId}
|
||
opened={selectedId !== null}
|
||
onClose={() => setSelectedId(null)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/notifications/components/NotificationsHistoryTable.tsx-----
|
||
|
||
File: src/pages/notifications/components/SendNotificationForm.tsx
|
||
Lines: 445
|
||
-----BEGIN src/pages/notifications/components/SendNotificationForm.tsx-----
|
||
import { useState, useMemo } from 'react'
|
||
import {
|
||
Paper, Stack, TextInput, Button, Group, MultiSelect, Checkbox,
|
||
Text, FileButton, Image, ActionIcon, Divider, Alert, Badge, Grid,
|
||
ThemeIcon,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconPhoto, IconX, IconSend, IconAlertCircle, IconUsers,
|
||
IconUser, IconMask, IconBuilding, IconTag, IconEye, IconMessage,
|
||
} from '@tabler/icons-react'
|
||
import { RichTextEditor, Link } from '@mantine/tiptap'
|
||
import { useEditor } from '@tiptap/react'
|
||
import StarterKit from '@tiptap/starter-kit'
|
||
import Underline from '@tiptap/extension-underline'
|
||
import { useDebouncedValue } from '@mantine/hooks'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useDepartments } from '@/features/departments/hooks/useDepartments'
|
||
import { useAllRoles } from '@/features/roles/hooks/useAllRoles'
|
||
import { useCreateNotification } from '@/features/notifications/hooks/useNotifications.ts'
|
||
import { convertHtmlToTelegram } from '@/features/notifications/utils/telegramHtml.ts'
|
||
import { notifications } from '@mantine/notifications'
|
||
import { Modal } from '@mantine/core'
|
||
import '@mantine/tiptap/styles.css'
|
||
|
||
const ROLE_TYPE_OPTIONS = [
|
||
{ value: 'director', label: 'Директора', icon: '👔' },
|
||
{ value: 'approver', label: 'Согласующие', icon: '✅' },
|
||
{ value: 'observer', label: 'Наблюдатели', icon: '👀' },
|
||
{ value: 'executor', label: 'Исполнители', icon: '⚙️' },
|
||
{ value: 'controller', label: 'Контролёры', icon: '🎯' },
|
||
]
|
||
|
||
export default function SendNotificationForm() {
|
||
const [title, setTitle] = useState('')
|
||
const [userSearch, setUserSearch] = useState('')
|
||
const [debouncedUserSearch] = useDebouncedValue(userSearch, 300)
|
||
|
||
const [selectedUserIds, setSelectedUserIds] = useState<string[]>([])
|
||
const [selectedRoleIds, setSelectedRoleIds] = useState<string[]>([])
|
||
const [selectedRoleFlags, setSelectedRoleFlags] = useState<string[]>([])
|
||
const [selectedDepartmentIds, setSelectedDepartmentIds] = useState<string[]>([])
|
||
|
||
const [photoBase64, setPhotoBase64] = useState<string | null>(null)
|
||
const [photoFileName, setPhotoFileName] = useState<string | null>(null)
|
||
const [photoPreviewUrl, setPhotoPreviewUrl] = useState<string | null>(null)
|
||
|
||
const [confirmOpen, setConfirmOpen] = useState(false)
|
||
|
||
const { data: usersData } = useUsers({
|
||
limit: 50,
|
||
...(debouncedUserSearch && { full_name: debouncedUserSearch }),
|
||
})
|
||
const { data: roles = [] } = useAllRoles()
|
||
const { data: departmentsResponse } = useDepartments({ limit: 1000 })
|
||
const departments = departmentsResponse?.data || []
|
||
|
||
const createNotification = useCreateNotification()
|
||
|
||
const editor = useEditor({
|
||
extensions: [StarterKit, Underline, Link],
|
||
content: '',
|
||
})
|
||
|
||
const userOptions = useMemo(
|
||
() => (usersData?.data || []).map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name + (u.username ? ` (@${u.username})` : ''),
|
||
})),
|
||
[usersData],
|
||
)
|
||
const roleOptions = useMemo(
|
||
() => roles.map((r) => ({ value: String(r.id), label: r.name })),
|
||
[roles],
|
||
)
|
||
const departmentOptions = useMemo(
|
||
() => departments.map((d) => ({ value: String(d.id), label: d.name })),
|
||
[departments],
|
||
)
|
||
|
||
const MAX_ASPECT_RATIO = 20
|
||
|
||
const handlePhotoChange = (file: File | null) => {
|
||
if (!file) {
|
||
setPhotoBase64(null)
|
||
setPhotoFileName(null)
|
||
setPhotoPreviewUrl(null)
|
||
return
|
||
}
|
||
const reader = new FileReader()
|
||
reader.onload = () => {
|
||
const result = reader.result as string
|
||
const img = new window.Image()
|
||
img.onload = () => {
|
||
const ratio = Math.max(img.width, img.height) / Math.min(img.width, img.height)
|
||
const sumDimensions = img.width + img.height
|
||
if (ratio > MAX_ASPECT_RATIO || sumDimensions > 10000) {
|
||
notifications.show({
|
||
title: 'Некорректное изображение',
|
||
message: `Telegram не примет это фото: слишком вытянутые пропорции (${img.width}×${img.height}).`,
|
||
color: 'red',
|
||
})
|
||
return
|
||
}
|
||
setPhotoBase64(result.split(',')[1] || '')
|
||
setPhotoFileName(file.name)
|
||
setPhotoPreviewUrl(result)
|
||
}
|
||
img.src = result
|
||
}
|
||
reader.readAsDataURL(file)
|
||
}
|
||
|
||
const hasAnyTarget =
|
||
selectedUserIds.length > 0 ||
|
||
selectedRoleIds.length > 0 ||
|
||
selectedRoleFlags.length > 0 ||
|
||
selectedDepartmentIds.length > 0
|
||
|
||
const messageHtml = editor?.getHTML() ?? ''
|
||
const messageText = editor?.getText() ?? ''
|
||
const isMessageEmpty = editor?.isEmpty ?? true
|
||
|
||
const canSubmit = title.trim().length > 0 && !isMessageEmpty && hasAnyTarget
|
||
|
||
const totalCriteria =
|
||
(selectedUserIds.length > 0 ? 1 : 0) +
|
||
(selectedRoleIds.length > 0 ? 1 : 0) +
|
||
(selectedRoleFlags.length > 0 ? 1 : 0) +
|
||
(selectedDepartmentIds.length > 0 ? 1 : 0)
|
||
|
||
const doSubmit = () => {
|
||
setConfirmOpen(false)
|
||
createNotification.mutate(
|
||
{
|
||
title: title.trim(),
|
||
message_html: convertHtmlToTelegram(messageHtml),
|
||
photo_base64: photoBase64 || undefined,
|
||
photo_file_name: photoFileName || undefined,
|
||
targets: {
|
||
user_ids: selectedUserIds.map(Number),
|
||
role_ids: selectedRoleIds.map(Number),
|
||
role_type_flags: selectedRoleFlags,
|
||
department_ids: selectedDepartmentIds.map(Number),
|
||
},
|
||
},
|
||
{
|
||
onSuccess: () => {
|
||
setTitle('')
|
||
editor?.commands.clearContent()
|
||
setSelectedUserIds([])
|
||
setSelectedRoleIds([])
|
||
setSelectedRoleFlags([])
|
||
setSelectedDepartmentIds([])
|
||
handlePhotoChange(null)
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: 'Уведомление отправлено',
|
||
color: 'green',
|
||
})
|
||
},
|
||
},
|
||
)
|
||
}
|
||
|
||
return (
|
||
<Paper withBorder p={{ base: 'md', md: 'xl' }} radius="md">
|
||
{/* ===== HEADER ===== */}
|
||
<Group justify="space-between" align="center" mb="lg">
|
||
<Group gap="sm">
|
||
<ThemeIcon size="lg" radius="md" variant="light" color="blue">
|
||
<IconMessage size={20} />
|
||
</ThemeIcon>
|
||
<div>
|
||
<Text size="xl" fw={700}>Новая рассылка</Text>
|
||
<Text size="xs" c="dimmed">Отправится через Telegram Bot</Text>
|
||
</div>
|
||
</Group>
|
||
{totalCriteria > 0 && (
|
||
<Badge size="lg" variant="light" color="blue" radius="sm">
|
||
{totalCriteria} {totalCriteria === 1 ? 'критерий' : 'критериев'}
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
|
||
<Grid gap="xl">
|
||
<Grid.Col span={{ base: 12, lg: 7 }}>
|
||
<Stack gap="lg">
|
||
<TextInput
|
||
label="Заголовок рассылки"
|
||
description="Только для админки, в Telegram не отправляется"
|
||
placeholder="Плановые работы 15 июля"
|
||
value={title}
|
||
onChange={(e) => setTitle(e.currentTarget.value)}
|
||
required
|
||
size="md"
|
||
/>
|
||
|
||
{/* Редактор */}
|
||
<Stack gap={6}>
|
||
<Group justify="space-between" align="center">
|
||
<Text size="sm" fw={500}>Текст сообщения</Text>
|
||
{!isMessageEmpty && (
|
||
<Badge size="xs" variant="light" color="green" leftSection={<IconEye size={10} />}>
|
||
Заполнено
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
<RichTextEditor editor={editor} style={{ minHeight: 320 }}>
|
||
<RichTextEditor.Toolbar sticky stickyOffset={0}>
|
||
<RichTextEditor.ControlsGroup>
|
||
<RichTextEditor.Bold />
|
||
<RichTextEditor.Italic />
|
||
<RichTextEditor.Underline />
|
||
<RichTextEditor.Strikethrough />
|
||
</RichTextEditor.ControlsGroup>
|
||
<RichTextEditor.ControlsGroup>
|
||
<RichTextEditor.Code />
|
||
<RichTextEditor.CodeBlock />
|
||
<RichTextEditor.ClearFormatting />
|
||
</RichTextEditor.ControlsGroup>
|
||
<RichTextEditor.ControlsGroup>
|
||
<RichTextEditor.Link />
|
||
<RichTextEditor.Unlink />
|
||
</RichTextEditor.ControlsGroup>
|
||
</RichTextEditor.Toolbar>
|
||
<RichTextEditor.Content style={{ minHeight: 220 }} />
|
||
</RichTextEditor>
|
||
<Text size="xs" c="dimmed">
|
||
<b>жирный</b> · <i>курсив</i> · <u>подчёркнутый</u> · <s>зачёркнутый</s> · <code>код</code> · ссылки — остальное Telegram не отобразит
|
||
</Text>
|
||
</Stack>
|
||
|
||
{/* Фото */}
|
||
<Stack gap={6}>
|
||
<Text size="sm" fw={500}>Фото (опционально)</Text>
|
||
{photoPreviewUrl ? (
|
||
<Group gap="sm">
|
||
<Paper withBorder p={4} radius="sm">
|
||
<Image src={photoPreviewUrl} h={90} w={90} radius="sm" fit="cover" />
|
||
</Paper>
|
||
<Stack gap={2} style={{ flex: 1 }}>
|
||
<Text size="sm" fw={500} lineClamp={1}>{photoFileName}</Text>
|
||
<Text size="xs" c="dimmed">Готово к отправке</Text>
|
||
</Stack>
|
||
<ActionIcon
|
||
color="red"
|
||
variant="light"
|
||
onClick={() => handlePhotoChange(null)}
|
||
>
|
||
<IconX size={16} />
|
||
</ActionIcon>
|
||
</Group>
|
||
) : (
|
||
<FileButton onChange={handlePhotoChange} accept="image/png,image/jpeg,image/webp">
|
||
{(props) => (
|
||
<Button {...props} variant="light" leftSection={<IconPhoto size={16} />}>
|
||
Прикрепить фото
|
||
</Button>
|
||
)}
|
||
</FileButton>
|
||
)}
|
||
</Stack>
|
||
</Stack>
|
||
</Grid.Col>
|
||
|
||
{/* ===== ПРАВАЯ КОЛОНКА: ПОЛУЧАТЕЛИ + ПРЕВЬЮ ===== */}
|
||
<Grid.Col span={{ base: 12, lg: 5 }}>
|
||
<Stack gap="lg">
|
||
{/* Получатели */}
|
||
<Paper withBorder p="md" radius="md">
|
||
<Group justify="space-between" mb="md">
|
||
<Group gap="xs">
|
||
<ThemeIcon size="sm" variant="light" color="violet">
|
||
<IconUsers size={14} />
|
||
</ThemeIcon>
|
||
<Text size="sm" fw={600}>Получатели</Text>
|
||
</Group>
|
||
{hasAnyTarget && (
|
||
<Badge size="xs" variant="light" color="violet">
|
||
Настроено
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
|
||
<Stack gap="md">
|
||
<MultiSelect
|
||
label={
|
||
<Group gap={4}>
|
||
<IconUser size={14} />
|
||
<Text size="sm" span>Конкретные пользователи</Text>
|
||
{selectedUserIds.length > 0 && (
|
||
<Badge size="xs" variant="filled" circle>{selectedUserIds.length}</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
placeholder="Начните вводить имя..."
|
||
data={userOptions}
|
||
value={selectedUserIds}
|
||
onChange={setSelectedUserIds}
|
||
searchable
|
||
searchValue={userSearch}
|
||
onSearchChange={setUserSearch}
|
||
clearable
|
||
nothingFoundMessage="Никого не найдено"
|
||
size="xs"
|
||
/>
|
||
|
||
<MultiSelect
|
||
label={
|
||
<Group gap={4}>
|
||
<IconMask size={14} />
|
||
<Text size="sm" span>Роли</Text>
|
||
{selectedRoleIds.length > 0 && (
|
||
<Badge size="xs" variant="filled" circle>{selectedRoleIds.length}</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
placeholder="Выберите роли"
|
||
data={roleOptions}
|
||
value={selectedRoleIds}
|
||
onChange={setSelectedRoleIds}
|
||
searchable
|
||
clearable
|
||
size="xs"
|
||
/>
|
||
|
||
<Stack gap={6}>
|
||
<Group gap={4}>
|
||
<IconTag size={14} />
|
||
<Text size="sm" span>Тип роли</Text>
|
||
{selectedRoleFlags.length > 0 && (
|
||
<Badge size="xs" variant="filled" circle>{selectedRoleFlags.length}</Badge>
|
||
)}
|
||
</Group>
|
||
<Checkbox.Group value={selectedRoleFlags} onChange={setSelectedRoleFlags}>
|
||
<Stack gap={6}>
|
||
{ROLE_TYPE_OPTIONS.map((opt) => (
|
||
<Checkbox
|
||
key={opt.value}
|
||
value={opt.value}
|
||
label={
|
||
<Group gap={6}>
|
||
<Text size="sm">{opt.icon}</Text>
|
||
<Text size="sm">{opt.label}</Text>
|
||
</Group>
|
||
}
|
||
/>
|
||
))}
|
||
</Stack>
|
||
</Checkbox.Group>
|
||
</Stack>
|
||
|
||
<MultiSelect
|
||
label={
|
||
<Group gap={4}>
|
||
<IconBuilding size={14} />
|
||
<Text size="sm" span>Отделы</Text>
|
||
{selectedDepartmentIds.length > 0 && (
|
||
<Badge size="xs" variant="filled" circle>{selectedDepartmentIds.length}</Badge>
|
||
)}
|
||
</Group>
|
||
}
|
||
placeholder="Выберите отделы"
|
||
data={departmentOptions}
|
||
value={selectedDepartmentIds}
|
||
onChange={setSelectedDepartmentIds}
|
||
searchable
|
||
clearable
|
||
size="xs"
|
||
/>
|
||
|
||
{!hasAnyTarget && (
|
||
<Alert color="blue" variant="light" icon={<IconAlertCircle size={16} />} p="xs">
|
||
<Text size="xs">Выберите хотя бы один способ определения получателей</Text>
|
||
</Alert>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Кнопка отправки */}
|
||
<Button
|
||
fullWidth
|
||
size="md"
|
||
leftSection={<IconSend size={18} />}
|
||
onClick={() => setConfirmOpen(true)}
|
||
loading={createNotification.isPending}
|
||
disabled={!canSubmit}
|
||
>
|
||
Отправить уведомление
|
||
</Button>
|
||
</Stack>
|
||
</Grid.Col>
|
||
</Grid>
|
||
|
||
{/* ===== МОДАЛКА ПОДТВЕРЖДЕНИЯ ===== */}
|
||
<Modal
|
||
opened={confirmOpen}
|
||
onClose={() => setConfirmOpen(false)}
|
||
title="Подтверждение отправки"
|
||
centered
|
||
>
|
||
<Stack gap="md">
|
||
<Text size="sm">
|
||
Отправить уведомление <b>«{title.trim()}»</b>?
|
||
</Text>
|
||
<Paper withBorder p="sm" radius="sm">
|
||
<Stack gap={4}>
|
||
{selectedUserIds.length > 0 && (
|
||
<Group justify="space-between">
|
||
<Text size="xs" c="dimmed">Пользователей</Text>
|
||
<Text size="sm" fw={500}>{selectedUserIds.length}</Text>
|
||
</Group>
|
||
)}
|
||
{selectedRoleIds.length > 0 && (
|
||
<Group justify="space-between">
|
||
<Text size="xs" c="dimmed">Ролей</Text>
|
||
<Text size="sm" fw={500}>{selectedRoleIds.length}</Text>
|
||
</Group>
|
||
)}
|
||
{selectedRoleFlags.length > 0 && (
|
||
<Group justify="space-between">
|
||
<Text size="xs" c="dimmed">Типов ролей</Text>
|
||
<Text size="sm" fw={500}>{selectedRoleFlags.length}</Text>
|
||
</Group>
|
||
)}
|
||
{selectedDepartmentIds.length > 0 && (
|
||
<Group justify="space-between">
|
||
<Text size="xs" c="dimmed">Отделов</Text>
|
||
<Text size="sm" fw={500}>{selectedDepartmentIds.length}</Text>
|
||
</Group>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
<Group justify="flex-end" gap="sm" mt="xs">
|
||
<Button variant="default" onClick={() => setConfirmOpen(false)}>
|
||
Отмена
|
||
</Button>
|
||
<Button color="blue" onClick={doSubmit} loading={createNotification.isPending}>
|
||
Отправить
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</Modal>
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/notifications/components/SendNotificationForm.tsx-----
|
||
|
||
File: src/pages/permissions/PermissionsPage.tsx
|
||
Lines: 306
|
||
-----BEGIN src/pages/permissions/PermissionsPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
Select,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Tabs,
|
||
UnstyledButton,
|
||
ThemeIcon,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconPencil,
|
||
IconTrash,
|
||
IconPlus,
|
||
IconSearch,
|
||
IconShield,
|
||
IconCategory,
|
||
IconBriefcase,
|
||
IconWorld,
|
||
} from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { usePermissions, useDeletePermission } from '@/features/permissions/hooks/usePermissions'
|
||
import { useRoles } from '@/features/roles/hooks/useRoles'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { PERMISSION_ACTIONS, ACTION_COLORS, ACTION_LABELS } from '@/features/permissions/constants'
|
||
import PermissionEditModal from './components/PermissionEditModal'
|
||
|
||
const LIMIT = 50
|
||
|
||
export default function PermissionsPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [roleFilter, setRoleFilter] = useState<string | null>(null)
|
||
const [actionFilter, setActionFilter] = useState<string | null>(null)
|
||
const [editPermissionId, setEditPermissionId] = useState<number | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
|
||
const { data, isLoading, isFetching } = usePermissions({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(roleFilter && { role_id: Number(roleFilter) }),
|
||
...(actionFilter && { action: actionFilter }),
|
||
})
|
||
|
||
const { data: roles } = useRoles({ limit: 1000 })
|
||
const deletePermission = useDeletePermission()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const roleOptions = roles?.data?.map((r) => ({
|
||
value: String(r.id),
|
||
label: r.name || '',
|
||
})) || []
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить это право? Пользователи с этой ролью потеряют соответствующие возможности.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deletePermission.mutate(id),
|
||
})
|
||
}
|
||
|
||
// Определяем "уровень" права
|
||
const getPermissionLevel = (permission: any) => {
|
||
if (permission.topic_id && permission.topic) {
|
||
return {
|
||
level: 'topic',
|
||
label: 'Тема',
|
||
value: permission.topic.name,
|
||
icon: IconBriefcase,
|
||
color: 'orange',
|
||
}
|
||
}
|
||
if (permission.topic_category_id && permission.topic_category) {
|
||
return {
|
||
level: 'category',
|
||
label: 'Категория',
|
||
value: permission.topic_category.name,
|
||
icon: IconCategory,
|
||
color: 'blue',
|
||
}
|
||
}
|
||
return {
|
||
level: 'global',
|
||
label: 'Глобальное',
|
||
value: 'Все темы',
|
||
icon: IconWorld,
|
||
color: 'violet',
|
||
}
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Права доступа</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => setCreateModalOpened(true)}
|
||
>
|
||
Добавить право
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Подсказка */}
|
||
<Paper withBorder p="md" bg="blue.0">
|
||
<Group gap="xs">
|
||
<IconShield size={20} color="blue" />
|
||
<Text size="sm">
|
||
Права определяют, какие действия могут выполнять пользователи с определённой ролью.
|
||
Право может быть <b>глобальным</b> (на все темы),
|
||
на <b>категорию</b> (на все темы категории) или на <b>конкретную тему</b>.
|
||
</Text>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<Select
|
||
label="Роль"
|
||
placeholder="Все роли"
|
||
data={roleOptions}
|
||
value={roleFilter}
|
||
onChange={(v) => {
|
||
setRoleFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
style={{ minWidth: 200 }}
|
||
/>
|
||
|
||
<Select
|
||
label="Действие"
|
||
placeholder="Все действия"
|
||
data={PERMISSION_ACTIONS.map((a) => ({
|
||
value: a.value,
|
||
label: a.label,
|
||
}))}
|
||
value={actionFilter}
|
||
onChange={(v) => {
|
||
setActionFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
style={{ minWidth: 200 }}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Роль</Table.Th>
|
||
<Table.Th>Действие</Table.Th>
|
||
<Table.Th>Область действия</Table.Th>
|
||
<Table.Th>Объект</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={6}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Права не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((permission) => {
|
||
const level = getPermissionLevel(permission)
|
||
const LevelIcon = level.icon
|
||
return (
|
||
<Table.Tr key={permission.id}>
|
||
<Table.Td>{permission.id}</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<ThemeIcon size="sm" variant="light" color="blue">
|
||
<IconShield size={12} />
|
||
</ThemeIcon>
|
||
<Text size="sm" fw={500}>
|
||
{permission.role?.name || '—'}
|
||
</Text>
|
||
</Group>
|
||
<Text size="xs" c="dimmed">
|
||
{permission.role?.code}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={ACTION_COLORS[permission.action || ''] || 'gray'}
|
||
variant="light"
|
||
>
|
||
{ACTION_LABELS[permission.action || ''] || permission.action}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<LevelIcon size={14} color={`var(--mantine-color-${level.color}-6)`} />
|
||
<Text size="sm" c={level.color}>
|
||
{level.label}
|
||
</Text>
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={2}>
|
||
{level.value}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditPermissionId(permission.id!)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(permission.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
)
|
||
})
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
<PermissionEditModal
|
||
permissionId={editPermissionId}
|
||
opened={editPermissionId !== null}
|
||
onClose={() => setEditPermissionId(null)}
|
||
/>
|
||
|
||
<PermissionEditModal
|
||
permissionId={null}
|
||
opened={createModalOpened}
|
||
onClose={() => setCreateModalOpened(false)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/permissions/PermissionsPage.tsx-----
|
||
|
||
File: src/pages/permissions/components/PermissionEditModal.tsx
|
||
Lines: 303
|
||
-----BEGIN src/pages/permissions/components/PermissionEditModal.tsx-----
|
||
import { useEffect, useMemo } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Select,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
Paper,
|
||
Alert,
|
||
Radio,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { IconInfoCircle } from '@tabler/icons-react'
|
||
import {
|
||
usePermission,
|
||
useCreatePermission,
|
||
useUpdatePermission
|
||
} from '@/features/permissions/hooks/usePermissions'
|
||
import { useRoles } from '@/features/roles/hooks/useRoles'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import { PERMISSION_ACTIONS } from '@/features/permissions/constants'
|
||
|
||
interface PermissionEditModalProps {
|
||
permissionId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
type ScopeType = 'global' | 'category' | 'topic'
|
||
|
||
export default function PermissionEditModal({
|
||
permissionId,
|
||
opened,
|
||
onClose
|
||
}: PermissionEditModalProps) {
|
||
const { data: permission, isLoading: permissionLoading } = usePermission(permissionId)
|
||
|
||
const createPermission = useCreatePermission()
|
||
const updatePermission = useUpdatePermission()
|
||
|
||
const { data: roles } = useRoles({ limit: 1000 })
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
|
||
const isEditMode = permissionId !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
role_id: null as number | null,
|
||
action: '',
|
||
scope_type: 'global' as ScopeType,
|
||
topic_category_id: null as number | null,
|
||
topic_id: null as number | null,
|
||
},
|
||
validate: {
|
||
role_id: (value) => (value === null ? 'Выберите роль' : null),
|
||
action: (value) => (value === '' ? 'Выберите действие' : null),
|
||
topic_id: (value, values) => {
|
||
if (values.scope_type === 'topic' && value === null) {
|
||
return 'Выберите тему'
|
||
}
|
||
return null
|
||
},
|
||
topic_category_id: (value, values) => {
|
||
if (values.scope_type === 'category' && value === null) {
|
||
return 'Выберите категорию'
|
||
}
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
// Загружаем темы выбранной категории
|
||
const { data: categoryTopics } = useTopics({
|
||
limit: 1000,
|
||
...(form.values.topic_category_id && { category_id: form.values.topic_category_id }),
|
||
})
|
||
|
||
// Заполняем форму данными
|
||
useEffect(() => {
|
||
if (permission) {
|
||
let scopeType: ScopeType = 'global'
|
||
if (permission.topic_id) scopeType = 'topic'
|
||
else if (permission.topic_category_id) scopeType = 'category'
|
||
|
||
form.setValues({
|
||
role_id: permission.role_id || null,
|
||
action: permission.action || '',
|
||
scope_type: scopeType,
|
||
topic_category_id: permission.topic_category_id || null,
|
||
topic_id: permission.topic_id || null,
|
||
})
|
||
} else if (!isEditMode) {
|
||
form.reset()
|
||
}
|
||
}, [permission, isEditMode])
|
||
|
||
// При смене scope_type сбрасываем связанные поля
|
||
const handleScopeTypeChange = (value: ScopeType) => {
|
||
form.setFieldValue('scope_type', value)
|
||
if (value === 'global') {
|
||
form.setFieldValue('topic_category_id', null)
|
||
form.setFieldValue('topic_id', null)
|
||
} else if (value === 'category') {
|
||
form.setFieldValue('topic_id', null)
|
||
}
|
||
}
|
||
|
||
// При смене категории сбрасываем тему
|
||
const handleCategoryChange = (value: string | null) => {
|
||
form.setFieldValue('topic_category_id', value ? Number(value) : null)
|
||
form.setFieldValue('topic_id', null)
|
||
}
|
||
|
||
// Опции
|
||
const roleOptions = roles?.data?.map((r) => ({
|
||
value: String(r.id),
|
||
label: r.name || '',
|
||
})) || []
|
||
|
||
const categoryOptions = categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const topicOptions = categoryTopics?.data?.map((t) => ({
|
||
value: String(t.id),
|
||
label: t.name || '',
|
||
})) || []
|
||
|
||
const actionOptions = PERMISSION_ACTIONS.map((a) => ({
|
||
value: a.value,
|
||
label: `${a.label} — ${a.description}`,
|
||
}))
|
||
|
||
// Получаем описание области действия
|
||
const scopeDescription = useMemo(() => {
|
||
switch (form.values.scope_type) {
|
||
case 'global':
|
||
return 'Право будет действовать на все темы согласований'
|
||
case 'category':
|
||
return 'Право будет действовать на все темы выбранной категории'
|
||
case 'topic':
|
||
return 'Право будет действовать только на выбранную тему'
|
||
}
|
||
}, [form.values.scope_type])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
const payload = {
|
||
role_id: values.role_id!,
|
||
action: values.action,
|
||
topic_category_id: values.scope_type === 'global' ? null :
|
||
values.scope_type === 'category' ? values.topic_category_id : null,
|
||
topic_id: values.scope_type === 'topic' ? values.topic_id : null,
|
||
}
|
||
|
||
if (isEditMode && permissionId) {
|
||
await updatePermission.mutateAsync({
|
||
id: permissionId,
|
||
...payload,
|
||
})
|
||
} else {
|
||
await createPermission.mutateAsync(payload)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isLoading = permissionLoading
|
||
const isSubmitting = createPermission.isPending || updatePermission.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование права' : 'Добавление права'}
|
||
</Text>
|
||
{permission && <Badge variant="light">ID: {permission.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
{/* Роль */}
|
||
<Select
|
||
label="Роль"
|
||
placeholder="Выберите роль"
|
||
data={roleOptions}
|
||
value={form.values.role_id ? String(form.values.role_id) : null}
|
||
onChange={(v) => form.setFieldValue('role_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
disabled={isEditMode}
|
||
description="Роль, которой назначается право"
|
||
/>
|
||
|
||
{/* Действие */}
|
||
<Select
|
||
label="Действие"
|
||
placeholder="Выберите действие"
|
||
data={actionOptions}
|
||
value={form.values.action}
|
||
onChange={(v) => form.setFieldValue('action', v || '')}
|
||
required
|
||
description="Какое действие будет доступно"
|
||
/>
|
||
|
||
{/* Область действия */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={500} mb="sm">
|
||
Область действия
|
||
</Text>
|
||
<Radio.Group
|
||
value={form.values.scope_type}
|
||
onChange={(v) => handleScopeTypeChange(v as ScopeType)}
|
||
>
|
||
<Stack gap="xs">
|
||
<Radio
|
||
value="global"
|
||
label="Глобальное право"
|
||
description="На все темы согласований"
|
||
/>
|
||
<Radio
|
||
value="category"
|
||
label="На категорию"
|
||
description="На все темы выбранной категории"
|
||
/>
|
||
<Radio
|
||
value="topic"
|
||
label="На конкретную тему"
|
||
description="Только на выбранную тему"
|
||
/>
|
||
</Stack>
|
||
</Radio.Group>
|
||
|
||
<Alert icon={<IconInfoCircle size={16} />} color="blue" variant="light" mt="sm">
|
||
<Text size="sm">{scopeDescription}</Text>
|
||
</Alert>
|
||
</Paper>
|
||
|
||
{/* Категория (если выбрана) */}
|
||
{(form.values.scope_type === 'category' || form.values.scope_type === 'topic') && (
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Выберите категорию"
|
||
data={categoryOptions}
|
||
value={form.values.topic_category_id ? String(form.values.topic_category_id) : null}
|
||
onChange={handleCategoryChange}
|
||
searchable
|
||
required={form.values.scope_type === 'category'}
|
||
description={
|
||
form.values.scope_type === 'topic'
|
||
? 'Категория, к которой принадлежит тема'
|
||
: 'Категория тем, на которые распространяется право'
|
||
}
|
||
/>
|
||
)}
|
||
|
||
{/* Тема (если выбрана) */}
|
||
{form.values.scope_type === 'topic' && (
|
||
<Select
|
||
label="Тема"
|
||
placeholder="Выберите тему"
|
||
data={topicOptions}
|
||
value={form.values.topic_id ? String(form.values.topic_id) : null}
|
||
onChange={(v) => form.setFieldValue('topic_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
disabled={!form.values.topic_category_id}
|
||
description={
|
||
!form.values.topic_category_id
|
||
? 'Сначала выберите категорию'
|
||
: 'Тема, на которую распространяется право'
|
||
}
|
||
/>
|
||
)}
|
||
|
||
{/* Кнопки */}
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/permissions/components/PermissionEditModal.tsx-----
|
||
|
||
File: src/pages/roles/RolesPage.tsx
|
||
Lines: 318
|
||
-----BEGIN src/pages/roles/RolesPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
TextInput,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import { IconPencil, IconTrash, IconPlus, IconSearch } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useRoles, useDeleteRole } from '@/features/roles/hooks/useRoles'
|
||
import RoleEditModal from './components/RoleEditModal'
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function RolesPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [search, setSearch] = useState('')
|
||
const [roleTypeFilter, setRoleTypeFilter] = useState<string | null>(null)
|
||
const [editRoleId, setEditRoleId] = useState<number | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
|
||
const { data, isLoading, isFetching } = useRoles({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(search && { name: search }),
|
||
...(roleTypeFilter === 'director' && { is_director: true }),
|
||
...(roleTypeFilter === 'approver' && { is_approver: true }),
|
||
...(roleTypeFilter === 'observer' && { is_observer: true }),
|
||
...(roleTypeFilter === 'executor' && { is_executor: true }),
|
||
...(roleTypeFilter === 'controller' && { is_controller: true }), // 🆕
|
||
})
|
||
|
||
const deleteRole = useDeleteRole()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить эту роль? Это действие нельзя отменить.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteRole.mutate(id),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Роли</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => setCreateModalOpened(true)}
|
||
>
|
||
Создать роль
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<TextInput
|
||
label="Поиск по названию"
|
||
placeholder="Администратор..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
|
||
<Group gap="xs">
|
||
<Badge
|
||
variant={roleTypeFilter === null ? 'filled' : 'light'}
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => {
|
||
setRoleTypeFilter(null)
|
||
setPage(1)
|
||
}}
|
||
>
|
||
Все
|
||
</Badge>
|
||
<Badge
|
||
variant={roleTypeFilter === 'director' ? 'filled' : 'light'}
|
||
color="violet"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => {
|
||
setRoleTypeFilter(roleTypeFilter === 'director' ? null : 'director')
|
||
setPage(1)
|
||
}}
|
||
>
|
||
Директора
|
||
</Badge>
|
||
<Badge
|
||
variant={roleTypeFilter === 'approver' ? 'filled' : 'light'}
|
||
color="blue"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => {
|
||
setRoleTypeFilter(roleTypeFilter === 'approver' ? null : 'approver')
|
||
setPage(1)
|
||
}}
|
||
>
|
||
Согласующие
|
||
</Badge>
|
||
<Badge
|
||
variant={roleTypeFilter === 'observer' ? 'filled' : 'light'}
|
||
color="green"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => {
|
||
setRoleTypeFilter(roleTypeFilter === 'observer' ? null : 'observer')
|
||
setPage(1)
|
||
}}
|
||
>
|
||
Наблюдатели
|
||
</Badge>
|
||
<Badge
|
||
variant={roleTypeFilter === 'controller' ? 'filled' : 'light'}
|
||
color="teal"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => {
|
||
setRoleTypeFilter(roleTypeFilter === 'controller' ? null : 'controller')
|
||
setPage(1)
|
||
}}
|
||
>
|
||
Контролёры
|
||
</Badge>
|
||
<Badge
|
||
variant={roleTypeFilter === 'executor' ? 'filled' : 'light'}
|
||
color="orange"
|
||
style={{ cursor: 'pointer' }}
|
||
onClick={() => {
|
||
setRoleTypeFilter(roleTypeFilter === 'executor' ? null : 'executor')
|
||
setPage(1)
|
||
}}
|
||
>
|
||
Исполнители
|
||
</Badge>
|
||
</Group>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Название</Table.Th>
|
||
<Table.Th>Код</Table.Th>
|
||
<Table.Th>Типы ролей</Table.Th>
|
||
<Table.Th>Описание</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={7}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Роли не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((role) => (
|
||
<Table.Tr key={role.id}>
|
||
<Table.Td>{role.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text fw={500}>{role.name}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace" c="dimmed">
|
||
{role.code}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap={4}>
|
||
{role.is_director && (
|
||
<Badge size="xs" color="violet" variant="light">Директор</Badge>
|
||
)}
|
||
{role.is_approver && (
|
||
<Badge size="xs" color="blue" variant="light">Согласующий</Badge>
|
||
)}
|
||
{role.is_observer && (
|
||
<Badge size="xs" color="green" variant="light">Наблюдатель</Badge>
|
||
)}
|
||
{role.is_executor && (
|
||
<Badge size="xs" color="orange" variant="light">Исполнитель</Badge>
|
||
)}
|
||
{role.is_controller && (
|
||
<Badge size="xs" color="teal" variant="light">Контролёр</Badge>
|
||
)}
|
||
{!role.is_director && !role.is_approver && !role.is_observer &&
|
||
!role.is_executor && !role.is_controller && (
|
||
<Text size="xs" c="dimmed">—</Text>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" lineClamp={2}>
|
||
{role.description || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={role.is_default ? 'blue' : 'gray'}
|
||
variant={role.is_default ? 'filled' : 'light'}
|
||
>
|
||
{role.is_default ? 'По умолчанию' : 'Пользовательская'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditRoleId(role.id!)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(role.id!)}
|
||
disabled={role.is_default}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{/* Пагинация */}
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{/* Индикатор обновления */}
|
||
{isFetching && !isLoading && (
|
||
<Box
|
||
style={{
|
||
position: 'fixed',
|
||
top: 70,
|
||
right: 20,
|
||
zIndex: 1000
|
||
}}
|
||
>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
{/* Модальное окно редактирования */}
|
||
<RoleEditModal
|
||
roleId={editRoleId}
|
||
opened={editRoleId !== null}
|
||
onClose={() => setEditRoleId(null)}
|
||
/>
|
||
|
||
{/* Модальное окно создания */}
|
||
<RoleEditModal
|
||
roleId={null}
|
||
opened={createModalOpened}
|
||
onClose={() => setCreateModalOpened(false)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/roles/RolesPage.tsx-----
|
||
|
||
File: src/pages/roles/components/RoleEditModal.tsx
|
||
Lines: 209
|
||
-----BEGIN src/pages/roles/components/RoleEditModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Textarea,
|
||
Switch,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
Paper,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
useRole,
|
||
useCreateRole,
|
||
useUpdateRole
|
||
} from '@/features/roles/hooks/useRoles'
|
||
|
||
interface RoleEditModalProps {
|
||
roleId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function RoleEditModal({
|
||
roleId,
|
||
opened,
|
||
onClose
|
||
}: RoleEditModalProps) {
|
||
const { data: role, isLoading: roleLoading } = useRole(roleId)
|
||
|
||
const createRole = useCreateRole()
|
||
const updateRole = useUpdateRole()
|
||
|
||
const isEditMode = roleId !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
name: '',
|
||
code: '',
|
||
description: '',
|
||
is_default: false,
|
||
is_director: false,
|
||
is_approver: false,
|
||
is_observer: false,
|
||
is_executor: false,
|
||
is_controller: false,
|
||
},
|
||
validate: {
|
||
name: (value: string | any[]) => (value.length < 2 ? 'Название должно содержать минимум 2 символа' : null),
|
||
code: (value: string | any[]) => {
|
||
if (value.length < 2) return 'Код должен содержать минимум 2 символа'
|
||
if (!/^[a-z0-9_]+$/.test(value as string)) return 'Код должен содержать только lowercase буквы, цифры и подчеркивания'
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
// Заполняем форму данными роли
|
||
useEffect(() => {
|
||
if (role) {
|
||
form.setValues({
|
||
name: role.name || '',
|
||
code: role.code || '',
|
||
description: role.description || '',
|
||
is_default: role.is_default ?? false,
|
||
is_director: role.is_director ?? false,
|
||
is_approver: role.is_approver ?? false,
|
||
is_observer: role.is_observer ?? false,
|
||
is_executor: role.is_executor ?? false,
|
||
is_controller: role.is_controller ?? false,
|
||
})
|
||
} else if (!isEditMode) {
|
||
form.reset()
|
||
}
|
||
}, [role, isEditMode])
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
if (isEditMode && roleId) {
|
||
// Режим редактирования
|
||
await updateRole.mutateAsync({
|
||
id: roleId,
|
||
...values,
|
||
})
|
||
} else {
|
||
// Режим создания
|
||
await createRole.mutateAsync(values)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isLoading = roleLoading
|
||
const isSubmitting = createRole.isPending || updateRole.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование роли' : 'Создание роли'}
|
||
</Text>
|
||
{role && <Badge variant="light">ID: {role.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<TextInput
|
||
label="Название"
|
||
placeholder="Администратор"
|
||
required
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Код"
|
||
placeholder="admin"
|
||
required
|
||
description="Уникальный идентификатор роли (lowercase, цифры, подчеркивания)"
|
||
disabled={isEditMode}
|
||
{...form.getInputProps('code')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Описание"
|
||
placeholder="Описание роли..."
|
||
minRows={2}
|
||
{...form.getInputProps('description')}
|
||
/>
|
||
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={500} mb="sm">Типы ролей</Text>
|
||
<Stack gap="sm">
|
||
<Switch
|
||
label="Директор"
|
||
description="Пользователь с этой ролью является директором"
|
||
checked={form.values.is_director}
|
||
onChange={(e) => form.setFieldValue('is_director', e.currentTarget.checked)}
|
||
color="violet"
|
||
/>
|
||
<Switch
|
||
label="Согласующий"
|
||
description="Пользователь с этой ролью может согласовывать заявки"
|
||
checked={form.values.is_approver}
|
||
onChange={(e) => form.setFieldValue('is_approver', e.currentTarget.checked)}
|
||
color="blue"
|
||
/>
|
||
<Switch
|
||
label="Наблюдатель"
|
||
description="Пользователь с этой ролью может наблюдать за заявками"
|
||
checked={form.values.is_observer}
|
||
onChange={(e) => form.setFieldValue('is_observer', e.currentTarget.checked)}
|
||
color="green"
|
||
/>
|
||
<Switch
|
||
label="Исполнитель"
|
||
description="Пользователь с этой ролью может выполнять задачи"
|
||
checked={form.values.is_executor}
|
||
onChange={(e) => form.setFieldValue('is_executor', e.currentTarget.checked)}
|
||
color="orange"
|
||
/>
|
||
<Switch
|
||
label="Контролёр"
|
||
description={
|
||
form.values.is_observer
|
||
? "Пользователь с этой ролью видит расширенный контроль по заявкам"
|
||
: "Доступно только вместе с ролью «Наблюдатель»"
|
||
}
|
||
checked={form.values.is_controller}
|
||
disabled={!form.values.is_observer}
|
||
onChange={(e) => form.setFieldValue('is_controller', e.currentTarget.checked)}
|
||
color="teal"
|
||
/>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
<Switch
|
||
label="Роль по умолчанию"
|
||
description="Назначается новым пользователям автоматически"
|
||
checked={form.values.is_default}
|
||
onChange={(e) => form.setFieldValue('is_default', e.currentTarget.checked)}
|
||
color="blue"
|
||
/>
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/roles/components/RoleEditModal.tsx-----
|
||
|
||
File: src/pages/settings/SettingsPage.tsx
|
||
Lines: 179
|
||
-----BEGIN src/pages/settings/SettingsPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Stack,
|
||
Text,
|
||
PasswordInput,
|
||
Button,
|
||
Group,
|
||
Alert,
|
||
Box,
|
||
Title,
|
||
Divider,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import { notifications } from '@mantine/notifications'
|
||
import { modals } from '@mantine/modals'
|
||
import { IconShield, IconAlertCircle, IconKey } from '@tabler/icons-react'
|
||
import { authApi } from '@/api/auth'
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
|
||
export default function SettingsPage() {
|
||
const [loading, setLoading] = useState(false)
|
||
const { user } = useAuth()
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
current_password: '',
|
||
new_password: '',
|
||
confirm_password: '',
|
||
},
|
||
validate: {
|
||
current_password: (value) =>
|
||
value.length === 0 ? 'Введите текущий пароль' : null,
|
||
new_password: (value) => {
|
||
if (value.length === 0) return 'Введите новый пароль'
|
||
if (value.length < 6) return 'Пароль должен содержать минимум 6 символов'
|
||
return null
|
||
},
|
||
confirm_password: (value, values) =>
|
||
value !== values.new_password ? 'Пароли не совпадают' : null,
|
||
},
|
||
})
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
// Подтверждение через модальное окно
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите смену пароля',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите изменить пароль? После смены пароля вам нужно будет
|
||
войти заново на всех устройствах.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Изменить пароль', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: async () => {
|
||
setLoading(true)
|
||
try {
|
||
await authApi.updateProfile({ password: values.new_password })
|
||
|
||
notifications.show({
|
||
title: 'Успешно',
|
||
message: 'Пароль успешно изменен',
|
||
color: 'green',
|
||
})
|
||
|
||
form.reset()
|
||
|
||
// Разлогиниваем пользователя, чтобы он вошёл заново
|
||
setTimeout(() => {
|
||
localStorage.removeItem('token')
|
||
window.location.href = '/login'
|
||
}, 1500)
|
||
|
||
} catch (error: any) {
|
||
notifications.show({
|
||
title: 'Ошибка',
|
||
message: error.response?.data?.error_description || 'Не удалось изменить пароль',
|
||
color: 'red',
|
||
})
|
||
} finally {
|
||
setLoading(false)
|
||
}
|
||
},
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Box maw={600}>
|
||
<Stack gap="lg">
|
||
<div>
|
||
<Title order={2}>Настройки</Title>
|
||
<Text c="dimmed" size="sm" mt={4}>
|
||
Управление вашим аккаунтом
|
||
</Text>
|
||
</div>
|
||
|
||
{/* Информация о профиле */}
|
||
<Paper withBorder p="md">
|
||
<Stack gap="xs">
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Логин:</Text>
|
||
<Text fw={500}>{user?.login || '—'}</Text>
|
||
</Group>
|
||
{user?.last_login && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Последний вход:</Text>
|
||
<Text size="sm">
|
||
{new Date(user.last_login).toLocaleString('ru-RU')}
|
||
</Text>
|
||
</Group>
|
||
)}
|
||
{user?.last_ip_login && (
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">Последний IP:</Text>
|
||
<Text size="sm" ff="monospace">{user.last_ip_login}</Text>
|
||
</Group>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Смена пароля */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="xs" mb="md">
|
||
<IconKey size={20} color="var(--mantine-color-blue-6)" />
|
||
<Text fw={600} size="lg">Смена пароля</Text>
|
||
</Group>
|
||
|
||
<Alert
|
||
icon={<IconAlertCircle size={16} />}
|
||
color="yellow"
|
||
variant="light"
|
||
mb="md"
|
||
>
|
||
<Text size="sm">
|
||
После смены пароля вам нужно будет войти заново на всех устройствах.
|
||
</Text>
|
||
</Alert>
|
||
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
<PasswordInput
|
||
label="Текущий пароль"
|
||
placeholder="Введите текущий пароль"
|
||
required
|
||
{...form.getInputProps('current_password')}
|
||
/>
|
||
|
||
<Divider />
|
||
|
||
<PasswordInput
|
||
label="Новый пароль"
|
||
placeholder="Минимум 6 символов"
|
||
required
|
||
{...form.getInputProps('new_password')}
|
||
/>
|
||
|
||
<PasswordInput
|
||
label="Подтвердите новый пароль"
|
||
placeholder="Повторите новый пароль"
|
||
required
|
||
{...form.getInputProps('confirm_password')}
|
||
/>
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button
|
||
type="submit"
|
||
loading={loading}
|
||
leftSection={<IconShield size={16} />}
|
||
>
|
||
Изменить пароль
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Paper>
|
||
</Stack>
|
||
</Box>
|
||
)
|
||
}
|
||
-----END src/pages/settings/SettingsPage.tsx-----
|
||
|
||
File: src/pages/topicExecutors/TopicExecutorsPage.tsx
|
||
Lines: 397
|
||
-----BEGIN src/pages/topicExecutors/TopicExecutorsPage.tsx-----
|
||
import { useState, useMemo } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
Select,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
SegmentedControl,
|
||
Badge,
|
||
Alert,
|
||
ScrollArea,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconPencil,
|
||
IconTrash,
|
||
IconPlus,
|
||
IconInfoCircle,
|
||
IconFile,
|
||
IconCheck,
|
||
IconX,
|
||
} from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import {
|
||
useTopicExecutors,
|
||
useDeleteTopicExecutor
|
||
} from '@/features/topicExecutors/hooks/useTopicExecutors'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import {
|
||
groupExecutorsByTopic,
|
||
TARGET_SYSTEMS,
|
||
TARGET_SYSTEM_LABELS,
|
||
TARGET_SYSTEM_COLORS,
|
||
type TopicExecutorsGroup,
|
||
} from '@/features/topicExecutors/utils'
|
||
import TopicExecutorsCard from './components/TopicExecutorsCard'
|
||
import TopicExecutorEditModal from './components/TopicExecutorEditModal'
|
||
import type { ApprovalTopicExecutor } from '@/types/api'
|
||
|
||
type ViewMode = 'cards' | 'table'
|
||
|
||
export default function TopicExecutorsPage() {
|
||
const [viewMode, setViewMode] = useState<ViewMode>('cards')
|
||
|
||
// ✅ Фильтры - адаптированы под дизайн Hierarchies
|
||
const [topicFilter, setTopicFilter] = useState<string | null>(null)
|
||
const [categoryFilter, setCategoryFilter] = useState<string | null>(null)
|
||
const [userFilter, setUserFilter] = useState<string | null>(null)
|
||
const [targetSystemFilter, setTargetSystemFilter] = useState<string | null>(null)
|
||
|
||
const [editExecutor, setEditExecutor] = useState<ApprovalTopicExecutor | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
const [presetGroup, setPresetGroup] = useState<TopicExecutorsGroup | null>(null)
|
||
|
||
// ✅ Получаем категории
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
|
||
// ✅ Получаем темы с учетом фильтра по категории
|
||
const { data: categoryTopics } = useTopics({
|
||
limit: 1000,
|
||
...(categoryFilter && { category_id: Number(categoryFilter) }),
|
||
})
|
||
|
||
const { data, isLoading, isFetching } = useTopicExecutors({
|
||
...(topicFilter && { topic_id: Number(topicFilter) }),
|
||
...(userFilter && { user_id: Number(userFilter) }),
|
||
...(categoryFilter && { category_id: Number(categoryFilter) }),
|
||
...(targetSystemFilter && { target_system: targetSystemFilter }),
|
||
})
|
||
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const { data: topics } = useTopics({ limit: 1000 })
|
||
|
||
const deleteExecutor = useDeleteTopicExecutor()
|
||
|
||
// Группируем по темам
|
||
const groups = useMemo(() => {
|
||
if (!data?.data) return []
|
||
return groupExecutorsByTopic(data.data)
|
||
}, [data])
|
||
|
||
// ✅ Опции для фильтров
|
||
const userOptions = users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || `Пользователь #${u.id}`,
|
||
})) || []
|
||
|
||
const categoryOptions = categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const topicOptions = (categoryFilter ? categoryTopics?.data : topics?.data)?.map((t) => ({
|
||
value: String(t.id),
|
||
label: t.name || '',
|
||
})) || []
|
||
|
||
const targetSystemOptions = TARGET_SYSTEMS.map((s) => ({
|
||
value: s.value,
|
||
label: s.label,
|
||
}))
|
||
|
||
// ✅ Обработчик изменения фильтров - сбрасывает страницу и выделение
|
||
const handleFilterChange =
|
||
(setter: (value: string | null) => void) => (value: string | null) => {
|
||
setter(value)
|
||
// Если меняется категория, сбрасываем тему
|
||
if (setter === setCategoryFilter) {
|
||
setTopicFilter(null)
|
||
}
|
||
}
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить этого исполнителя?
|
||
Задачи по этой теме не будут назначаться данному пользователю.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteExecutor.mutate(id),
|
||
})
|
||
}
|
||
|
||
const handleEditExecutor = (id: number) => {
|
||
const executor = data?.data?.find((e) => e.id === id)
|
||
if (executor) {
|
||
setEditExecutor(executor)
|
||
}
|
||
}
|
||
|
||
const handleAddExecutor = (group: TopicExecutorsGroup) => {
|
||
setPresetGroup(group)
|
||
setCreateModalOpened(true)
|
||
}
|
||
|
||
const handleCloseModal = () => {
|
||
setEditExecutor(null)
|
||
setCreateModalOpened(false)
|
||
setPresetGroup(null)
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
{/* Заголовок - адаптирован под дизайн Hierarchies */}
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Исполнители тем</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.data?.length || 0}
|
||
</Text>
|
||
<SegmentedControl
|
||
value={viewMode}
|
||
onChange={(v) => setViewMode(v as ViewMode)}
|
||
data={[
|
||
{ value: 'cards', label: 'Карточки' },
|
||
{ value: 'table', label: 'Таблица' },
|
||
]}
|
||
/>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => {
|
||
setPresetGroup(null)
|
||
setCreateModalOpened(true)
|
||
}}
|
||
>
|
||
Добавить исполнителя
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Подсказка */}
|
||
<Alert icon={<IconInfoCircle size={16} />} color="orange" variant="light">
|
||
<Text size="sm">
|
||
Исполнители — это пользователи, которые выполняют задачи после согласования заявки.
|
||
Каждая тема может иметь несколько исполнителей с разными шагами.
|
||
Поле "Текст задачи" содержит инструкцию для исполнителя.
|
||
</Text>
|
||
</Alert>
|
||
|
||
{/* ✅ Фильтры - адаптированы под дизайн Hierarchies */}
|
||
<Paper withBorder p="md">
|
||
<Stack gap="md">
|
||
<Group gap="md" align="flex-end">
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Все категории"
|
||
data={categoryOptions}
|
||
value={categoryFilter}
|
||
onChange={handleFilterChange(setCategoryFilter)}
|
||
clearable
|
||
searchable
|
||
style={{ flex: 1, minWidth: 250 }}
|
||
/>
|
||
<Select
|
||
label="Тема"
|
||
placeholder="Все темы"
|
||
data={topicOptions}
|
||
value={topicFilter}
|
||
onChange={handleFilterChange(setTopicFilter)}
|
||
clearable
|
||
searchable
|
||
style={{ flex: 1, minWidth: 250 }}
|
||
/>
|
||
</Group>
|
||
<Group gap="md" align="flex-end">
|
||
<Select
|
||
label="Исполнитель"
|
||
placeholder="Все исполнители"
|
||
data={userOptions}
|
||
value={userFilter}
|
||
onChange={handleFilterChange(setUserFilter)}
|
||
clearable
|
||
searchable
|
||
style={{ flex: 1, minWidth: 250 }}
|
||
/>
|
||
<Select
|
||
label="Целевая система"
|
||
placeholder="Все системы"
|
||
data={targetSystemOptions}
|
||
value={targetSystemFilter}
|
||
onChange={handleFilterChange(setTargetSystemFilter)}
|
||
clearable
|
||
style={{ flex: 1, minWidth: 200 }}
|
||
/>
|
||
</Group>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Контент */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : viewMode === 'cards' ? (
|
||
<ScrollArea p="md">
|
||
<Stack gap="md">
|
||
{groups.length === 0 ? (
|
||
<Center p={40}>
|
||
<Text c="dimmed">Исполнители не найдены</Text>
|
||
</Center>
|
||
) : (
|
||
groups.map((group) => (
|
||
<TopicExecutorsCard
|
||
key={group.topicId}
|
||
group={group}
|
||
onEditExecutor={handleEditExecutor}
|
||
onDeleteExecutor={handleDelete}
|
||
onAddExecutor={handleAddExecutor}
|
||
/>
|
||
))
|
||
)}
|
||
</Stack>
|
||
</ScrollArea>
|
||
) : (
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Тема</Table.Th>
|
||
<Table.Th>Исполнитель</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Шаг</Table.Th>
|
||
<Table.Th>Задача</Table.Th>
|
||
<Table.Th style={{ width: 120 }}>Система</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Файл</Table.Th>
|
||
<Table.Th style={{ width: 80 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={9}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Исполнители не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
data?.data?.map((executor) => (
|
||
<Table.Tr key={executor.id}>
|
||
<Table.Td>{executor.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" fw={500}>
|
||
{executor.topic?.name || '—'}
|
||
</Text>
|
||
<Text size="xs" c="dimmed" ff="monospace">
|
||
{executor.topic?.code}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" fw={500}>
|
||
{executor.user?.full_name || '—'}
|
||
</Text>
|
||
<Text size="xs" c="dimmed">
|
||
{executor.user?.department?.name}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge variant="light" color="orange">
|
||
#{executor.step_order}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="xs" lineClamp={2}>
|
||
{executor.task_text || '—'}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color={TARGET_SYSTEM_COLORS[executor.target_system || ''] || 'gray'}
|
||
>
|
||
{TARGET_SYSTEM_LABELS[executor.target_system || ''] || executor.target_system}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
{executor.require_file ? (
|
||
<IconFile size={16} color="var(--mantine-color-violet-6)" />
|
||
) : (
|
||
<Text size="xs" c="dimmed">—</Text>
|
||
)}
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color={executor.is_active ? 'green' : 'gray'}
|
||
leftSection={executor.is_active ? <IconCheck size={10} /> : <IconX size={10} />}
|
||
>
|
||
{executor.is_active ? 'Активен' : 'Неактивен'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditExecutor(executor)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(executor.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
{/* Модальные окна */}
|
||
<TopicExecutorEditModal
|
||
executor={editExecutor}
|
||
opened={editExecutor !== null}
|
||
onClose={handleCloseModal}
|
||
/>
|
||
|
||
<TopicExecutorEditModal
|
||
executor={null}
|
||
presetGroup={presetGroup}
|
||
opened={createModalOpened}
|
||
onClose={handleCloseModal}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/topicExecutors/TopicExecutorsPage.tsx-----
|
||
|
||
File: src/pages/topicExecutors/components/TopicExecutorEditModal.tsx
|
||
Lines: 233
|
||
-----BEGIN src/pages/topicExecutors/components/TopicExecutorEditModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
Select,
|
||
NumberInput,
|
||
Textarea,
|
||
Switch,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
useCreateTopicExecutor,
|
||
useUpdateTopicExecutor
|
||
} from '@/features/topicExecutors/hooks/useTopicExecutors'
|
||
import { useUsers } from '@/features/users/hooks/useUsers'
|
||
import { useTopics } from '@/features/topics/hooks/useTopics'
|
||
import { TARGET_SYSTEMS } from '@/features/topicExecutors/utils'
|
||
import type { ApprovalTopicExecutor } from '@/types/api'
|
||
import type { TopicExecutorsGroup } from '@/features/topicExecutors/utils'
|
||
|
||
interface TopicExecutorEditModalProps {
|
||
executor: ApprovalTopicExecutor | null
|
||
presetGroup?: TopicExecutorsGroup | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function TopicExecutorEditModal({
|
||
executor,
|
||
presetGroup,
|
||
opened,
|
||
onClose
|
||
}: TopicExecutorEditModalProps) {
|
||
const createExecutor = useCreateTopicExecutor()
|
||
const updateExecutor = useUpdateTopicExecutor()
|
||
|
||
const { data: users } = useUsers({ limit: 1000 })
|
||
const { data: topics } = useTopics({ limit: 1000 })
|
||
|
||
const isEditMode = executor !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
topic_id: null as number | null,
|
||
user_id: null as number | null,
|
||
step_order: 0,
|
||
require_file: false,
|
||
task_text: '',
|
||
is_active: true,
|
||
target_system: 'all',
|
||
},
|
||
validate: {
|
||
topic_id: (v) => (v === null ? 'Выберите тему' : null),
|
||
user_id: (v) => (v === null ? 'Выберите исполнителя' : null),
|
||
},
|
||
})
|
||
|
||
// Заполняем форму данными
|
||
useEffect(() => {
|
||
if (executor) {
|
||
form.setValues({
|
||
topic_id: executor.topic_id || null,
|
||
user_id: executor.user_id || null,
|
||
step_order: executor.step_order ?? 0,
|
||
require_file: executor.require_file ?? false,
|
||
task_text: executor.task_text || '',
|
||
is_active: executor.is_active ?? true,
|
||
target_system: executor.target_system || 'all',
|
||
})
|
||
} else if (presetGroup) {
|
||
// Предзаполняем из группы
|
||
form.setValues({
|
||
topic_id: presetGroup.topicId,
|
||
user_id: null,
|
||
step_order: presetGroup.executors.length,
|
||
require_file: false,
|
||
task_text: '',
|
||
is_active: true,
|
||
target_system: 'all',
|
||
})
|
||
} else {
|
||
form.reset()
|
||
}
|
||
}, [executor, presetGroup, opened])
|
||
|
||
// Опции
|
||
const userOptions = users?.data?.map((u) => ({
|
||
value: String(u.id),
|
||
label: u.full_name || `Пользователь #${u.id}`,
|
||
description: u.department?.name,
|
||
})) || []
|
||
|
||
const topicOptions = topics?.data?.map((t) => ({
|
||
value: String(t.id),
|
||
label: t.name || '',
|
||
description: t.category?.name,
|
||
})) || []
|
||
|
||
const targetSystemOptions = TARGET_SYSTEMS.map((s) => ({
|
||
value: s.value,
|
||
label: s.label,
|
||
}))
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
const payload = {
|
||
topic_id: values.topic_id!,
|
||
user_id: values.user_id!,
|
||
step_order: values.step_order,
|
||
require_file: values.require_file,
|
||
task_text: values.task_text || null,
|
||
is_active: values.is_active,
|
||
target_system: values.target_system,
|
||
}
|
||
|
||
if (isEditMode && executor?.id) {
|
||
await updateExecutor.mutateAsync({
|
||
id: executor.id,
|
||
...payload,
|
||
})
|
||
} else {
|
||
await createExecutor.mutateAsync(payload)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isSubmitting = createExecutor.isPending || updateExecutor.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование исполнителя' : 'Добавление исполнителя'}
|
||
</Text>
|
||
{executor && <Badge variant="light">ID: {executor.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="lg"
|
||
>
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
{/* Тема */}
|
||
<Select
|
||
label="Тема согласования"
|
||
placeholder="Выберите тему"
|
||
data={topicOptions}
|
||
value={form.values.topic_id ? String(form.values.topic_id) : null}
|
||
onChange={(v) => form.setFieldValue('topic_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
disabled={isEditMode || !!presetGroup}
|
||
description="Тема, для которой назначается исполнитель"
|
||
/>
|
||
|
||
{/* Исполнитель */}
|
||
<Select
|
||
label="Исполнитель"
|
||
placeholder="Выберите пользователя"
|
||
data={userOptions}
|
||
value={form.values.user_id ? String(form.values.user_id) : null}
|
||
onChange={(v) => form.setFieldValue('user_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
description="Пользователь, который будет выполнять задачу"
|
||
/>
|
||
|
||
{/* Порядок шага */}
|
||
<NumberInput
|
||
label="Порядок шага (step_order)"
|
||
description="0 = первый шаг, 1 = второй и т.д."
|
||
value={form.values.step_order}
|
||
onChange={(v) => form.setFieldValue('step_order', Number(v) || 0)}
|
||
min={0}
|
||
required
|
||
/>
|
||
|
||
{/* Целевая система */}
|
||
<Select
|
||
label="Целевая система"
|
||
placeholder="Выберите систему"
|
||
data={targetSystemOptions}
|
||
value={form.values.target_system}
|
||
onChange={(v) => form.setFieldValue('target_system', v || 'all')}
|
||
description="Система, в которой будет выполняться задача"
|
||
/>
|
||
|
||
{/* Текст задачи */}
|
||
<Textarea
|
||
label="Текст задачи"
|
||
placeholder="Опишите, что нужно сделать..."
|
||
value={form.values.task_text}
|
||
onChange={(e) => form.setFieldValue('task_text', e.currentTarget.value)}
|
||
minRows={3}
|
||
description="Инструкция для исполнителя"
|
||
/>
|
||
|
||
{/* Требует файл */}
|
||
<Switch
|
||
label="Требуется файл"
|
||
description="Исполнитель должен прикрепить файл при выполнении задачи"
|
||
checked={form.values.require_file}
|
||
onChange={(e) => form.setFieldValue('require_file', e.currentTarget.checked)}
|
||
/>
|
||
|
||
{/* Активен */}
|
||
<Switch
|
||
label="Активен"
|
||
description="Неактивные исполнители не будут получать задачи"
|
||
checked={form.values.is_active}
|
||
onChange={(e) => form.setFieldValue('is_active', e.currentTarget.checked)}
|
||
/>
|
||
|
||
{/* Кнопки */}
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Добавить'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/topicExecutors/components/TopicExecutorEditModal.tsx-----
|
||
|
||
File: src/pages/topicExecutors/components/TopicExecutorsCard.tsx
|
||
Lines: 218
|
||
-----BEGIN src/pages/topicExecutors/components/TopicExecutorsCard.tsx-----
|
||
import {
|
||
Paper,
|
||
Group,
|
||
Stack,
|
||
Text,
|
||
Badge,
|
||
ActionIcon,
|
||
Avatar,
|
||
Box,
|
||
Tooltip,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import {
|
||
IconPencil,
|
||
IconTrash,
|
||
IconUserPlus,
|
||
IconBriefcase,
|
||
IconCategory,
|
||
IconFile,
|
||
IconCheck,
|
||
IconX,
|
||
} from '@tabler/icons-react'
|
||
import type { TopicExecutorsGroup } from '@/features/topicExecutors/utils'
|
||
import { TARGET_SYSTEM_LABELS, TARGET_SYSTEM_COLORS } from '@/features/topicExecutors/utils'
|
||
|
||
interface TopicExecutorsCardProps {
|
||
group: TopicExecutorsGroup
|
||
onEditExecutor: (executorId: number) => void
|
||
onDeleteExecutor: (executorId: number) => void
|
||
onAddExecutor: (group: TopicExecutorsGroup) => void
|
||
}
|
||
|
||
export default function TopicExecutorsCard({
|
||
group,
|
||
onEditExecutor,
|
||
onDeleteExecutor,
|
||
onAddExecutor,
|
||
}: TopicExecutorsCardProps) {
|
||
return (
|
||
<Paper withBorder p="md" mb="md">
|
||
{/* Заголовок темы */}
|
||
<Group justify="space-between" mb="md">
|
||
<Group gap="md">
|
||
<Avatar size="sm" radius="xl" color="orange">
|
||
<IconBriefcase size={16} />
|
||
</Avatar>
|
||
<Stack gap={0}>
|
||
<Text fw={600} size="sm">{group.topicName}</Text>
|
||
<Text size="xs" c="dimmed" ff="monospace">{group.topicCode}</Text>
|
||
{group.categoryName && (
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color="blue"
|
||
leftSection={<IconCategory size={10} />}
|
||
mt={4}
|
||
>
|
||
{group.categoryName}
|
||
</Badge>
|
||
)}
|
||
</Stack>
|
||
</Group>
|
||
|
||
<Tooltip label="Добавить исполнителя">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="green"
|
||
onClick={() => onAddExecutor(group)}
|
||
>
|
||
<IconUserPlus size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
|
||
{/* Список исполнителей */}
|
||
<Box>
|
||
{group.executors.length === 0 ? (
|
||
<Text size="sm" c="dimmed" ta="center" py="md">
|
||
Исполнители не назначены
|
||
</Text>
|
||
) : (
|
||
<Stack gap="xs">
|
||
{group.executors.map((executor, index) => (
|
||
<Paper
|
||
key={executor.id}
|
||
withBorder
|
||
p="sm"
|
||
style={{
|
||
cursor: 'pointer',
|
||
transition: 'all 0.2s',
|
||
opacity: executor.is_active ? 1 : 0.6,
|
||
}}
|
||
onClick={() => onEditExecutor(executor.id!)}
|
||
className="hover-shadow"
|
||
>
|
||
<Stack gap="xs">
|
||
{/* Верхняя строка: исполнитель и метаданные */}
|
||
<Group justify="space-between">
|
||
<Group gap="sm">
|
||
<Badge
|
||
variant="light"
|
||
color="orange"
|
||
size="sm"
|
||
>
|
||
Шаг #{executor.step_order ?? index}
|
||
</Badge>
|
||
<Avatar size="sm" radius="xl" color="orange">
|
||
{executor.user?.full_name?.charAt(0) || '?'}
|
||
</Avatar>
|
||
<Stack gap={0}>
|
||
<Text size="sm" fw={500}>
|
||
{executor.user?.full_name || '—'}
|
||
</Text>
|
||
{executor.user?.department?.name && (
|
||
<Text size="xs" c="dimmed">
|
||
{executor.user.department.name}
|
||
</Text>
|
||
)}
|
||
</Stack>
|
||
</Group>
|
||
|
||
<Group gap={4}>
|
||
{/* Целевая система */}
|
||
{executor.target_system && (
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color={TARGET_SYSTEM_COLORS[executor.target_system] || 'gray'}
|
||
>
|
||
{TARGET_SYSTEM_LABELS[executor.target_system] || executor.target_system}
|
||
</Badge>
|
||
)}
|
||
|
||
{/* Требует файл */}
|
||
{executor.require_file && (
|
||
<Tooltip label="Требуется файл">
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color="violet"
|
||
leftSection={<IconFile size={10} />}
|
||
>
|
||
Файл
|
||
</Badge>
|
||
</Tooltip>
|
||
)}
|
||
|
||
{/* Активен/неактивен */}
|
||
<Badge
|
||
size="xs"
|
||
variant="light"
|
||
color={executor.is_active ? 'green' : 'gray'}
|
||
leftSection={executor.is_active ? <IconCheck size={10} /> : <IconX size={10} />}
|
||
>
|
||
{executor.is_active ? 'Активен' : 'Неактивен'}
|
||
</Badge>
|
||
|
||
{/* Кнопки действий */}
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="blue"
|
||
size="sm"
|
||
onClick={(e) => {
|
||
e.stopPropagation()
|
||
onEditExecutor(executor.id!)
|
||
}}
|
||
>
|
||
<IconPencil size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="subtle"
|
||
color="red"
|
||
size="sm"
|
||
onClick={(e) => {
|
||
e.stopPropagation()
|
||
onDeleteExecutor(executor.id!)
|
||
}}
|
||
>
|
||
<IconTrash size={14} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Текст задачи */}
|
||
{executor.task_text && (
|
||
<Paper
|
||
withBorder
|
||
p="xs"
|
||
bg="gray.0"
|
||
style={{ borderRadius: 4 }}
|
||
>
|
||
<Text size="xs" c="dimmed" mb={4} fw={500}>
|
||
Задача:
|
||
</Text>
|
||
<Text size="xs" style={{ whiteSpace: 'pre-wrap' }}>
|
||
{executor.task_text}
|
||
</Text>
|
||
</Paper>
|
||
)}
|
||
</Stack>
|
||
</Paper>
|
||
))}
|
||
</Stack>
|
||
)}
|
||
</Box>
|
||
|
||
<style>{`
|
||
.hover-shadow:hover {
|
||
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
|
||
border-color: var(--mantine-color-orange-4);
|
||
}
|
||
`}</style>
|
||
</Paper>
|
||
)
|
||
}
|
||
-----END src/pages/topicExecutors/components/TopicExecutorsCard.tsx-----
|
||
|
||
File: src/pages/topics/TopicsPage.tsx
|
||
Lines: 268
|
||
-----BEGIN src/pages/topics/TopicsPage.tsx-----
|
||
import { useState } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Button,
|
||
Text,
|
||
TextInput,
|
||
Select,
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Switch,
|
||
} from '@mantine/core'
|
||
import { IconPencil, IconTrash, IconPlus, IconSearch } from '@tabler/icons-react'
|
||
import { modals } from '@mantine/modals'
|
||
import { useTopics, useDeleteTopic } from '@/features/topics/hooks/useTopics'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import TopicEditModal from './components/TopicEditModal'
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function TopicsPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [search, setSearch] = useState('')
|
||
const [categoryFilter, setCategoryFilter] = useState<string | null>(null)
|
||
const [activeFilter, setActiveFilter] = useState<boolean | null>(null)
|
||
const [editTopicId, setEditTopicId] = useState<number | null>(null)
|
||
const [createModalOpened, setCreateModalOpened] = useState(false)
|
||
|
||
const { data, isLoading, isFetching } = useTopics({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(search && { name: search }),
|
||
...(categoryFilter && { category_id: Number(categoryFilter) }),
|
||
...(activeFilter !== null && { is_active: activeFilter }),
|
||
})
|
||
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
const deleteTopic = useDeleteTopic()
|
||
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
|
||
const categoryOptions = categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const handleDelete = (id: number) => {
|
||
modals.openConfirmModal({
|
||
title: 'Подтвердите удаление',
|
||
children: (
|
||
<Text size="sm">
|
||
Вы уверены, что хотите удалить эту тему? Связанные данные (исполнители, иерархия) могут быть затронуты.
|
||
</Text>
|
||
),
|
||
labels: { confirm: 'Удалить', cancel: 'Отмена' },
|
||
confirmProps: { color: 'red' },
|
||
onConfirm: () => deleteTopic.mutate(id),
|
||
})
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Темы согласований</Text>
|
||
<Group>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
<Button
|
||
leftSection={<IconPlus size={16} />}
|
||
onClick={() => setCreateModalOpened(true)}
|
||
>
|
||
Создать тему
|
||
</Button>
|
||
</Group>
|
||
</Group>
|
||
|
||
{/* Фильтры */}
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<TextInput
|
||
label="Поиск по названию"
|
||
placeholder="Отпуск, больничный..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Все категории"
|
||
data={categoryOptions}
|
||
value={categoryFilter}
|
||
onChange={(v) => {
|
||
setCategoryFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
searchable
|
||
style={{ minWidth: 200 }}
|
||
/>
|
||
|
||
<Switch
|
||
label="Только активные"
|
||
checked={activeFilter === true}
|
||
onChange={(e) => {
|
||
setActiveFilter(e.currentTarget.checked ? true : null)
|
||
setPage(1)
|
||
}}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
{/* Таблица */}
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Название</Table.Th>
|
||
<Table.Th>Категория</Table.Th>
|
||
<Table.Th>Код</Table.Th>
|
||
<Table.Th>Параметры</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Статус</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{data?.data?.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={7}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Темы не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
(data?.data || []).map((topic) => (
|
||
<Table.Tr key={topic.id}>
|
||
<Table.Td>{topic.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text fw={500} size="sm">{topic.name}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge size="xs" variant="light" color="blue">
|
||
{topic.category?.name || '—'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="xs" ff="monospace" c="dimmed">
|
||
{topic.code}
|
||
</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap={4}>
|
||
{topic.duration_type && (
|
||
<Badge size="xs" variant="light" color="cyan">
|
||
{topic.duration_type}
|
||
</Badge>
|
||
)}
|
||
{topic.time_type && (
|
||
<Badge size="xs" variant="light" color="teal">
|
||
{topic.time_type}
|
||
</Badge>
|
||
)}
|
||
{topic.payment_type && (
|
||
<Badge size="xs" variant="light" color="violet">
|
||
{topic.payment_type}
|
||
</Badge>
|
||
)}
|
||
{topic.requires_file && (
|
||
<Badge size="xs" variant="light" color="orange">
|
||
Файл
|
||
</Badge>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Badge
|
||
color={topic.is_active ? 'green' : 'gray'}
|
||
variant={topic.is_active ? 'light' : 'filled'}
|
||
>
|
||
{topic.is_active ? 'Активна' : 'Неактивна'}
|
||
</Badge>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap="xs">
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditTopicId(topic.id!)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
<Tooltip label="Удалить">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => handleDelete(topic.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
<TopicEditModal
|
||
topicId={editTopicId}
|
||
opened={editTopicId !== null}
|
||
onClose={() => setEditTopicId(null)}
|
||
/>
|
||
|
||
<TopicEditModal
|
||
topicId={null}
|
||
opened={createModalOpened}
|
||
onClose={() => setCreateModalOpened(false)}
|
||
/>
|
||
</Stack>
|
||
)
|
||
}
|
||
-----END src/pages/topics/TopicsPage.tsx-----
|
||
|
||
File: src/pages/topics/components/TopicEditModal.tsx
|
||
Lines: 348
|
||
-----BEGIN src/pages/topics/components/TopicEditModal.tsx-----
|
||
import { useEffect } from 'react'
|
||
import {
|
||
Modal,
|
||
Stack,
|
||
TextInput,
|
||
Textarea,
|
||
Select,
|
||
Switch,
|
||
Group,
|
||
Button,
|
||
Text,
|
||
Loader,
|
||
Center,
|
||
Badge,
|
||
Paper,
|
||
} from '@mantine/core'
|
||
import { useForm } from '@mantine/form'
|
||
import {
|
||
useTopic,
|
||
useCreateTopic,
|
||
useUpdateTopic
|
||
} from '@/features/topics/hooks/useTopics'
|
||
import { useCategories } from '@/features/categories/hooks/useCategories'
|
||
import {
|
||
DURATION_TYPES,
|
||
TIME_TYPES,
|
||
PAYMENT_TYPES,
|
||
APPROVAL_MODES,
|
||
} from '@/features/topics/constants'
|
||
|
||
interface TopicEditModalProps {
|
||
topicId: number | null
|
||
opened: boolean
|
||
onClose: () => void
|
||
}
|
||
|
||
export default function TopicEditModal({
|
||
topicId,
|
||
opened,
|
||
onClose
|
||
}: TopicEditModalProps) {
|
||
const { data: topic, isLoading: topicLoading } = useTopic(topicId)
|
||
const { data: categories } = useCategories({ limit: 1000 })
|
||
|
||
const createTopic = useCreateTopic()
|
||
const updateTopic = useUpdateTopic()
|
||
|
||
const isEditMode = topicId !== null
|
||
|
||
const form = useForm({
|
||
initialValues: {
|
||
category_id: null as number | null,
|
||
name: '',
|
||
code: '',
|
||
duration_type: '',
|
||
time_type: '',
|
||
payment_type: '',
|
||
template: '',
|
||
allows_file: false,
|
||
is_active: true,
|
||
allow_approver_selection: false,
|
||
first_approver_role_code: '',
|
||
allow_observer_selection: false,
|
||
// 🆕 Делегирование обязанностей на время отсутствия — актуально
|
||
// для тем категорий "Отгул"/"Отпуск"/"Больничный".
|
||
allow_delegation_selection: false,
|
||
approval_mode: 'sequential',
|
||
require_approver_comment: false,
|
||
requires_file: false,
|
||
require_observer_selection: false,
|
||
instructions: '',
|
||
is_tree_root: false,
|
||
},
|
||
validate: {
|
||
category_id: (v) => (v === null ? 'Выберите категорию' : null),
|
||
name: (v: string | any[]) => (v.length < 2 ? 'Название должно содержать минимум 2 символа' : null),
|
||
code: (v: string | any[]) => {
|
||
if (v.length < 2) return 'Код должен содержать минимум 2 символа'
|
||
if (!/^[a-z0-9_]+$/.test(v as string)) return 'Код должен содержать только lowercase буквы, цифры и подчеркивания'
|
||
return null
|
||
},
|
||
},
|
||
})
|
||
|
||
useEffect(() => {
|
||
if (topic) {
|
||
form.setValues({
|
||
category_id: topic.category_id || null,
|
||
name: topic.name || '',
|
||
code: topic.code || '',
|
||
duration_type: topic.duration_type || '',
|
||
time_type: topic.time_type || '',
|
||
payment_type: topic.payment_type || '',
|
||
template: topic.template || '',
|
||
allows_file: topic.allows_file ?? false,
|
||
is_active: topic.is_active ?? true,
|
||
allow_approver_selection: topic.allow_approver_selection ?? false,
|
||
first_approver_role_code: topic.first_approver_role_code || '',
|
||
allow_observer_selection: topic.allow_observer_selection ?? false,
|
||
allow_delegation_selection: topic.allow_delegation_selection ?? false,
|
||
approval_mode: topic.approval_mode || 'sequential',
|
||
require_approver_comment: topic.require_approver_comment ?? false,
|
||
requires_file: topic.requires_file ?? false,
|
||
require_observer_selection: topic.require_observer_selection ?? false,
|
||
instructions: topic.instructions || '',
|
||
})
|
||
} else if (!isEditMode) {
|
||
form.reset()
|
||
}
|
||
}, [topic, isEditMode])
|
||
|
||
const categoryOptions = categories?.data?.map((c) => ({
|
||
value: String(c.id),
|
||
label: c.name || '',
|
||
})) || []
|
||
|
||
const handleSubmit = async (values: typeof form.values) => {
|
||
const payload = {
|
||
category_id: values.category_id!,
|
||
name: values.name,
|
||
code: values.code,
|
||
duration_type: values.duration_type || undefined,
|
||
time_type: values.time_type || undefined,
|
||
payment_type: values.payment_type || undefined,
|
||
template: values.template || null,
|
||
allows_file: values.allows_file,
|
||
is_active: values.is_active,
|
||
allow_approver_selection: values.allow_approver_selection,
|
||
first_approver_role_code: values.first_approver_role_code || null,
|
||
allow_observer_selection: values.allow_observer_selection,
|
||
allow_delegation_selection: values.allow_delegation_selection,
|
||
approval_mode: values.approval_mode,
|
||
require_approver_comment: values.require_approver_comment,
|
||
requires_file: values.requires_file,
|
||
require_observer_selection: values.require_observer_selection,
|
||
instructions: values.instructions || null,
|
||
}
|
||
|
||
if (isEditMode && topicId) {
|
||
await updateTopic.mutateAsync({ id: topicId, ...payload })
|
||
} else {
|
||
await createTopic.mutateAsync(payload)
|
||
}
|
||
onClose()
|
||
}
|
||
|
||
const isLoading = topicLoading
|
||
const isSubmitting = createTopic.isPending || updateTopic.isPending
|
||
|
||
return (
|
||
<Modal
|
||
opened={opened}
|
||
onClose={onClose}
|
||
title={
|
||
<Group>
|
||
<Text fw={700}>
|
||
{isEditMode ? 'Редактирование темы' : 'Создание темы'}
|
||
</Text>
|
||
{topic && <Badge variant="light">ID: {topic.id}</Badge>}
|
||
</Group>
|
||
}
|
||
size="xl"
|
||
>
|
||
{isLoading ? (
|
||
<Center p={40}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<form onSubmit={form.onSubmit(handleSubmit)}>
|
||
<Stack gap="md">
|
||
{/* Основные поля */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">Основные параметры</Text>
|
||
<Stack gap="md">
|
||
<Select
|
||
label="Категория"
|
||
placeholder="Выберите категорию"
|
||
data={categoryOptions}
|
||
value={form.values.category_id ? String(form.values.category_id) : null}
|
||
onChange={(v) => form.setFieldValue('category_id', v ? Number(v) : null)}
|
||
searchable
|
||
required
|
||
/>
|
||
|
||
<TextInput
|
||
label="Название"
|
||
placeholder="Отпуск — несколько дней"
|
||
required
|
||
{...form.getInputProps('name')}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Код"
|
||
placeholder="vacation_multi_day"
|
||
required
|
||
description="Уникальный идентификатор (lowercase, цифры, подчеркивания)"
|
||
disabled={isEditMode}
|
||
{...form.getInputProps('code')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Шаблон текста заявки"
|
||
placeholder="Пример заполнения..."
|
||
minRows={3}
|
||
{...form.getInputProps('template')}
|
||
/>
|
||
|
||
<Textarea
|
||
label="Инструкция для согласующего"
|
||
placeholder="Что нужно сделать для согласования заявки..."
|
||
minRows={2}
|
||
{...form.getInputProps('instructions')}
|
||
/>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Типы */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">Типы и параметры</Text>
|
||
<Stack gap="md">
|
||
<Select
|
||
label="Тип длительности"
|
||
placeholder="Не указан"
|
||
data={DURATION_TYPES}
|
||
value={form.values.duration_type || null}
|
||
onChange={(v) => form.setFieldValue('duration_type', v || '')}
|
||
clearable
|
||
/>
|
||
|
||
<Select
|
||
label="Тип времени"
|
||
placeholder="Не указан"
|
||
data={TIME_TYPES}
|
||
value={form.values.time_type || null}
|
||
onChange={(v) => form.setFieldValue('time_type', v || '')}
|
||
clearable
|
||
/>
|
||
|
||
<Select
|
||
label="Тип оплаты"
|
||
placeholder="Не указан"
|
||
data={PAYMENT_TYPES}
|
||
value={form.values.payment_type || null}
|
||
onChange={(v) => form.setFieldValue('payment_type', v || '')}
|
||
clearable
|
||
/>
|
||
|
||
<Select
|
||
label="Режим согласования"
|
||
data={APPROVAL_MODES}
|
||
value={form.values.approval_mode || 'sequential'}
|
||
onChange={(v) => form.setFieldValue('approval_mode', v || 'sequential')}
|
||
/>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Настройки согласования */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">Настройки согласования</Text>
|
||
<Stack gap="sm">
|
||
<Switch
|
||
label="Выбор согласующего из иерархии"
|
||
description="Пользователь может выбрать согласующего из списка людей, прописанных в иерархии (user_hierarchy) для этой темы"
|
||
checked={form.values.allow_approver_selection}
|
||
onChange={(e) => form.setFieldValue('allow_approver_selection', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<TextInput
|
||
label="Код роли первого согласующего"
|
||
placeholder="supervisor, manager..."
|
||
description="Если указан — первый согласующий выбирается из пользователей с этой ролью. Работает независимо от выбора из иерархии."
|
||
value={form.values.first_approver_role_code}
|
||
onChange={(e) => form.setFieldValue('first_approver_role_code', e.currentTarget.value)}
|
||
/>
|
||
|
||
<Switch
|
||
label="Разрешить выбор наблюдателя"
|
||
description="Пользователь может добавить наблюдателей"
|
||
checked={form.values.allow_observer_selection}
|
||
onChange={(e) => form.setFieldValue('allow_observer_selection', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<Switch
|
||
label="Требовать выбор наблюдателя"
|
||
description="Наблюдатель обязателен"
|
||
checked={form.values.require_observer_selection}
|
||
onChange={(e) => form.setFieldValue('require_observer_selection', e.currentTarget.checked)}
|
||
disabled={!form.values.allow_observer_selection}
|
||
/>
|
||
|
||
<Switch
|
||
label="Требовать комментарий согласующего"
|
||
description="Согласующий должен оставить комментарий"
|
||
checked={form.values.require_approver_comment}
|
||
onChange={(e) => form.setFieldValue('require_approver_comment', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<Switch
|
||
label="Разрешить делегирование обязанностей"
|
||
description="В конце заявки сотруднику предложат делегировать все согласования на время отсутствия другому человеку (актуально для отгула/отпуска/больничного)"
|
||
checked={form.values.allow_delegation_selection}
|
||
onChange={(e) => form.setFieldValue('allow_delegation_selection', e.currentTarget.checked)}
|
||
/>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Файлы */}
|
||
<Paper withBorder p="md">
|
||
<Text size="sm" fw={600} mb="sm">Файлы</Text>
|
||
<Stack gap="sm">
|
||
<Switch
|
||
label="Разрешить прикрепление файлов"
|
||
description="Пользователь может прикрепить файлы"
|
||
checked={form.values.allows_file}
|
||
onChange={(e) => form.setFieldValue('allows_file', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<Switch
|
||
label="Требовать файл"
|
||
description="Файл обязателен для подачи заявки"
|
||
checked={form.values.requires_file}
|
||
onChange={(e) => form.setFieldValue('requires_file', e.currentTarget.checked)}
|
||
disabled={!form.values.allows_file}
|
||
/>
|
||
</Stack>
|
||
</Paper>
|
||
|
||
{/* Статус */}
|
||
<Switch
|
||
label="Активна"
|
||
description="Неактивные темы не будут доступны для создания заявок"
|
||
checked={form.values.is_active}
|
||
onChange={(e) => form.setFieldValue('is_active', e.currentTarget.checked)}
|
||
/>
|
||
|
||
<Group justify="flex-end" mt="md">
|
||
<Button variant="default" onClick={onClose} disabled={isSubmitting}>
|
||
Отмена
|
||
</Button>
|
||
<Button type="submit" loading={isSubmitting}>
|
||
{isEditMode ? 'Сохранить' : 'Создать'}
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</form>
|
||
)}
|
||
</Modal>
|
||
)
|
||
}
|
||
-----END src/pages/topics/components/TopicEditModal.tsx-----
|
||
|
||
File: src/pages/users/UsersPage.tsx
|
||
Lines: 330
|
||
-----BEGIN src/pages/users/UsersPage.tsx-----
|
||
import { useState, useMemo } from 'react'
|
||
import {
|
||
Paper,
|
||
Table,
|
||
Badge,
|
||
Group,
|
||
ActionIcon,
|
||
Text,
|
||
TextInput,
|
||
Select,
|
||
MultiSelect, // ✅ Добавлен
|
||
Pagination,
|
||
Loader,
|
||
Center,
|
||
Tooltip,
|
||
Box,
|
||
Stack,
|
||
Modal,
|
||
Button,
|
||
} from '@mantine/core'
|
||
import { IconPencil, IconSearch, IconTrash } from '@tabler/icons-react'
|
||
import { useUsers, useDeleteUser } from '@/features/users/hooks/useUsers'
|
||
import { useDepartments } from '@/features/users/hooks/useDepartments'
|
||
import { useRoles } from '@/features/users/hooks/useRoles' // ✅ Добавлен
|
||
import UserEditModal from "@/components/UserEditModal.tsx"
|
||
import { useAuth } from '@/hooks/useAuth'
|
||
|
||
const LIMIT = 20
|
||
|
||
export default function UsersPage() {
|
||
const [page, setPage] = useState(1)
|
||
const [search, setSearch] = useState('')
|
||
const [selectedRoleIds, setSelectedRoleIds] = useState<number[]>([]) // ✅ Массив ID ролей
|
||
const [departmentFilter, setDepartmentFilter] = useState<string | null>(null)
|
||
const [statusFilter, setStatusFilter] = useState<string | null>(null)
|
||
const [editUserId, setEditUserId] = useState<number | null>(null)
|
||
const [deleteUserId, setDeleteUserId] = useState<number | null>(null)
|
||
|
||
const { user: currentUser } = useAuth()
|
||
const isRootAdmin = currentUser?.is_root === true
|
||
|
||
const { data, isLoading, isFetching } = useUsers({
|
||
offset: (page - 1) * LIMIT,
|
||
limit: LIMIT,
|
||
...(departmentFilter && { department_id: Number(departmentFilter) }),
|
||
...(statusFilter === 'blocked' && { is_blocked: true }),
|
||
...(statusFilter === 'fired' && { is_fired: true }),
|
||
...(statusFilter === 'active' && { is_blocked: false, is_fired: false }),
|
||
...(search && { full_name: search }),
|
||
...(selectedRoleIds.length > 0 && { role_ids: selectedRoleIds }), // ✅ Передаём массив
|
||
})
|
||
|
||
const { data: departments } = useDepartments()
|
||
const { data: allRoles } = useRoles({ limit: 1000 }) // ✅ Получаем все роли
|
||
const deleteUser = useDeleteUser()
|
||
|
||
const departmentOptions = useMemo(() => {
|
||
if (!departments || !Array.isArray(departments)) return []
|
||
return departments.map((d) => ({
|
||
value: String(d.id),
|
||
label: d.name || '',
|
||
}))
|
||
}, [departments])
|
||
|
||
const roleOptions = useMemo(() => {
|
||
if (!allRoles || !Array.isArray(allRoles)) return []
|
||
return allRoles.map((r) => ({
|
||
value: String(r.id),
|
||
label: r.name || '',
|
||
}))
|
||
}, [allRoles])
|
||
|
||
const users = Array.isArray(data?.data) ? data.data : []
|
||
const totalPages = data?.total_count ? Math.ceil(data.total_count / LIMIT) : 1
|
||
const hasSelected = selectedRoleIds.length > 0;
|
||
|
||
const handleDelete = async () => {
|
||
if (!deleteUserId) return
|
||
await deleteUser.mutateAsync(deleteUserId)
|
||
setDeleteUserId(null)
|
||
}
|
||
|
||
return (
|
||
<Stack gap="md">
|
||
<Group justify="space-between">
|
||
<Text size="xl" fw={700}>Пользователи</Text>
|
||
<Text c="dimmed" size="sm">
|
||
Всего: {data?.total_count || 0}
|
||
</Text>
|
||
</Group>
|
||
|
||
<Paper withBorder p="md">
|
||
<Group gap="md" align="flex-end">
|
||
<TextInput
|
||
label="Поиск по имени"
|
||
placeholder="Иванов Иван..."
|
||
leftSection={<IconSearch size={16} />}
|
||
value={search}
|
||
onChange={(e) => {
|
||
setSearch(e.currentTarget.value)
|
||
setPage(1)
|
||
}}
|
||
style={{ flex: 1 }}
|
||
/>
|
||
|
||
<Box style={{ width: 250 }}>
|
||
<MultiSelect
|
||
label="Роли"
|
||
// ✅ Меняем placeholder в зависимости от количества выбранных
|
||
placeholder={hasSelected ? `Выбрано: ${selectedRoleIds.length}` : "Все роли"}
|
||
data={roleOptions}
|
||
value={selectedRoleIds.map(String)}
|
||
onChange={(v) => {
|
||
setSelectedRoleIds(v.map(Number))
|
||
setPage(1)
|
||
}}
|
||
searchable
|
||
clearable
|
||
maxDropdownHeight={400}
|
||
limit={15}
|
||
styles={{
|
||
input: {
|
||
minHeight: 36,
|
||
},
|
||
pill: {
|
||
display: 'none',
|
||
},
|
||
pillsList: {
|
||
display: 'none',
|
||
},
|
||
}}
|
||
/>
|
||
</Box>
|
||
|
||
<Select
|
||
label="Отдел"
|
||
placeholder="Все отделы"
|
||
data={departmentOptions}
|
||
value={departmentFilter}
|
||
onChange={(v) => {
|
||
setDepartmentFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
style={{ minWidth: 200 }}
|
||
/>
|
||
|
||
<Select
|
||
label="Статус"
|
||
placeholder="Все"
|
||
data={[
|
||
{ value: 'active', label: 'Активные' },
|
||
{ value: 'blocked', label: 'Заблокированные' },
|
||
{ value: 'fired', label: 'Уволенные' },
|
||
]}
|
||
value={statusFilter}
|
||
onChange={(v) => {
|
||
setStatusFilter(v)
|
||
setPage(1)
|
||
}}
|
||
clearable
|
||
style={{ minWidth: 180 }}
|
||
/>
|
||
</Group>
|
||
</Paper>
|
||
|
||
<Paper withBorder>
|
||
{isLoading ? (
|
||
<Center p={60}>
|
||
<Loader />
|
||
</Center>
|
||
) : (
|
||
<>
|
||
<Table striped highlightOnHover>
|
||
<Table.Thead>
|
||
<Table.Tr>
|
||
<Table.Th style={{ width: 60 }}>ID</Table.Th>
|
||
<Table.Th>Telegram ID</Table.Th>
|
||
<Table.Th>Имя</Table.Th>
|
||
<Table.Th>Username</Table.Th>
|
||
<Table.Th>Отдел</Table.Th>
|
||
<Table.Th>Роли</Table.Th>
|
||
<Table.Th>Статус</Table.Th>
|
||
<Table.Th style={{ width: 100 }}>Действия</Table.Th>
|
||
</Table.Tr>
|
||
</Table.Thead>
|
||
<Table.Tbody>
|
||
{users.length === 0 ? (
|
||
<Table.Tr>
|
||
<Table.Td colSpan={8}>
|
||
<Center p={40}>
|
||
<Text c="dimmed">Пользователи не найдены</Text>
|
||
</Center>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
) : (
|
||
users.map((user) => (
|
||
<Table.Tr key={user.id}>
|
||
<Table.Td>{user.id}</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" ff="monospace">{user.telegram_id}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text fw={500}>{user.full_name}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Text size="sm" c="dimmed">@{user.username || '—'}</Text>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
{user.department?.name || <Text c="dimmed">—</Text>}
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap={4}>
|
||
{Array.isArray(user.user_roles) ? (
|
||
<>
|
||
{user.user_roles.slice(0, 3).map((ur) => (
|
||
<Badge key={ur.id} size="xs" variant="light">
|
||
{ur.role?.name || 'Роль'}
|
||
</Badge>
|
||
))}
|
||
{user.user_roles.length > 3 && (
|
||
<Badge size="xs" variant="outline">
|
||
+{user.user_roles.length - 3}
|
||
</Badge>
|
||
)}
|
||
</>
|
||
) : (
|
||
<Text size="xs" c="dimmed">—</Text>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<UserStatusBadge
|
||
isBlocked={user.is_blocked}
|
||
isFired={user.is_fired}
|
||
/>
|
||
</Table.Td>
|
||
<Table.Td>
|
||
<Group gap={4}>
|
||
<Tooltip label="Редактировать">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="blue"
|
||
onClick={() => setEditUserId(user.id!)}
|
||
>
|
||
<IconPencil size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
{isRootAdmin && (
|
||
<Tooltip label="Удалить пользователя">
|
||
<ActionIcon
|
||
variant="light"
|
||
color="red"
|
||
onClick={() => setDeleteUserId(user.id!)}
|
||
>
|
||
<IconTrash size={16} />
|
||
</ActionIcon>
|
||
</Tooltip>
|
||
)}
|
||
</Group>
|
||
</Table.Td>
|
||
</Table.Tr>
|
||
))
|
||
)}
|
||
</Table.Tbody>
|
||
</Table>
|
||
|
||
{totalPages > 1 && (
|
||
<Box p="md" style={{ borderTop: '1px solid var(--mantine-color-gray-3)' }}>
|
||
<Group justify="space-between">
|
||
<Text size="sm" c="dimmed">
|
||
Страница {page} из {totalPages}
|
||
</Text>
|
||
<Pagination
|
||
value={page}
|
||
onChange={setPage}
|
||
total={totalPages}
|
||
withEdges
|
||
/>
|
||
</Group>
|
||
</Box>
|
||
)}
|
||
</>
|
||
)}
|
||
</Paper>
|
||
|
||
{isFetching && !isLoading && (
|
||
<Box style={{ position: 'fixed', top: 70, right: 20, zIndex: 1000 }}>
|
||
<Loader size="xs" />
|
||
</Box>
|
||
)}
|
||
|
||
<UserEditModal
|
||
userId={editUserId}
|
||
opened={editUserId !== null}
|
||
onClose={() => setEditUserId(null)}
|
||
/>
|
||
|
||
<Modal
|
||
opened={deleteUserId !== null}
|
||
onClose={() => setDeleteUserId(null)}
|
||
title="Подтверждение удаления"
|
||
size="md"
|
||
>
|
||
<Stack gap="md">
|
||
<Text>
|
||
Вы уверены, что хотите удалить пользователя? Это действие нельзя отменить.
|
||
</Text>
|
||
<Group justify="flex-end">
|
||
<Button variant="default" onClick={() => setDeleteUserId(null)}>
|
||
Отмена
|
||
</Button>
|
||
<Button
|
||
color="red"
|
||
onClick={handleDelete}
|
||
loading={deleteUser.isPending}
|
||
>
|
||
Удалить
|
||
</Button>
|
||
</Group>
|
||
</Stack>
|
||
</Modal>
|
||
</Stack>
|
||
)
|
||
}
|
||
|
||
function UserStatusBadge({ isBlocked, isFired }: { isBlocked?: boolean; isFired?: boolean }) {
|
||
if (isFired) return <Badge color="gray" variant="filled">Уволен</Badge>
|
||
if (isBlocked) return <Badge color="red" variant="filled">Заблокирован</Badge>
|
||
return <Badge color="green" variant="light">Активен</Badge>
|
||
}
|
||
-----END src/pages/users/UsersPage.tsx-----
|
||
|
||
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-----
|
||
|