1279 lines
53 KiB
JavaScript
1279 lines
53 KiB
JavaScript
// admin-server.js
|
||
const express = require('express');
|
||
const router = express.Router();
|
||
|
||
// Middleware для проверки прав администратора
|
||
const requireAdmin = (req, res, next) => {
|
||
if (!req.session.user || req.session.user.role !== 'admin') {
|
||
return res.status(403).json({ error: 'Недостаточно прав' });
|
||
}
|
||
next();
|
||
};
|
||
|
||
// Статистика
|
||
router.get('/admin/stats', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
|
||
// Получаем статистику по задачам
|
||
const tasksStats = await new Promise((resolve, reject) => {
|
||
db.get(`
|
||
SELECT
|
||
COUNT(*) as totalTasks,
|
||
COUNT(CASE WHEN status = 'active' AND closed_at IS NULL THEN 1 END) as activeTasks,
|
||
COUNT(CASE WHEN closed_at IS NOT NULL THEN 1 END) as closedTasks,
|
||
COUNT(CASE WHEN status = 'deleted' THEN 1 END) as deletedTasks
|
||
FROM tasks
|
||
`, [], (err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row || { totalTasks: 0, activeTasks: 0, closedTasks: 0, deletedTasks: 0 });
|
||
});
|
||
});
|
||
|
||
// Статистика по назначениям
|
||
const assignmentsStats = await new Promise((resolve, reject) => {
|
||
db.get(`
|
||
SELECT
|
||
COUNT(*) as totalAssignments,
|
||
COUNT(CASE WHEN status = 'assigned' THEN 1 END) as assignedCount,
|
||
COUNT(CASE WHEN status = 'in_progress' THEN 1 END) as inProgressCount,
|
||
COUNT(CASE WHEN status = 'completed' THEN 1 END) as completedCount,
|
||
COUNT(CASE WHEN status = 'overdue' THEN 1 END) as overdueCount,
|
||
COUNT(CASE WHEN status = 'rework' THEN 1 END) as reworkCount
|
||
FROM task_assignments
|
||
`, [], (err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row || { totalAssignments: 0, assignedCount: 0, inProgressCount: 0, completedCount: 0, overdueCount: 0, reworkCount: 0 });
|
||
});
|
||
});
|
||
|
||
// Статистика по пользователям
|
||
const usersStats = await new Promise((resolve, reject) => {
|
||
db.get(`
|
||
SELECT
|
||
COUNT(*) as totalUsers,
|
||
COUNT(CASE WHEN role = 'admin' THEN 1 END) as adminUsers,
|
||
COUNT(CASE WHEN role = 'teacher' THEN 1 END) as teacherUsers,
|
||
COUNT(CASE WHEN auth_type = 'ldap' THEN 1 END) as ldapUsers,
|
||
COUNT(CASE WHEN auth_type = 'local' THEN 1 END) as localUsers
|
||
FROM users
|
||
`, [], (err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row || { totalUsers: 0, adminUsers: 0, teacherUsers: 0, ldapUsers: 0, localUsers: 0 });
|
||
});
|
||
});
|
||
|
||
// Статистика по файлам
|
||
const filesStats = await new Promise((resolve, reject) => {
|
||
db.get(`
|
||
SELECT
|
||
COUNT(*) as totalFiles,
|
||
SUM(file_size) as totalFilesSize
|
||
FROM task_files
|
||
`, [], (err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row || { totalFiles: 0, totalFilesSize: 0 });
|
||
});
|
||
});
|
||
|
||
res.json({
|
||
...tasksStats,
|
||
...assignmentsStats,
|
||
...usersStats,
|
||
...filesStats,
|
||
timestamp: new Date().toISOString()
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка получения статистики:', error);
|
||
res.status(500).json({ error: 'Ошибка получения статистики' });
|
||
}
|
||
});
|
||
|
||
// Получение всех пользователей
|
||
router.get('/admin/users', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
|
||
const query = `
|
||
SELECT id, login, name, email, role, auth_type, groups, description,
|
||
created_at, last_login, updated_at
|
||
FROM users
|
||
ORDER BY name
|
||
`;
|
||
|
||
db.all(query, [], (err, users) => {
|
||
if (err) {
|
||
console.error('Ошибка получения пользователей:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
res.json(users);
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Получение конкретного пользователя
|
||
router.get('/admin/users/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
|
||
const query = `
|
||
SELECT id, login, name, email, role, auth_type, groups, description,
|
||
created_at, last_login, updated_at
|
||
FROM users
|
||
WHERE id = ?
|
||
`;
|
||
|
||
db.get(query, [userId], (err, user) => {
|
||
if (err) {
|
||
console.error('Ошибка получения пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (!user) {
|
||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||
}
|
||
|
||
res.json(user);
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Обновление пользователя
|
||
router.put('/admin/users/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
const { login, name, email, role, auth_type, groups, description } = req.body;
|
||
|
||
if (!login || !name || !email) {
|
||
return res.status(400).json({ error: 'Заполните обязательные поля' });
|
||
}
|
||
|
||
// Проверяем, что пользователь не пытается изменить свою роль на не-админа
|
||
if (req.session.user.id == userId && role !== 'admin') {
|
||
return res.status(400).json({ error: 'Нельзя снять права администратора у себя' });
|
||
}
|
||
|
||
const query = `
|
||
UPDATE users
|
||
SET login = ?, name = ?, email = ?, role = ?, auth_type = ?,
|
||
groups = ?, description = ?, updated_at = CURRENT_TIMESTAMP
|
||
WHERE id = ?
|
||
`;
|
||
|
||
db.run(query, [login, name, email, role, auth_type, groups || '[]', description || '', userId], function(err) {
|
||
if (err) {
|
||
console.error('Ошибка обновления пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (this.changes === 0) {
|
||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||
}
|
||
|
||
res.json({ success: true, message: 'Пользователь обновлен' });
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Удаление пользователя
|
||
router.delete('/admin/users/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
|
||
// Нельзя удалить самого себя
|
||
if (req.session.user.id == userId) {
|
||
return res.status(400).json({ error: 'Нельзя удалить самого себя' });
|
||
}
|
||
|
||
const query = `DELETE FROM users WHERE id = ?`;
|
||
|
||
db.run(query, [userId], function(err) {
|
||
if (err) {
|
||
console.error('Ошибка удаления пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (this.changes === 0) {
|
||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||
}
|
||
|
||
res.json({ success: true, message: 'Пользователь удален' });
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Получение всех задач (для админа)
|
||
router.get('/admin/tasks', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const {
|
||
search = '',
|
||
status = 'all',
|
||
creator = '',
|
||
assignee = '',
|
||
limit = 100,
|
||
offset = 0
|
||
} = req.query;
|
||
|
||
let query = `
|
||
SELECT DISTINCT
|
||
t.*,
|
||
u.name as creator_name,
|
||
u.login as creator_login,
|
||
ot.title as original_task_title,
|
||
ou.name as original_creator_name,
|
||
GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
|
||
GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
|
||
FROM tasks t
|
||
LEFT JOIN users u ON t.created_by = u.id
|
||
LEFT JOIN tasks ot ON t.original_task_id = ot.id
|
||
LEFT JOIN users ou ON ot.created_by = ou.id
|
||
LEFT JOIN task_assignments ta ON t.id = ta.task_id
|
||
LEFT JOIN users u2 ON ta.user_id = u2.id
|
||
WHERE 1=1
|
||
`;
|
||
|
||
const params = [];
|
||
|
||
if (status !== 'all') {
|
||
if (status === 'deleted') {
|
||
query += " AND t.status = 'deleted'";
|
||
} else if (status === 'closed') {
|
||
query += " AND t.closed_at IS NOT NULL";
|
||
} else if (status === 'active') {
|
||
query += " AND t.status = 'active' AND t.closed_at IS NULL";
|
||
}
|
||
}
|
||
|
||
if (creator) {
|
||
query += ` AND t.created_by = ?`;
|
||
params.push(creator);
|
||
}
|
||
|
||
if (assignee) {
|
||
query += ` AND ta.user_id = ?`;
|
||
params.push(assignee);
|
||
}
|
||
|
||
if (search) {
|
||
query += ` AND (t.title LIKE ? OR t.description LIKE ?)`;
|
||
const searchPattern = `%${search}%`;
|
||
params.push(searchPattern, searchPattern);
|
||
}
|
||
|
||
query += " GROUP BY t.id ORDER BY t.created_at DESC LIMIT ? OFFSET ?";
|
||
params.push(parseInt(limit), parseInt(offset));
|
||
|
||
db.all(query, params, (err, tasks) => {
|
||
if (err) {
|
||
console.error('Ошибка получения задач:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
res.json(tasks);
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Получение всех логов активности
|
||
router.get('/admin/activity-logs', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const {
|
||
taskId = '',
|
||
userId = '',
|
||
action = '',
|
||
startDate = '',
|
||
endDate = '',
|
||
limit = 100,
|
||
offset = 0
|
||
} = req.query;
|
||
|
||
let query = `
|
||
SELECT al.*, u.name as user_name, t.title as task_title
|
||
FROM activity_logs al
|
||
LEFT JOIN users u ON al.user_id = u.id
|
||
LEFT JOIN tasks t ON al.task_id = t.id
|
||
WHERE 1=1
|
||
`;
|
||
|
||
const params = [];
|
||
|
||
if (taskId) {
|
||
query += ` AND al.task_id = ?`;
|
||
params.push(taskId);
|
||
}
|
||
|
||
if (userId) {
|
||
query += ` AND al.user_id = ?`;
|
||
params.push(userId);
|
||
}
|
||
|
||
if (action) {
|
||
query += ` AND al.action = ?`;
|
||
params.push(action);
|
||
}
|
||
|
||
if (startDate) {
|
||
query += ` AND al.created_at >= ?`;
|
||
params.push(startDate);
|
||
}
|
||
|
||
if (endDate) {
|
||
query += ` AND al.created_at <= ?`;
|
||
params.push(endDate);
|
||
}
|
||
|
||
query += " ORDER BY al.created_at DESC LIMIT ? OFFSET ?";
|
||
params.push(parseInt(limit), parseInt(offset));
|
||
|
||
db.all(query, params, (err, logs) => {
|
||
if (err) {
|
||
console.error('Ошибка получения логов:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
res.json(logs);
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Получение логов уведомлений
|
||
router.get('/admin/notification-logs', requireAdmin, async (req, res) => {
|
||
try {
|
||
const postgresLogger = require('./postgres');
|
||
|
||
const {
|
||
taskId,
|
||
status,
|
||
startDate,
|
||
endDate,
|
||
limit = 100,
|
||
offset = 0
|
||
} = req.query;
|
||
|
||
if (!postgresLogger.pool || !postgresLogger.initialized) {
|
||
return res.json({ logs: [], total: 0, limit, offset });
|
||
}
|
||
|
||
let query = `
|
||
SELECT * FROM sms_logs
|
||
WHERE 1=1
|
||
${taskId ? 'AND task_id = $1' : ''}
|
||
${status ? `AND status = $${taskId ? 2 : 1}` : ''}
|
||
${startDate ? `AND created_at >= $${taskId ? (status ? 3 : 2) : (status ? 2 : 1)}` : ''}
|
||
${endDate ? `AND created_at <= $${taskId ? (status ? (startDate ? 4 : 3) : (startDate ? 3 : 2)) : (status ? (startDate ? 3 : 2) : (startDate ? 2 : 1))}` : ''}
|
||
ORDER BY created_at DESC
|
||
LIMIT $${taskId ? (status ? (startDate ? (endDate ? 5 : 4) : (endDate ? 4 : 3)) : (startDate ? (endDate ? 4 : 3) : (endDate ? 3 : 2))) : (status ? (startDate ? (endDate ? 4 : 3) : (endDate ? 3 : 2)) : (startDate ? (endDate ? 3 : 2) : (endDate ? 2 : 1)))}
|
||
OFFSET $${taskId ? (status ? (startDate ? (endDate ? 6 : 5) : (endDate ? 5 : 4)) : (startDate ? (endDate ? 5 : 4) : (endDate ? 4 : 3))) : (status ? (startDate ? (endDate ? 5 : 4) : (endDate ? 4 : 3)) : (startDate ? (endDate ? 4 : 3) : (endDate ? 3 : 2)))}
|
||
`;
|
||
|
||
const params = [];
|
||
if (taskId) params.push(taskId);
|
||
if (status) params.push(status);
|
||
if (startDate) params.push(startDate);
|
||
if (endDate) params.push(endDate);
|
||
params.push(parseInt(limit), parseInt(offset));
|
||
|
||
const client = await postgresLogger.pool.connect();
|
||
try {
|
||
const result = await client.query(query, params);
|
||
const logs = result.rows;
|
||
|
||
// Получаем общее количество
|
||
const countQuery = `
|
||
SELECT COUNT(*) as total FROM sms_logs
|
||
WHERE 1=1
|
||
${taskId ? 'AND task_id = $1' : ''}
|
||
${status ? `AND status = $${taskId ? 2 : 1}` : ''}
|
||
${startDate ? `AND created_at >= $${taskId ? (status ? 3 : 2) : (status ? 2 : 1)}` : ''}
|
||
${endDate ? `AND created_at <= $${taskId ? (status ? (startDate ? 4 : 3) : (startDate ? 3 : 2)) : (status ? (startDate ? 3 : 2) : (startDate ? 2 : 1))}` : ''}
|
||
`;
|
||
|
||
const countResult = await client.query(countQuery, params.slice(0, -2));
|
||
const total = countResult.rows[0]?.total || 0;
|
||
|
||
res.json({
|
||
logs,
|
||
total: parseInt(total),
|
||
limit: parseInt(limit),
|
||
offset: parseInt(offset)
|
||
});
|
||
} finally {
|
||
client.release();
|
||
}
|
||
} catch (error) {
|
||
console.error('Ошибка получения логов уведомлений:', error);
|
||
res.status(500).json({ error: 'Ошибка получения логов' });
|
||
}
|
||
});
|
||
|
||
// Получение детальной статистики
|
||
router.get('/admin/detailed-stats', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const { period = 'week' } = req.query;
|
||
|
||
let dateFilter = '';
|
||
let dateFormat = '';
|
||
|
||
switch (period) {
|
||
case 'day':
|
||
dateFilter = "created_at >= DATE('now', '-1 day')";
|
||
dateFormat = "strftime('%H:00', created_at)";
|
||
break;
|
||
case 'week':
|
||
dateFilter = "created_at >= DATE('now', '-7 days')";
|
||
dateFormat = "strftime('%Y-%m-%d', created_at)";
|
||
break;
|
||
case 'month':
|
||
dateFilter = "created_at >= DATE('now', '-30 days')";
|
||
dateFormat = "strftime('%Y-%m-%d', created_at)";
|
||
break;
|
||
case 'year':
|
||
dateFilter = "created_at >= DATE('now', '-365 days')";
|
||
dateFormat = "strftime('%Y-%m', created_at)";
|
||
break;
|
||
default:
|
||
dateFilter = "created_at >= DATE('now', '-7 days')";
|
||
dateFormat = "strftime('%Y-%m-%d', created_at)";
|
||
}
|
||
|
||
// Статистика по задачам по дням
|
||
const tasksByDay = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT
|
||
${dateFormat} as date,
|
||
COUNT(*) as total,
|
||
COUNT(CASE WHEN status = 'active' AND closed_at IS NULL THEN 1 END) as active,
|
||
COUNT(CASE WHEN closed_at IS NOT NULL THEN 1 END) as closed,
|
||
COUNT(CASE WHEN status = 'deleted' THEN 1 END) as deleted
|
||
FROM tasks
|
||
WHERE ${dateFilter}
|
||
GROUP BY ${dateFormat}
|
||
ORDER BY ${dateFormat}
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
|
||
// Статистика по назначениям по дням
|
||
const assignmentsByDay = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT
|
||
${dateFormat} as date,
|
||
COUNT(*) as total,
|
||
COUNT(CASE WHEN status = 'assigned' THEN 1 END) as assigned,
|
||
COUNT(CASE WHEN status = 'in_progress' THEN 1 END) as in_progress,
|
||
COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed,
|
||
COUNT(CASE WHEN status = 'overdue' THEN 1 END) as overdue,
|
||
COUNT(CASE WHEN status = 'rework' THEN 1 END) as rework
|
||
FROM task_assignments
|
||
WHERE ${dateFilter}
|
||
GROUP BY ${dateFormat}
|
||
ORDER BY ${dateFormat}
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
|
||
// Статистика по пользователям (активность)
|
||
const userActivity = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT
|
||
u.name as user_name,
|
||
u.login as user_login,
|
||
u.role,
|
||
u.auth_type,
|
||
COUNT(DISTINCT t.id) as tasks_created,
|
||
COUNT(DISTINCT ta.id) as tasks_assigned,
|
||
COUNT(DISTINCT CASE WHEN ta.status = 'completed' THEN ta.id END) as tasks_completed,
|
||
MAX(u.last_login) as last_login
|
||
FROM users u
|
||
LEFT JOIN tasks t ON u.id = t.created_by
|
||
LEFT JOIN task_assignments ta ON u.id = ta.user_id
|
||
GROUP BY u.id
|
||
ORDER BY tasks_created DESC
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
|
||
// Статистика по файлам
|
||
const filesStats = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT
|
||
${dateFormat} as date,
|
||
COUNT(*) as file_count,
|
||
SUM(file_size) as total_size
|
||
FROM task_files
|
||
WHERE ${dateFilter}
|
||
GROUP BY ${dateFormat}
|
||
ORDER BY ${dateFormat}
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
|
||
res.json({
|
||
period,
|
||
tasksByDay,
|
||
assignmentsByDay,
|
||
userActivity,
|
||
filesStats,
|
||
timestamp: new Date().toISOString()
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка получения детальной статистики:', error);
|
||
res.status(500).json({ error: 'Ошибка получения статистики' });
|
||
}
|
||
});
|
||
|
||
// Создание нового пользователя (только для админов)
|
||
router.post('/admin/users', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const { login, password, name, email, role = 'teacher', auth_type = 'local' } = req.body;
|
||
|
||
if (!login || !password || !name || !email) {
|
||
return res.status(400).json({ error: 'Заполните все обязательные поля' });
|
||
}
|
||
|
||
// Проверяем, существует ли пользователь с таким логином
|
||
db.get("SELECT id FROM users WHERE login = ?", [login], async (err, existingUser) => {
|
||
if (err) {
|
||
console.error('Ошибка проверки пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (existingUser) {
|
||
return res.status(400).json({ error: 'Пользователь с таким логином уже существует' });
|
||
}
|
||
|
||
// Проверяем, существует ли пользователь с таким email
|
||
db.get("SELECT id FROM users WHERE email = ?", [email], async (err, existingEmail) => {
|
||
if (err) {
|
||
console.error('Ошибка проверки email:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (existingEmail) {
|
||
return res.status(400).json({ error: 'Пользователь с таким email уже существует' });
|
||
}
|
||
|
||
// Хешируем пароль
|
||
const bcrypt = require('bcryptjs');
|
||
const hashedPassword = await bcrypt.hash(password, 10);
|
||
|
||
// Создаем пользователя
|
||
const query = `
|
||
INSERT INTO users (login, password, name, email, role, auth_type, created_at)
|
||
VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
|
||
`;
|
||
|
||
db.run(query, [login, hashedPassword, name, email, role, auth_type], function(err) {
|
||
if (err) {
|
||
console.error('Ошибка создания пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
res.json({
|
||
success: true,
|
||
message: 'Пользователь создан',
|
||
userId: this.lastID
|
||
});
|
||
});
|
||
});
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Сброс пароля пользователя
|
||
router.post('/admin/users/:id/reset-password', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
const { newPassword } = req.body;
|
||
|
||
if (!newPassword || newPassword.length < 6) {
|
||
return res.status(400).json({ error: 'Пароль должен содержать минимум 6 символов' });
|
||
}
|
||
|
||
// Хешируем пароль
|
||
const bcrypt = require('bcryptjs');
|
||
const hashedPassword = await bcrypt.hash(newPassword, 10);
|
||
|
||
const query = `UPDATE users SET password = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`;
|
||
|
||
db.run(query, [hashedPassword, userId], function(err) {
|
||
if (err) {
|
||
console.error('Ошибка сброса пароля:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (this.changes === 0) {
|
||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||
}
|
||
|
||
res.json({ success: true, message: 'Пароль сброшен' });
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
// API для админ Канбан-доски
|
||
router.get('/admin/kanban-tasks', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const days = parseInt(req.query.days) || 7;
|
||
|
||
const now = new Date();
|
||
const futureDate = new Date(now.getTime() + days * 24 * 60 * 60 * 1000);
|
||
const futureISO = futureDate.toISOString();
|
||
|
||
const query = `
|
||
SELECT DISTINCT
|
||
t.*,
|
||
u.name as creator_name,
|
||
u.login as creator_login,
|
||
GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
|
||
GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
|
||
FROM tasks t
|
||
LEFT JOIN users u ON t.created_by = u.id
|
||
LEFT JOIN task_assignments ta ON t.id = ta.task_id
|
||
LEFT JOIN users u2 ON ta.user_id = u2.id
|
||
WHERE t.status = 'active'
|
||
AND t.closed_at IS NULL
|
||
AND (t.due_date IS NULL OR t.due_date <= ?)
|
||
GROUP BY t.id
|
||
ORDER BY t.due_date ASC, t.created_at DESC
|
||
`;
|
||
|
||
db.all(query, [futureISO], async (err, tasks) => {
|
||
if (err) {
|
||
console.error('Ошибка получения задач для Канбана:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
// Добавляем статус для Канбана
|
||
const tasksWithKanban = await Promise.all(tasks.map(async (task) => {
|
||
// Получаем назначения для задачи
|
||
const assignments = await new Promise((resolve) => {
|
||
db.all(`
|
||
SELECT ta.*, u.name as user_name, u.login as user_login
|
||
FROM task_assignments ta
|
||
LEFT JOIN users u ON ta.user_id = u.id
|
||
WHERE ta.task_id = ?
|
||
`, [task.id], (err, rows) => {
|
||
resolve(rows || []);
|
||
});
|
||
});
|
||
|
||
// Определяем статус для Канбана
|
||
let kanbanStatus = 'unassigned';
|
||
|
||
if (assignments.length === 0) {
|
||
kanbanStatus = 'unassigned';
|
||
} else {
|
||
const hasAssigned = assignments.some(a => a.status === 'assigned');
|
||
const hasInProgress = assignments.some(a => a.status === 'in_progress');
|
||
const hasOverdue = assignments.some(a => a.status === 'overdue');
|
||
const hasRework = assignments.some(a => a.status === 'rework');
|
||
const allCompleted = assignments.every(a => a.status === 'completed');
|
||
|
||
if (allCompleted) {
|
||
kanbanStatus = 'completed';
|
||
} else if (hasRework) {
|
||
kanbanStatus = 'rework';
|
||
} else if (hasOverdue) {
|
||
kanbanStatus = 'overdue';
|
||
} else if (hasInProgress) {
|
||
kanbanStatus = 'in_progress';
|
||
} else if (hasAssigned) {
|
||
kanbanStatus = 'assigned';
|
||
}
|
||
}
|
||
|
||
return {
|
||
...task,
|
||
kanbanStatus,
|
||
assignments
|
||
};
|
||
}));
|
||
|
||
res.json({ tasks: tasksWithKanban });
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
// Экспорт данных
|
||
router.get('/admin/export', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const { format = 'json', dataType = 'all' } = req.query;
|
||
|
||
const exportData = {};
|
||
|
||
if (dataType === 'all' || dataType === 'users') {
|
||
const users = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT id, login, name, email, role, auth_type, groups, description,
|
||
created_at, last_login, updated_at
|
||
FROM users
|
||
ORDER BY id
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
exportData.users = users;
|
||
}
|
||
|
||
if (dataType === 'all' || dataType === 'tasks') {
|
||
const tasks = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT t.*, u.name as creator_name, u.login as creator_login
|
||
FROM tasks t
|
||
LEFT JOIN users u ON t.created_by = u.id
|
||
ORDER BY t.id
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
exportData.tasks = tasks;
|
||
}
|
||
|
||
if (dataType === 'all' || dataType === 'assignments') {
|
||
const assignments = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT ta.*, u.name as user_name, u.login as user_login, t.title as task_title
|
||
FROM task_assignments ta
|
||
LEFT JOIN users u ON ta.user_id = u.id
|
||
LEFT JOIN tasks t ON ta.task_id = t.id
|
||
ORDER BY ta.id
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
exportData.assignments = assignments;
|
||
}
|
||
|
||
if (dataType === 'all' || dataType === 'logs') {
|
||
const logs = await new Promise((resolve, reject) => {
|
||
db.all(`
|
||
SELECT al.*, u.name as user_name, t.title as task_title
|
||
FROM activity_logs al
|
||
LEFT JOIN users u ON al.user_id = u.id
|
||
LEFT JOIN tasks t ON al.task_id = t.id
|
||
ORDER BY al.id
|
||
`, [], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows || []);
|
||
});
|
||
});
|
||
exportData.activityLogs = logs;
|
||
}
|
||
|
||
exportData.exportedAt = new Date().toISOString();
|
||
exportData.system = 'MiniCRM';
|
||
exportData.version = '1.0.0';
|
||
|
||
if (format === 'csv') {
|
||
// Простая реализация CSV экспорта (можно расширить)
|
||
const csvData = Object.entries(exportData)
|
||
.map(([key, value]) => {
|
||
if (Array.isArray(value)) {
|
||
if (value.length === 0) return `${key}: Нет данных\n`;
|
||
const headers = Object.keys(value[0]).join(',');
|
||
const rows = value.map(item =>
|
||
Object.values(item).map(val =>
|
||
typeof val === 'string' ? `"${val.replace(/"/g, '""')}"` : val
|
||
).join(',')
|
||
).join('\n');
|
||
return `${key}:\n${headers}\n${rows}\n\n`;
|
||
}
|
||
return `${key}: ${JSON.stringify(value)}\n`;
|
||
})
|
||
.join('');
|
||
|
||
res.setHeader('Content-Type', 'text/csv');
|
||
res.setHeader('Content-Disposition', `attachment; filename="minicrm_export_${new Date().toISOString().split('T')[0]}.csv"`);
|
||
res.send(csvData);
|
||
} else {
|
||
res.json(exportData);
|
||
}
|
||
} catch (error) {
|
||
console.error('Ошибка экспорта данных:', error);
|
||
res.status(500).json({ error: 'Ошибка экспорта данных' });
|
||
}
|
||
});
|
||
|
||
// Получение профилей пользователей с настройками уведомлений
|
||
router.get('/admin/user-profiles', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
|
||
const query = `
|
||
SELECT
|
||
u.id,
|
||
u.login,
|
||
u.name,
|
||
u.email as user_email,
|
||
u.role,
|
||
u.auth_type,
|
||
u.groups,
|
||
u.created_at,
|
||
u.last_login,
|
||
us.email_notifications,
|
||
us.notification_email,
|
||
us.telegram_notifications,
|
||
us.telegram_chat_id,
|
||
us.vk_notifications,
|
||
us.vk_user_id,
|
||
us.updated_at as settings_updated_at
|
||
FROM users u
|
||
LEFT JOIN user_settings us ON u.id = us.user_id
|
||
ORDER BY u.name
|
||
`;
|
||
|
||
db.all(query, [], (err, profiles) => {
|
||
if (err) {
|
||
console.error('Ошибка получения профилей пользователей:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
res.json(profiles);
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Получение конкретного профиля пользователя
|
||
router.get('/admin/user-profiles/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
|
||
const query = `
|
||
SELECT
|
||
u.id,
|
||
u.login,
|
||
u.name,
|
||
u.email as user_email,
|
||
u.role,
|
||
u.auth_type,
|
||
u.groups,
|
||
u.created_at,
|
||
u.last_login,
|
||
us.email_notifications,
|
||
us.notification_email,
|
||
us.telegram_notifications,
|
||
us.telegram_chat_id,
|
||
us.vk_notifications,
|
||
us.vk_user_id,
|
||
us.created_at as settings_created_at,
|
||
us.updated_at as settings_updated_at
|
||
FROM users u
|
||
LEFT JOIN user_settings us ON u.id = us.user_id
|
||
WHERE u.id = ?
|
||
`;
|
||
|
||
db.get(query, [userId], (err, profile) => {
|
||
if (err) {
|
||
console.error('Ошибка получения профиля пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (!profile) {
|
||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||
}
|
||
|
||
res.json(profile);
|
||
});
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Обновление настроек уведомлений пользователя (для админа)
|
||
router.put('/admin/user-profiles/:id/notification-settings', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
const {
|
||
email_notifications,
|
||
notification_email,
|
||
telegram_notifications,
|
||
telegram_chat_id,
|
||
vk_notifications,
|
||
vk_user_id
|
||
} = req.body;
|
||
|
||
// Валидация email
|
||
if (email_notifications && notification_email) {
|
||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
||
if (!emailRegex.test(notification_email)) {
|
||
return res.status(400).json({ error: 'Неверный формат email' });
|
||
}
|
||
}
|
||
|
||
// Проверяем существование записи
|
||
db.get("SELECT id FROM user_settings WHERE user_id = ?", [userId], (err, existing) => {
|
||
if (err) {
|
||
console.error('Ошибка проверки настроек:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (existing) {
|
||
// Обновляем существующие настройки
|
||
db.run(
|
||
`UPDATE user_settings SET
|
||
email_notifications = ?,
|
||
notification_email = ?,
|
||
telegram_notifications = ?,
|
||
telegram_chat_id = ?,
|
||
vk_notifications = ?,
|
||
vk_user_id = ?,
|
||
updated_at = CURRENT_TIMESTAMP
|
||
WHERE user_id = ?`,
|
||
[
|
||
email_notifications ? 1 : 0,
|
||
notification_email || '',
|
||
telegram_notifications ? 1 : 0,
|
||
telegram_chat_id || '',
|
||
vk_notifications ? 1 : 0,
|
||
vk_user_id || '',
|
||
userId
|
||
],
|
||
function(updateErr) {
|
||
if (updateErr) {
|
||
console.error('Ошибка обновления настроек:', updateErr);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
// Логируем действие
|
||
const { logActivity } = require('./database');
|
||
if (logActivity) {
|
||
logActivity(0, req.session.user.id, 'USER_SETTINGS_UPDATED', `Админ обновил настройки уведомлений пользователя ${userId}`);
|
||
}
|
||
|
||
console.log(`✅ Админ обновил настройки пользователя ${userId}`);
|
||
res.json({ success: true, message: 'Настройки уведомлений обновлены' });
|
||
}
|
||
);
|
||
} else {
|
||
// Создаем новые настройки
|
||
db.run(
|
||
`INSERT INTO user_settings
|
||
(user_id, email_notifications, notification_email,
|
||
telegram_notifications, telegram_chat_id,
|
||
vk_notifications, vk_user_id)
|
||
VALUES (?, ?, ?, ?, ?, ?, ?)`,
|
||
[
|
||
userId,
|
||
email_notifications ? 1 : 0,
|
||
notification_email || '',
|
||
telegram_notifications ? 1 : 0,
|
||
telegram_chat_id || '',
|
||
vk_notifications ? 1 : 0,
|
||
vk_user_id || ''
|
||
],
|
||
function(insertErr) {
|
||
if (insertErr) {
|
||
console.error('Ошибка создания настроек:', insertErr);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
// Логируем действие
|
||
const { logActivity } = require('./database');
|
||
if (logActivity) {
|
||
logActivity(0, req.session.user.id, 'USER_SETTINGS_CREATED', `Админ создал настройки уведомлений пользователя ${userId}`);
|
||
}
|
||
|
||
console.log(`✅ Админ создал настройки пользователя ${userId}`);
|
||
res.json({ success: true, message: 'Настройки уведомлений созданы' });
|
||
}
|
||
);
|
||
}
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Массовое обновление email уведомлений для нескольких пользователей
|
||
router.post('/admin/bulk-email-settings', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const { users, email_notifications, notification_email } = req.body;
|
||
|
||
if (!Array.isArray(users) || users.length === 0) {
|
||
return res.status(400).json({ error: 'Выберите пользователей' });
|
||
}
|
||
|
||
if (email_notifications && !notification_email) {
|
||
return res.status(400).json({ error: 'Укажите email для уведомлений' });
|
||
}
|
||
|
||
// Валидация email
|
||
if (email_notifications && notification_email) {
|
||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
||
if (!emailRegex.test(notification_email)) {
|
||
return res.status(400).json({ error: 'Неверный формат email' });
|
||
}
|
||
}
|
||
|
||
const results = {
|
||
success: 0,
|
||
failed: 0,
|
||
errors: []
|
||
};
|
||
|
||
// Обновляем каждого пользователя в транзакции
|
||
db.serialize(() => {
|
||
db.run("BEGIN TRANSACTION");
|
||
|
||
users.forEach(userId => {
|
||
// Проверяем существование записи
|
||
db.get("SELECT id FROM user_settings WHERE user_id = ?", [userId], (err, existing) => {
|
||
if (err) {
|
||
results.failed++;
|
||
results.errors.push({ userId, error: err.message });
|
||
return;
|
||
}
|
||
|
||
if (existing) {
|
||
// Обновляем существующие настройки
|
||
db.run(
|
||
`UPDATE user_settings SET
|
||
email_notifications = ?,
|
||
notification_email = ?,
|
||
updated_at = CURRENT_TIMESTAMP
|
||
WHERE user_id = ?`,
|
||
[
|
||
email_notifications ? 1 : 0,
|
||
email_notifications ? notification_email : '',
|
||
userId
|
||
],
|
||
function(updateErr) {
|
||
if (updateErr) {
|
||
results.failed++;
|
||
results.errors.push({ userId, error: updateErr.message });
|
||
} else {
|
||
results.success++;
|
||
}
|
||
}
|
||
);
|
||
} else {
|
||
// Создаем новые настройки с значениями по умолчанию
|
||
db.run(
|
||
`INSERT INTO user_settings
|
||
(user_id, email_notifications, notification_email,
|
||
telegram_notifications, telegram_chat_id,
|
||
vk_notifications, vk_user_id)
|
||
VALUES (?, ?, ?, 0, '', 0, '')`,
|
||
[
|
||
userId,
|
||
email_notifications ? 1 : 0,
|
||
email_notifications ? notification_email : ''
|
||
],
|
||
function(insertErr) {
|
||
if (insertErr) {
|
||
results.failed++;
|
||
results.errors.push({ userId, error: insertErr.message });
|
||
} else {
|
||
results.success++;
|
||
}
|
||
}
|
||
);
|
||
}
|
||
});
|
||
});
|
||
|
||
setTimeout(() => {
|
||
db.run("COMMIT", (commitErr) => {
|
||
if (commitErr) {
|
||
console.error('Ошибка коммита транзакции:', commitErr);
|
||
return res.status(500).json({ error: 'Ошибка транзакции' });
|
||
}
|
||
|
||
// Логируем действие
|
||
const { logActivity } = require('./database');
|
||
if (logActivity) {
|
||
logActivity(0, req.session.user.id, 'BULK_SETTINGS_UPDATED',
|
||
`Админ массово обновил настройки для ${users.length} пользователей`);
|
||
}
|
||
|
||
console.log(`✅ Массовое обновление: успешно ${results.success}, ошибок ${results.failed}`);
|
||
res.json({
|
||
success: true,
|
||
message: 'Настройки обновлены',
|
||
results
|
||
});
|
||
});
|
||
}, 1000);
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
// Отправка тестового уведомления пользователю
|
||
router.post('/admin/user-profiles/:id/test-notification', requireAdmin, async (req, res) => {
|
||
try {
|
||
const { getDb } = require('./database');
|
||
const db = getDb();
|
||
const userId = req.params.id;
|
||
const notificationType = req.body.notification_type || 'test';
|
||
|
||
// Получаем информацию о пользователе
|
||
db.get(`
|
||
SELECT u.id, u.name, u.email, us.email_notifications, us.notification_email
|
||
FROM users u
|
||
LEFT JOIN user_settings us ON u.id = us.user_id
|
||
WHERE u.id = ?
|
||
`, [userId], async (err, user) => {
|
||
if (err) {
|
||
console.error('Ошибка получения пользователя:', err);
|
||
return res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
|
||
if (!user) {
|
||
return res.status(404).json({ error: 'Пользователь не найден' });
|
||
}
|
||
|
||
// Проверяем, включены ли email уведомления
|
||
if (!user.email_notifications) {
|
||
return res.status(400).json({ error: 'Email уведомления отключены у пользователя' });
|
||
}
|
||
|
||
const emailTo = user.notification_email || user.email;
|
||
if (!emailTo) {
|
||
return res.status(400).json({ error: 'У пользователя не указан email' });
|
||
}
|
||
|
||
// Отправляем тестовое уведомление
|
||
const emailNotifications = require('./email-notifications');
|
||
const emailSent = await emailNotifications.sendEmailNotification(
|
||
emailTo,
|
||
'Тестовое уведомление от School CRM',
|
||
`
|
||
<!DOCTYPE html>
|
||
<html>
|
||
<head>
|
||
<style>
|
||
body { font-family: Arial, sans-serif; line-height: 1.6; }
|
||
.container { max-width: 600px; margin: 0 auto; padding: 20px; }
|
||
.header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px 10px 0 0; }
|
||
.content { padding: 20px; border: 1px solid #ddd; border-top: none; }
|
||
.button { display: inline-block; background: #667eea; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; }
|
||
.footer { margin-top: 20px; font-size: 12px; color: #666; }
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<div class="container">
|
||
<div class="header">
|
||
<h2>✅ Тестовое уведомление</h2>
|
||
</div>
|
||
<div class="content">
|
||
<p>Здравствуйте, ${user.name}!</p>
|
||
<p>Это тестовое уведомление от системы School CRM.</p>
|
||
<p>Если вы получили это письмо, значит настройки уведомлений работают корректно.</p>
|
||
<br>
|
||
<p><strong>Информация о тесте:</strong></p>
|
||
<ul>
|
||
<li>Получатель: ${emailTo}</li>
|
||
<li>Отправитель: Администратор</li>
|
||
<li>Время: ${new Date().toLocaleString('ru-RU')}</li>
|
||
</ul>
|
||
</div>
|
||
<div class="footer">
|
||
<p>Это тестовое сообщение от School CRM системы.</p>
|
||
<p>Вы можете изменить настройки уведомлений в личном кабинете.</p>
|
||
</div>
|
||
</div>
|
||
</body>
|
||
</html>
|
||
`
|
||
);
|
||
|
||
if (emailSent) {
|
||
// Логируем действие
|
||
const { logActivity } = require('./database');
|
||
if (logActivity) {
|
||
logActivity(0, req.session.user.id, 'TEST_NOTIFICATION_SENT',
|
||
`Админ отправил тестовое уведомление пользователю ${user.name} (${emailTo})`);
|
||
}
|
||
|
||
res.json({
|
||
success: true,
|
||
message: 'Тестовое уведомление отправлено',
|
||
email: emailTo
|
||
});
|
||
} else {
|
||
res.status(500).json({ error: 'Не удалось отправить уведомление' });
|
||
}
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('Ошибка:', error);
|
||
res.status(500).json({ error: 'Ошибка сервера' });
|
||
}
|
||
});
|
||
|
||
module.exports = router; |