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