1362 lines
51 KiB
JavaScript
1362 lines
51 KiB
JavaScript
// upravlenie-service.js
|
||
const axios = require('axios');
|
||
const FormData = require('form-data');
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
const crypto = require('crypto');
|
||
|
||
const SERVICE_ID_RANGE = { min: 1, max: 4062 };
|
||
const SYNC_INTERVAL = 60000;
|
||
const MAX_RETRY_COUNT = 3;
|
||
const RETRY_DELAY = 5000;
|
||
|
||
const TaskStatus = {
|
||
PENDING: 'pending',
|
||
IN_PROGRESS: 'in_progress',
|
||
ASSIGNED: 'assigned',
|
||
REWORK: 'rework',
|
||
COMPLETED: 'completed',
|
||
OVERDUE: 'overdue',
|
||
CANCELLED: 'cancelled'
|
||
};
|
||
|
||
const SyncDirection = {
|
||
INCOMING: 'incoming',
|
||
OUTGOING: 'outgoing'
|
||
};
|
||
|
||
class UpravlenieService {
|
||
constructor(db) {
|
||
this.db = db;
|
||
this.syncIntervals = new Map();
|
||
this.syncInProgress = new Set();
|
||
this.init();
|
||
}
|
||
|
||
async init() {
|
||
console.log('🔧 Инициализация сервиса Upravlenie...');
|
||
await this.createTable();
|
||
await this.startAllSyncJobs();
|
||
console.log('✅ Сервис Upravlenie инициализирован');
|
||
}
|
||
|
||
async createTable() {
|
||
const createTableSQL = `
|
||
CREATE TABLE IF NOT EXISTS upravlenie (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
service_id INTEGER NOT NULL CHECK(service_id >= 1 AND service_id <= 4062),
|
||
service_name VARCHAR(255) NOT NULL,
|
||
service_type VARCHAR(50) NOT NULL CHECK(service_type IN ('organizer', 'executor')),
|
||
login VARCHAR(255) NOT NULL,
|
||
password VARCHAR(255) NOT NULL,
|
||
api_url VARCHAR(500),
|
||
local_user_id INTEGER,
|
||
local_user_login VARCHAR(255),
|
||
sync_direction VARCHAR(50) DEFAULT 'outgoing' CHECK(sync_direction IN ('incoming', 'outgoing', 'both')),
|
||
sync_enabled BOOLEAN DEFAULT 1,
|
||
sync_interval INTEGER DEFAULT 60,
|
||
last_sync_at TIMESTAMP,
|
||
last_sync_status VARCHAR(50),
|
||
last_sync_error TEXT,
|
||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||
is_active BOOLEAN DEFAULT 1,
|
||
FOREIGN KEY (local_user_id) REFERENCES users(id)
|
||
)
|
||
`;
|
||
|
||
return new Promise((resolve, reject) => {
|
||
this.db.run(createTableSQL, (err) => {
|
||
if (err) {
|
||
console.error('❌ Ошибка создания таблицы upravlenie:', err);
|
||
reject(err);
|
||
} else {
|
||
console.log('✅ Таблица upravlenie создана/проверена');
|
||
this.createIndexes().then(resolve).catch(reject);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
async createIndexes() {
|
||
const indexes = [
|
||
'CREATE INDEX IF NOT EXISTS idx_upravlenie_service_id ON upravlenie(service_id)',
|
||
'CREATE INDEX IF NOT EXISTS idx_upravlenie_service_type ON upravlenie(service_type)',
|
||
'CREATE INDEX IF NOT EXISTS idx_upravlenie_local_user_id ON upravlenie(local_user_id)',
|
||
'CREATE INDEX IF NOT EXISTS idx_upravlenie_sync_enabled ON upravlenie(sync_enabled)',
|
||
'CREATE INDEX IF NOT EXISTS idx_upravlenie_last_sync ON upravlenie(last_sync_at)'
|
||
];
|
||
|
||
return new Promise((resolve, reject) => {
|
||
this.db.serialize(() => {
|
||
let error = null;
|
||
indexes.forEach(indexSQL => {
|
||
this.db.run(indexSQL, (err) => {
|
||
if (err) error = err;
|
||
});
|
||
});
|
||
|
||
if (error) {
|
||
console.error('❌ Ошибка создания индексов:', error);
|
||
reject(error);
|
||
} else {
|
||
console.log('✅ Индексы для upravlenie созданы');
|
||
resolve();
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
async createConnection(data) {
|
||
const {
|
||
service_id, service_name, service_type, login, password,
|
||
api_url, local_user_id, local_user_login, sync_direction = 'outgoing',
|
||
sync_enabled = 1, sync_interval = 60
|
||
} = data;
|
||
|
||
if (service_id < SERVICE_ID_RANGE.min || service_id > SERVICE_ID_RANGE.max) {
|
||
throw new Error(`service_id должен быть в диапазоне ${SERVICE_ID_RANGE.min}-${SERVICE_ID_RANGE.max}`);
|
||
}
|
||
|
||
if (service_type === 'executor' && !api_url) {
|
||
throw new Error('Для исполнителя необходимо указать api_url организатора');
|
||
}
|
||
|
||
if (local_user_id) {
|
||
const userExists = await this.checkLocalUserExists(local_user_id);
|
||
if (!userExists) {
|
||
throw new Error(`Пользователь с ID ${local_user_id} не существует`);
|
||
}
|
||
}
|
||
|
||
const existing = await this.getConnectionByServiceId(service_id);
|
||
if (existing && existing.is_active) {
|
||
throw new Error(`Подключение с service_id ${service_id} уже существует`);
|
||
}
|
||
|
||
const sql = `
|
||
INSERT INTO upravlenie (
|
||
service_id, service_name, service_type, login, password,
|
||
api_url, local_user_id, local_user_login, sync_direction,
|
||
sync_enabled, sync_interval
|
||
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||
`;
|
||
|
||
return new Promise((resolve, reject) => {
|
||
this.db.run(sql, [
|
||
service_id, service_name, service_type, login, password,
|
||
api_url, local_user_id || null, local_user_login || null,
|
||
sync_direction, sync_enabled, sync_interval
|
||
], function(err) {
|
||
if (err) {
|
||
reject(err);
|
||
} else {
|
||
const connectionId = this.lastID;
|
||
console.log(`✅ Создано подключение ${service_name} (ID: ${connectionId}, service_id: ${service_id})`);
|
||
resolve({ id: connectionId, ...data });
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
async checkLocalUserExists(userId) {
|
||
return new Promise((resolve) => {
|
||
this.db.get('SELECT id FROM users WHERE id = ?', [userId], (err, row) => {
|
||
resolve(!!row);
|
||
});
|
||
});
|
||
}
|
||
|
||
getConnection(id) {
|
||
return new Promise((resolve, reject) => {
|
||
this.db.get('SELECT * FROM upravlenie WHERE id = ?', [id], (err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row);
|
||
});
|
||
});
|
||
}
|
||
|
||
getConnectionByServiceId(serviceId) {
|
||
return new Promise((resolve, reject) => {
|
||
this.db.get(
|
||
'SELECT * FROM upravlenie WHERE service_id = ? AND is_active = 1',
|
||
[serviceId],
|
||
(err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row);
|
||
}
|
||
);
|
||
});
|
||
}
|
||
|
||
getAllConnections(filters = {}) {
|
||
return new Promise((resolve, reject) => {
|
||
let sql = 'SELECT * FROM upravlenie WHERE 1=1';
|
||
const params = [];
|
||
|
||
if (filters.service_type) {
|
||
sql += ' AND service_type = ?';
|
||
params.push(filters.service_type);
|
||
}
|
||
|
||
if (filters.is_active !== undefined) {
|
||
sql += ' AND is_active = ?';
|
||
params.push(filters.is_active ? 1 : 0);
|
||
}
|
||
|
||
if (filters.sync_enabled !== undefined) {
|
||
sql += ' AND sync_enabled = ?';
|
||
params.push(filters.sync_enabled ? 1 : 0);
|
||
}
|
||
|
||
sql += ' ORDER BY service_name';
|
||
|
||
this.db.all(sql, params, (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows);
|
||
});
|
||
});
|
||
}
|
||
|
||
async updateConnection(id, data) {
|
||
const fields = [];
|
||
const values = [];
|
||
|
||
const allowedFields = [
|
||
'service_name', 'service_type', 'login', 'password',
|
||
'api_url', 'local_user_id', 'local_user_login',
|
||
'sync_direction', 'sync_enabled', 'sync_interval',
|
||
'is_active'
|
||
];
|
||
|
||
allowedFields.forEach(field => {
|
||
if (data[field] !== undefined) {
|
||
fields.push(`${field} = ?`);
|
||
values.push(data[field]);
|
||
}
|
||
});
|
||
|
||
if (fields.length === 0) {
|
||
throw new Error('Нет данных для обновления');
|
||
}
|
||
|
||
fields.push('updated_at = CURRENT_TIMESTAMP');
|
||
values.push(id);
|
||
|
||
const sql = `UPDATE upravlenie SET ${fields.join(', ')} WHERE id = ?`;
|
||
|
||
return new Promise((resolve, reject) => {
|
||
this.db.run(sql, values, function(err) {
|
||
if (err) {
|
||
reject(err);
|
||
} else {
|
||
console.log(`✅ Подключение ${id} обновлено`);
|
||
resolve({ id, changes: this.changes });
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
async deleteConnection(id) {
|
||
return this.updateConnection(id, { is_active: 0 });
|
||
}
|
||
|
||
async startAllSyncJobs() {
|
||
const connections = await this.getAllConnections({
|
||
is_active: true,
|
||
sync_enabled: true
|
||
});
|
||
|
||
for (const conn of connections) {
|
||
this.startSyncJob(conn.id, conn.sync_interval);
|
||
}
|
||
|
||
console.log(`✅ Запущено ${connections.length} задач синхронизации`);
|
||
}
|
||
|
||
startSyncJob(connectionId, intervalMinutes) {
|
||
this.stopSyncJob(connectionId);
|
||
|
||
const intervalMs = intervalMinutes * 60 * 1000;
|
||
const interval = setInterval(() => {
|
||
this.syncConnection(connectionId);
|
||
}, intervalMs);
|
||
|
||
this.syncIntervals.set(connectionId, interval);
|
||
console.log(`✅ Запущена синхронизация для подключения ${connectionId} (интервал: ${intervalMinutes} мин)`);
|
||
|
||
setTimeout(() => {
|
||
this.syncConnection(connectionId);
|
||
}, 1000);
|
||
}
|
||
|
||
stopSyncJob(connectionId) {
|
||
if (this.syncIntervals.has(connectionId)) {
|
||
clearInterval(this.syncIntervals.get(connectionId));
|
||
this.syncIntervals.delete(connectionId);
|
||
console.log(`✅ Остановлена синхронизация для подключения ${connectionId}`);
|
||
}
|
||
}
|
||
|
||
async restartSyncJob(connectionId) {
|
||
this.stopSyncJob(connectionId);
|
||
|
||
const connection = await this.getConnection(connectionId);
|
||
if (connection && connection.is_active && connection.sync_enabled) {
|
||
this.startSyncJob(connectionId, connection.sync_interval);
|
||
}
|
||
}
|
||
|
||
async syncConnection(connectionId) {
|
||
if (this.syncInProgress.has(connectionId)) {
|
||
console.log(`⚠️ Синхронизация подключения ${connectionId} уже выполняется`);
|
||
return;
|
||
}
|
||
|
||
this.syncInProgress.add(connectionId);
|
||
|
||
try {
|
||
const connection = await this.getConnection(connectionId);
|
||
if (!connection || !connection.is_active || !connection.sync_enabled) {
|
||
return;
|
||
}
|
||
|
||
console.log(`🔄 Синхронизация подключения ${connection.service_name} (${connection.service_id})...`);
|
||
|
||
await this.updateSyncStatus(connectionId, 'in_progress');
|
||
|
||
if (connection.service_type === 'organizer') {
|
||
await this.syncFromExecutors(connection);
|
||
} else {
|
||
await this.syncToOrganizer(connection);
|
||
}
|
||
|
||
await this.updateSyncStatus(connectionId, 'success');
|
||
console.log(`✅ Синхронизация подключения ${connection.service_name} завершена`);
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка синхронизации подключения ${connectionId}:`, error.message);
|
||
await this.updateSyncStatus(connectionId, 'error', error.message);
|
||
} finally {
|
||
this.syncInProgress.delete(connectionId);
|
||
}
|
||
}
|
||
|
||
updateSyncStatus(connectionId, status, error = null) {
|
||
return new Promise((resolve, reject) => {
|
||
this.db.run(
|
||
`UPDATE upravlenie
|
||
SET last_sync_at = CURRENT_TIMESTAMP,
|
||
last_sync_status = ?,
|
||
last_sync_error = ?
|
||
WHERE id = ?`,
|
||
[status, error, connectionId],
|
||
(err) => {
|
||
if (err) reject(err);
|
||
else resolve();
|
||
}
|
||
);
|
||
});
|
||
}
|
||
|
||
async syncToOrganizer(connection) {
|
||
if (!connection.api_url) {
|
||
throw new Error('Для исполнителя не указан api_url организатора');
|
||
}
|
||
|
||
console.log(`🔍 Исполнитель ${connection.service_name} пытается связаться с организатором по URL: ${connection.api_url}`);
|
||
|
||
if (!connection.local_user_id) {
|
||
console.warn(`⚠️ Для подключения ${connection.service_name} не указан локальный пользователь. Задачи не будут создаваться.`);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
console.log(`📡 Проверка доступности организатора...`);
|
||
|
||
const organizerTasks = await this.fetchTasksFromOrganizer(connection);
|
||
console.log(`📥 Получено ${organizerTasks.length} задач от организатора`);
|
||
|
||
const localTasks = await this.getTasksForLocalUser(connection.local_user_id);
|
||
|
||
if (organizerTasks.length > 0) {
|
||
await this.syncTasksWithOrganizer(connection, organizerTasks, localTasks);
|
||
}
|
||
|
||
if (localTasks.length > 0) {
|
||
await this.sendTaskStatusesToOrganizer(connection, localTasks);
|
||
console.log(`📤 Отправлено ${localTasks.length} статусов организатору`);
|
||
}
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка связи с организатором:`, error.message);
|
||
if (error.code === 'ECONNREFUSED') {
|
||
console.error(`🔴 Организатор не доступен по адресу ${connection.api_url}`);
|
||
} else if (error.code === 'ETIMEDOUT') {
|
||
console.error(`⏱️ Таймаут при подключении к организатору`);
|
||
} else if (error.response) {
|
||
console.error(`📡 Ответ организатора:`, {
|
||
status: error.response.status,
|
||
data: error.response.data
|
||
});
|
||
}
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
async syncFromExecutors(connection) {
|
||
const executors = await this.getAllConnections({
|
||
service_type: 'executor',
|
||
is_active: true,
|
||
sync_enabled: true
|
||
});
|
||
|
||
if (executors.length === 0) {
|
||
console.log(`📭 Нет активных исполнителей для организатора ${connection.service_name}`);
|
||
return;
|
||
}
|
||
|
||
for (const executor of executors) {
|
||
try {
|
||
if (!executor.local_user_id) {
|
||
console.warn(`⚠️ Для исполнителя ${executor.service_name} не указан локальный пользователь. Пропускаем...`);
|
||
continue;
|
||
}
|
||
|
||
const taskStatuses = await this.fetchTaskStatusesFromExecutor(executor);
|
||
|
||
if (taskStatuses.length > 0) {
|
||
await this.updateTaskStatusesFromExecutor(executor, taskStatuses);
|
||
console.log(`✅ Получено ${taskStatuses.length} статусов от исполнителя ${executor.service_name}`);
|
||
}
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка получения статусов от исполнителя ${executor.service_name}:`, error.message);
|
||
}
|
||
}
|
||
}
|
||
|
||
getTasksForLocalUser(userId) {
|
||
return new Promise((resolve, reject) => {
|
||
if (!userId) {
|
||
return resolve([]);
|
||
}
|
||
|
||
this.db.all(`
|
||
SELECT t.*, ta.status as assignment_status, ta.due_date as assignment_due_date
|
||
FROM tasks t
|
||
JOIN task_assignments ta ON t.id = ta.task_id
|
||
WHERE ta.user_id = ? AND t.status = 'active' AND t.closed_at IS NULL
|
||
ORDER BY t.created_at DESC
|
||
`, [userId], (err, rows) => {
|
||
if (err) reject(err);
|
||
else resolve(rows);
|
||
});
|
||
});
|
||
}
|
||
|
||
async fetchTasksFromOrganizer(connection) {
|
||
try {
|
||
const response = await axios.get(`${connection.api_url}/api/external/tasks`, {
|
||
params: {
|
||
service_id: connection.service_id,
|
||
user_login: connection.local_user_login
|
||
},
|
||
auth: {
|
||
username: connection.login,
|
||
password: connection.password
|
||
},
|
||
timeout: 10000
|
||
});
|
||
|
||
return response.data.tasks || [];
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка получения задач от организатора:`, error.message);
|
||
throw new Error(`Не удалось получить задачи: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
async fetchTaskStatusesFromExecutor(executor) {
|
||
try {
|
||
const response = await axios.get(`${executor.api_url}/api/external/task-statuses`, {
|
||
params: {
|
||
service_id: executor.service_id
|
||
},
|
||
auth: {
|
||
username: executor.login,
|
||
password: executor.password
|
||
},
|
||
timeout: 10000
|
||
});
|
||
|
||
return response.data.statuses || [];
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка получения статусов от исполнителя:`, error.message);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
async sendTaskStatusesToOrganizer(connection, localTasks) {
|
||
const statuses = localTasks.map(task => ({
|
||
task_id: task.id,
|
||
external_task_id: task.external_task_id,
|
||
status: task.assignment_status,
|
||
completed_at: task.closed_at,
|
||
comment: task.rework_comment
|
||
}));
|
||
|
||
try {
|
||
await axios.post(`${connection.api_url}/api/external/task-statuses`, {
|
||
service_id: connection.service_id,
|
||
statuses: statuses
|
||
}, {
|
||
auth: {
|
||
username: connection.login,
|
||
password: connection.password
|
||
},
|
||
timeout: 10000
|
||
});
|
||
|
||
console.log(`✅ Отправлено ${statuses.length} статусов организатору`);
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка отправки статусов организатору:`, error.message);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
async syncTasksWithOrganizer(connection, organizerTasks, localTasks) {
|
||
for (const organizerTask of organizerTasks) {
|
||
const localTask = localTasks.find(t => t.external_task_id === organizerTask.id);
|
||
|
||
if (!localTask) {
|
||
await this.createTaskFromOrganizer(connection, organizerTask);
|
||
} else {
|
||
await this.updateTaskFromOrganizer(connection, organizerTask, localTask);
|
||
}
|
||
}
|
||
}
|
||
|
||
async createTaskFromOrganizer(connection, taskData) {
|
||
return new Promise((resolve, reject) => {
|
||
if (!connection.local_user_id) {
|
||
reject(new Error('local_user_id не может быть пустым. Укажите локального пользователя для создания задач.'));
|
||
return;
|
||
}
|
||
|
||
this.db.all("PRAGMA table_info(tasks)", (err, columns) => {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
|
||
const columnNames = columns.map(c => c.name);
|
||
|
||
let fields = ['title', 'description', 'status', 'created_by', 'start_date', 'due_date', 'task_type'];
|
||
let placeholders = ['?', '?', '?', '?', '?', '?', '?'];
|
||
let values = [
|
||
taskData.title,
|
||
taskData.description || '',
|
||
'active',
|
||
connection.local_user_id,
|
||
taskData.start_date || new Date().toISOString(),
|
||
taskData.due_date || null,
|
||
'external'
|
||
];
|
||
|
||
if (columnNames.includes('external_task_id')) {
|
||
fields.push('external_task_id');
|
||
placeholders.push('?');
|
||
values.push(taskData.id);
|
||
}
|
||
|
||
if (columnNames.includes('external_service_id')) {
|
||
fields.push('external_service_id');
|
||
placeholders.push('?');
|
||
values.push(connection.service_id);
|
||
}
|
||
|
||
const sql = `INSERT INTO tasks (${fields.join(', ')}) VALUES (${placeholders.join(', ')})`;
|
||
|
||
this.db.run(sql, values, function(err) {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
|
||
const newTaskId = this.lastID;
|
||
|
||
this.db.run(
|
||
`INSERT INTO task_assignments (task_id, user_id, status, start_date, due_date)
|
||
VALUES (?, ?, ?, ?, ?)`,
|
||
[
|
||
newTaskId,
|
||
connection.local_user_id,
|
||
taskData.status || 'assigned',
|
||
taskData.start_date || new Date().toISOString(),
|
||
taskData.due_date || null
|
||
],
|
||
(err) => {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
|
||
console.log(`✅ Создана задача ${newTaskId} от организатора ${connection.service_name}`);
|
||
resolve(newTaskId);
|
||
}
|
||
);
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
async updateTaskFromOrganizer(connection, organizerTask, localTask) {
|
||
return new Promise((resolve, reject) => {
|
||
this.db.run(
|
||
`UPDATE tasks
|
||
SET title = ?, description = ?, due_date = ?, updated_at = CURRENT_TIMESTAMP
|
||
WHERE id = ?`,
|
||
[organizerTask.title, organizerTask.description || '', organizerTask.due_date || null, localTask.id],
|
||
(err) => {
|
||
if (err) reject(err);
|
||
else {
|
||
console.log(`✅ Обновлена задача ${localTask.id} от организатора`);
|
||
resolve();
|
||
}
|
||
}
|
||
);
|
||
});
|
||
}
|
||
|
||
async updateTaskStatusesFromExecutor(executor, taskStatuses) {
|
||
for (const status of taskStatuses) {
|
||
await new Promise((resolve, reject) => {
|
||
this.db.run(
|
||
`UPDATE task_assignments
|
||
SET status = ?, updated_at = CURRENT_TIMESTAMP
|
||
WHERE task_id = ? AND user_id = ?`,
|
||
[
|
||
status.status,
|
||
status.task_id,
|
||
executor.local_user_id
|
||
],
|
||
function(err) {
|
||
if (err) reject(err);
|
||
else {
|
||
if (this.changes > 0) {
|
||
console.log(`✅ Обновлен статус задачи ${status.task_id}: ${status.status}`);
|
||
}
|
||
resolve();
|
||
}
|
||
}
|
||
);
|
||
});
|
||
|
||
if (status.status === 'completed') {
|
||
await this.checkAndCloseTaskIfAllCompleted(status.task_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
async checkAndCloseTaskIfAllCompleted(taskId) {
|
||
return new Promise((resolve) => {
|
||
this.db.all(
|
||
'SELECT status FROM task_assignments WHERE task_id = ?',
|
||
[taskId],
|
||
(err, assignments) => {
|
||
if (!err && assignments && assignments.length > 0) {
|
||
const allCompleted = assignments.every(a => a.status === 'completed');
|
||
|
||
if (allCompleted) {
|
||
this.db.run(
|
||
'UPDATE tasks SET closed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
|
||
[taskId],
|
||
(err) => {
|
||
if (!err) {
|
||
console.log(`✅ Задача ${taskId} автоматически закрыта`);
|
||
}
|
||
resolve();
|
||
}
|
||
);
|
||
} else {
|
||
resolve();
|
||
}
|
||
} else {
|
||
resolve();
|
||
}
|
||
}
|
||
);
|
||
});
|
||
}
|
||
|
||
async uploadFileToRemote(connection, taskId, fileId) {
|
||
return new Promise((resolve, reject) => {
|
||
this.db.get(
|
||
'SELECT * FROM task_files WHERE id = ?',
|
||
[fileId],
|
||
async (err, file) => {
|
||
if (err || !file) {
|
||
reject(err || new Error('Файл не найден'));
|
||
return;
|
||
}
|
||
|
||
if (!fs.existsSync(file.file_path)) {
|
||
reject(new Error('Файл не существует на диске'));
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const formData = new FormData();
|
||
formData.append('file', fs.createReadStream(file.file_path), {
|
||
filename: file.original_name,
|
||
contentType: 'application/octet-stream'
|
||
});
|
||
formData.append('task_id', taskId);
|
||
formData.append('service_id', connection.service_id);
|
||
|
||
const response = await axios.post(
|
||
`${connection.api_url}/api/external/upload-file`,
|
||
formData,
|
||
{
|
||
headers: formData.getHeaders(),
|
||
auth: {
|
||
username: connection.login,
|
||
password: connection.password
|
||
},
|
||
timeout: 30000,
|
||
maxContentLength: Infinity,
|
||
maxBodyLength: Infinity
|
||
}
|
||
);
|
||
|
||
console.log(`✅ Файл ${file.original_name} загружен в удаленный сервис`);
|
||
resolve(response.data);
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка загрузки файла в удаленный сервис:`, error.message);
|
||
reject(error);
|
||
}
|
||
}
|
||
);
|
||
});
|
||
}
|
||
|
||
async downloadFileFromRemote(connection, remoteFileId, localTaskId) {
|
||
try {
|
||
const response = await axios.get(
|
||
`${connection.api_url}/api/external/download-file/${remoteFileId}`,
|
||
{
|
||
params: { service_id: connection.service_id },
|
||
auth: {
|
||
username: connection.login,
|
||
password: connection.password
|
||
},
|
||
responseType: 'stream',
|
||
timeout: 30000
|
||
}
|
||
);
|
||
|
||
const { createUserTaskFolder } = require('./database');
|
||
const userFolder = createUserTaskFolder(localTaskId, connection.local_user_login || 'external');
|
||
|
||
const fileName = response.headers['x-file-name'] || `remote_${Date.now()}.bin`;
|
||
const filePath = path.join(userFolder, fileName);
|
||
|
||
const writer = fs.createWriteStream(filePath);
|
||
response.data.pipe(writer);
|
||
|
||
await new Promise((resolve, reject) => {
|
||
writer.on('finish', resolve);
|
||
writer.on('error', reject);
|
||
});
|
||
|
||
const fileSize = fs.statSync(filePath).size;
|
||
|
||
return new Promise((resolve, reject) => {
|
||
this.db.run(
|
||
`INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size)
|
||
VALUES (?, ?, ?, ?, ?, ?)`,
|
||
[
|
||
localTaskId,
|
||
connection.local_user_id,
|
||
fileName,
|
||
fileName,
|
||
filePath,
|
||
fileSize
|
||
],
|
||
function(err) {
|
||
if (err) reject(err);
|
||
else {
|
||
console.log(`✅ Файл ${fileName} загружен из удаленного сервиса`);
|
||
resolve({ id: this.lastID, filePath, fileName });
|
||
}
|
||
}
|
||
);
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error(`❌ Ошибка загрузки файла из удаленного сервиса:`, error.message);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
generateAuthToken(serviceId, login) {
|
||
const secret = process.env.EXTERNAL_API_SECRET || 'default_secret_change_me';
|
||
const timestamp = Math.floor(Date.now() / 1000);
|
||
const data = `${serviceId}:${login}:${timestamp}`;
|
||
const hash = crypto.createHmac('sha256', secret).update(data).digest('hex');
|
||
return `${timestamp}:${hash}`;
|
||
}
|
||
|
||
verifyAuthToken(token, serviceId, login) {
|
||
try {
|
||
const secret = process.env.EXTERNAL_API_SECRET || 'default_secret_change_me';
|
||
const [timestamp, hash] = token.split(':');
|
||
|
||
const now = Math.floor(Date.now() / 1000);
|
||
if (now - parseInt(timestamp) > 300) {
|
||
return false;
|
||
}
|
||
|
||
const data = `${serviceId}:${login}:${timestamp}`;
|
||
const expectedHash = crypto.createHmac('sha256', secret).update(data).digest('hex');
|
||
|
||
return crypto.timingSafeEqual(
|
||
Buffer.from(hash, 'hex'),
|
||
Buffer.from(expectedHash, 'hex')
|
||
);
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
async manualSync(connectionId) {
|
||
console.log(`🔄 Ручная синхронизация подключения ${connectionId}`);
|
||
await this.syncConnection(connectionId);
|
||
}
|
||
|
||
async checkConnection(connectionId) {
|
||
const connection = await this.getConnection(connectionId);
|
||
if (!connection) {
|
||
return { success: false, error: 'Подключение не найдено' };
|
||
}
|
||
|
||
const result = {
|
||
id: connection.id,
|
||
service_id: connection.service_id,
|
||
service_name: connection.service_name,
|
||
service_type: connection.service_type,
|
||
local_user_id: connection.local_user_id,
|
||
api_url: connection.api_url,
|
||
status: 'unknown'
|
||
};
|
||
|
||
if (connection.service_type === 'executor') {
|
||
if (!connection.api_url) {
|
||
result.status = 'error';
|
||
result.error = 'Не указан API URL организатора';
|
||
return result;
|
||
}
|
||
|
||
try {
|
||
const response = await axios.get(`${connection.api_url}/api/health`, {
|
||
timeout: 5000,
|
||
auth: {
|
||
username: connection.login,
|
||
password: connection.password
|
||
}
|
||
});
|
||
|
||
result.status = 'connected';
|
||
result.organizer_status = response.data;
|
||
|
||
} catch (error) {
|
||
result.status = 'disconnected';
|
||
result.error = error.message;
|
||
|
||
if (error.code === 'ECONNREFUSED') {
|
||
result.error_details = 'Организатор не доступен по указанному адресу';
|
||
} else if (error.response?.status === 401) {
|
||
result.error_details = 'Ошибка аутентификации - проверьте логин/пароль';
|
||
} else if (error.response?.status === 404) {
|
||
result.error_details = 'API организатора не найдено - проверьте URL';
|
||
} else {
|
||
result.error_details = error.message;
|
||
}
|
||
}
|
||
} else {
|
||
const executors = await this.getAllConnections({
|
||
service_type: 'executor',
|
||
is_active: true
|
||
});
|
||
|
||
result.executors_count = executors.length;
|
||
result.status = executors.length > 0 ? 'has_executors' : 'no_executors';
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
async getSyncStats() {
|
||
const connections = await this.getAllConnections({ is_active: true });
|
||
|
||
const stats = {
|
||
total: connections.length,
|
||
organizers: 0,
|
||
executors: 0,
|
||
lastSyncs: [],
|
||
errors: []
|
||
};
|
||
|
||
connections.forEach(conn => {
|
||
if (conn.service_type === 'organizer') {
|
||
stats.organizers++;
|
||
} else {
|
||
stats.executors++;
|
||
}
|
||
|
||
if (conn.last_sync_at) {
|
||
stats.lastSyncs.push({
|
||
service: conn.service_name,
|
||
last_sync: conn.last_sync_at,
|
||
status: conn.last_sync_status
|
||
});
|
||
}
|
||
|
||
if (conn.last_sync_error) {
|
||
stats.errors.push({
|
||
service: conn.service_name,
|
||
error: conn.last_sync_error,
|
||
time: conn.last_sync_at
|
||
});
|
||
}
|
||
});
|
||
|
||
return stats;
|
||
}
|
||
}
|
||
|
||
function setupUpravlenieEndpoints(app, db) {
|
||
const upravlenieService = new UpravlenieService(db);
|
||
|
||
const requireAuth = (req, res, next) => {
|
||
if (!req.session || !req.session.user) {
|
||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||
}
|
||
next();
|
||
};
|
||
|
||
const requireAdmin = (req, res, next) => {
|
||
if (!req.session || !req.session.user) {
|
||
return res.status(401).json({ error: 'Требуется аутентификация' });
|
||
}
|
||
if (req.session.user.role !== 'admin') {
|
||
return res.status(403).json({ error: 'Требуются права администратора' });
|
||
}
|
||
next();
|
||
};
|
||
|
||
app.get('/api/upravlenie/connections', requireAdmin, async (req, res) => {
|
||
try {
|
||
const filters = {
|
||
service_type: req.query.service_type,
|
||
is_active: req.query.is_active !== undefined ? req.query.is_active === 'true' : undefined,
|
||
sync_enabled: req.query.sync_enabled !== undefined ? req.query.sync_enabled === 'true' : undefined
|
||
};
|
||
|
||
const connections = await upravlenieService.getAllConnections(filters);
|
||
res.json(connections);
|
||
} catch (error) {
|
||
console.error('❌ Ошибка получения подключений:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const connection = await upravlenieService.getConnection(req.params.id);
|
||
if (!connection) {
|
||
return res.status(404).json({ error: 'Подключение не найдено' });
|
||
}
|
||
res.json(connection);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/upravlenie/connections', requireAdmin, async (req, res) => {
|
||
try {
|
||
const connection = await upravlenieService.createConnection(req.body);
|
||
res.json({
|
||
success: true,
|
||
message: 'Подключение создано',
|
||
connection: connection
|
||
});
|
||
} catch (error) {
|
||
console.error('❌ Ошибка создания подключения:', error);
|
||
res.status(400).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.put('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const result = await upravlenieService.updateConnection(req.params.id, req.body);
|
||
res.json({
|
||
success: true,
|
||
message: 'Подключение обновлено',
|
||
changes: result.changes
|
||
});
|
||
} catch (error) {
|
||
res.status(400).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.delete('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
await upravlenieService.deleteConnection(req.params.id);
|
||
res.json({ success: true, message: 'Подключение удалено' });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/upravlenie/connections/:id/sync', requireAdmin, async (req, res) => {
|
||
try {
|
||
await upravlenieService.manualSync(req.params.id);
|
||
res.json({ success: true, message: 'Синхронизация запущена' });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/upravlenie/check/:id', requireAdmin, async (req, res) => {
|
||
try {
|
||
const result = await upravlenieService.checkConnection(req.params.id);
|
||
res.json(result);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/upravlenie/stats', requireAdmin, async (req, res) => {
|
||
try {
|
||
const stats = await upravlenieService.getSyncStats();
|
||
res.json(stats);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
const authenticateExternal = async (req, res, next) => {
|
||
const authHeader = req.headers.authorization;
|
||
|
||
if (!authHeader || !authHeader.startsWith('Basic ')) {
|
||
return res.status(401).json({ error: 'Требуется базовая аутентификация' });
|
||
}
|
||
|
||
const base64Credentials = authHeader.split(' ')[1];
|
||
const credentials = Buffer.from(base64Credentials, 'base64').toString('ascii');
|
||
const [login, password] = credentials.split(':');
|
||
|
||
try {
|
||
const connection = await new Promise((resolve, reject) => {
|
||
db.get(
|
||
'SELECT * FROM upravlenie WHERE login = ? AND password = ? AND is_active = 1',
|
||
[login, password],
|
||
(err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row);
|
||
}
|
||
);
|
||
});
|
||
|
||
if (!connection) {
|
||
return res.status(401).json({ error: 'Неверные учетные данные' });
|
||
}
|
||
|
||
req.externalConnection = connection;
|
||
next();
|
||
} catch (error) {
|
||
console.error('❌ Ошибка аутентификации:', error);
|
||
res.status(500).json({ error: 'Ошибка аутентификации' });
|
||
}
|
||
};
|
||
|
||
app.get('/api/external/tasks', authenticateExternal, async (req, res) => {
|
||
try {
|
||
const { service_id, user_login } = req.query;
|
||
const connection = req.externalConnection;
|
||
|
||
if (parseInt(service_id) !== connection.service_id) {
|
||
return res.status(403).json({ error: 'Неверный service_id' });
|
||
}
|
||
|
||
let userId = null;
|
||
if (user_login) {
|
||
const user = await new Promise((resolve) => {
|
||
db.get('SELECT id FROM users WHERE login = ?', [user_login], (err, row) => {
|
||
resolve(row);
|
||
});
|
||
});
|
||
userId = user?.id;
|
||
}
|
||
|
||
let tasks = [];
|
||
if (userId) {
|
||
tasks = await new Promise((resolve) => {
|
||
db.all(`
|
||
SELECT t.*, ta.status as assignment_status
|
||
FROM tasks t
|
||
JOIN task_assignments ta ON t.id = ta.task_id
|
||
WHERE ta.user_id = ? AND t.status = 'active' AND t.closed_at IS NULL
|
||
`, [userId], (err, rows) => {
|
||
resolve(rows || []);
|
||
});
|
||
});
|
||
} else {
|
||
tasks = await new Promise((resolve) => {
|
||
db.all(`
|
||
SELECT t.*, GROUP_CONCAT(ta.user_id) as assigned_users
|
||
FROM tasks t
|
||
LEFT JOIN task_assignments ta ON t.id = ta.task_id
|
||
WHERE t.status = 'active' AND t.closed_at IS NULL
|
||
GROUP BY t.id
|
||
`, [], (err, rows) => {
|
||
resolve(rows || []);
|
||
});
|
||
});
|
||
}
|
||
|
||
res.json({
|
||
service_id: connection.service_id,
|
||
tasks: tasks.map(t => ({
|
||
id: t.id,
|
||
title: t.title,
|
||
description: t.description,
|
||
status: t.assignment_status || t.status,
|
||
created_at: t.created_at,
|
||
due_date: t.due_date,
|
||
assigned_users: t.assigned_users
|
||
}))
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ Ошибка получения внешних задач:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/external/task-statuses', authenticateExternal, async (req, res) => {
|
||
try {
|
||
const { service_id, statuses } = req.body;
|
||
const connection = req.externalConnection;
|
||
|
||
if (parseInt(service_id) !== connection.service_id) {
|
||
return res.status(403).json({ error: 'Неверный service_id' });
|
||
}
|
||
|
||
if (!Array.isArray(statuses)) {
|
||
return res.status(400).json({ error: 'statuses должен быть массивом' });
|
||
}
|
||
|
||
for (const status of statuses) {
|
||
await new Promise((resolve, reject) => {
|
||
db.run(
|
||
`UPDATE task_assignments
|
||
SET status = ?, updated_at = CURRENT_TIMESTAMP
|
||
WHERE task_id = ?`,
|
||
[status.status, status.task_id],
|
||
function(err) {
|
||
if (err) reject(err);
|
||
else resolve();
|
||
}
|
||
);
|
||
});
|
||
|
||
if (status.status === 'completed') {
|
||
await checkAndCloseTaskIfAllCompleted(db, status.task_id);
|
||
}
|
||
}
|
||
|
||
res.json({
|
||
success: true,
|
||
message: `Получено ${statuses.length} статусов`,
|
||
processed: statuses.length
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ Ошибка получения статусов от исполнителя:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/external/task-statuses', authenticateExternal, async (req, res) => {
|
||
try {
|
||
const { service_id } = req.query;
|
||
const connection = req.externalConnection;
|
||
|
||
if (parseInt(service_id) !== connection.service_id) {
|
||
return res.status(403).json({ error: 'Неверный service_id' });
|
||
}
|
||
|
||
const statuses = await new Promise((resolve) => {
|
||
db.all(`
|
||
SELECT
|
||
t.id as task_id,
|
||
t.external_task_id,
|
||
ta.status,
|
||
t.closed_at as completed_at,
|
||
t.rework_comment as comment
|
||
FROM tasks t
|
||
JOIN task_assignments ta ON t.id = ta.task_id
|
||
WHERE t.external_service_id = ?
|
||
`, [service_id], (err, rows) => {
|
||
resolve(rows || []);
|
||
});
|
||
});
|
||
|
||
res.json({
|
||
service_id: connection.service_id,
|
||
statuses: statuses
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ Ошибка получения статусов для организатора:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/external/upload-file', authenticateExternal, async (req, res) => {
|
||
if (!req.files || !req.files.file) {
|
||
return res.status(400).json({ error: 'Файл не загружен' });
|
||
}
|
||
|
||
try {
|
||
const { task_id, service_id } = req.body;
|
||
const file = req.files.file;
|
||
const connection = req.externalConnection;
|
||
|
||
if (parseInt(service_id) !== connection.service_id) {
|
||
return res.status(403).json({ error: 'Неверный service_id' });
|
||
}
|
||
|
||
const { createUserTaskFolder } = require('./database');
|
||
const userFolder = createUserTaskFolder(task_id, connection.local_user_login || 'external');
|
||
|
||
const fileName = `${Date.now()}_${file.name}`;
|
||
const filePath = path.join(userFolder, fileName);
|
||
|
||
await file.mv(filePath);
|
||
|
||
const result = await new Promise((resolve, reject) => {
|
||
db.run(
|
||
`INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size)
|
||
VALUES (?, ?, ?, ?, ?, ?)`,
|
||
[
|
||
task_id,
|
||
connection.local_user_id,
|
||
fileName,
|
||
file.name,
|
||
filePath,
|
||
file.size
|
||
],
|
||
function(err) {
|
||
if (err) reject(err);
|
||
else resolve({ id: this.lastID });
|
||
}
|
||
);
|
||
});
|
||
|
||
res.json({
|
||
success: true,
|
||
file_id: result.id,
|
||
message: 'Файл успешно загружен'
|
||
});
|
||
|
||
} catch (error) {
|
||
console.error('❌ Ошибка загрузки внешнего файла:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/external/download-file/:fileId', authenticateExternal, async (req, res) => {
|
||
try {
|
||
const { fileId } = req.params;
|
||
const { service_id } = req.query;
|
||
const connection = req.externalConnection;
|
||
|
||
if (parseInt(service_id) !== connection.service_id) {
|
||
return res.status(403).json({ error: 'Неверный service_id' });
|
||
}
|
||
|
||
const file = await new Promise((resolve, reject) => {
|
||
db.get(
|
||
'SELECT * FROM task_files WHERE id = ?',
|
||
[fileId],
|
||
(err, row) => {
|
||
if (err) reject(err);
|
||
else resolve(row);
|
||
}
|
||
);
|
||
});
|
||
|
||
if (!file) {
|
||
return res.status(404).json({ error: 'Файл не найден' });
|
||
}
|
||
|
||
if (!fs.existsSync(file.file_path)) {
|
||
return res.status(404).json({ error: 'Файл не существует на диске' });
|
||
}
|
||
|
||
res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(file.original_name)}"`);
|
||
res.setHeader('X-File-Name', encodeURIComponent(file.original_name));
|
||
res.setHeader('Content-Type', 'application/octet-stream');
|
||
|
||
fs.createReadStream(file.file_path).pipe(res);
|
||
|
||
} catch (error) {
|
||
console.error('❌ Ошибка скачивания файла:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
async function checkAndCloseTaskIfAllCompleted(db, taskId) {
|
||
return new Promise((resolve) => {
|
||
db.all(
|
||
'SELECT status FROM task_assignments WHERE task_id = ?',
|
||
[taskId],
|
||
(err, assignments) => {
|
||
if (!err && assignments && assignments.length > 0) {
|
||
const allCompleted = assignments.every(a => a.status === 'completed');
|
||
|
||
if (allCompleted) {
|
||
db.run(
|
||
'UPDATE tasks SET closed_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
|
||
[taskId],
|
||
(err) => {
|
||
if (!err) {
|
||
console.log(`✅ Задача ${taskId} автоматически закрыта`);
|
||
}
|
||
resolve();
|
||
}
|
||
);
|
||
} else {
|
||
resolve();
|
||
}
|
||
} else {
|
||
resolve();
|
||
}
|
||
}
|
||
);
|
||
});
|
||
}
|
||
|
||
return upravlenieService;
|
||
}
|
||
|
||
module.exports = {
|
||
UpravlenieService,
|
||
setupUpravlenieEndpoints,
|
||
TaskStatus,
|
||
SyncDirection
|
||
}; |