From 0ece532121b17797cc05104f3210f19ba68479ca Mon Sep 17 00:00:00 2001
From: kalugin66 <kalugin66@ya.ru>
Date: Wed, 25 Feb 2026 16:21:37 +0500
Subject: [PATCH] upravlenie-service

---
 public/upravlenie.html | 1093 +++++++++++++++++++++++++++++-----------
 upravlenie-service.js  |  646 ++++++++++--------------
 2 files changed, 1059 insertions(+), 680 deletions(-)

diff --git a/public/upravlenie.html b/public/upravlenie.html
index 342b0ff..0116d7e 100644
--- a/public/upravlenie.html
+++ b/public/upravlenie.html
@@ -5,187 +5,529 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Управление межсервисным взаимодействием</title>
     <style>
-        body {
-            font-family: Arial, sans-serif;
-            margin: 20px;
-            background: #f5f5f5;
-        }
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-            background: white;
-            padding: 20px;
-            border-radius: 8px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-        }
-        h1, h2 {
-            color: #333;
-        }
-        .form-group {
-            margin-bottom: 15px;
-        }
-        label {
-            display: block;
-            margin-bottom: 5px;
-            font-weight: bold;
-        }
-        input, select, textarea {
-            width: 100%;
-            padding: 8px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
+        * {
             box-sizing: border-box;
+            margin: 0;
+            padding: 0;
         }
-        button {
-            background: #4CAF50;
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: #f0f2f5;
+            margin: 0;
+            padding: 20px;
+        }
+
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+            background: white;
+            padding: 15px 20px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+
+        .header h1 {
+            margin: 0;
+            font-size: 24px;
+            color: #1a1a1a;
+        }
+
+        .back-button {
+            background: #6c757d;
             color: white;
             border: none;
-            padding: 10px 20px;
+            padding: 8px 16px;
             border-radius: 4px;
             cursor: pointer;
             font-size: 14px;
-            margin-right: 10px;
+            font-weight: 500;
+            text-decoration: none;
+            display: inline-flex;
+            align-items: center;
+            gap: 5px;
         }
-        button:hover {
-            background: #45a049;
+
+        .back-button:hover {
+            background: #5a6268;
         }
-        button.danger {
-            background: #f44336;
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
         }
-        button.danger:hover {
-            background: #d32f2f;
+
+        .tabs {
+            display: flex;
+            gap: 5px;
+            background: white;
+            padding: 10px;
+            border-radius: 8px 8px 0 0;
+            border-bottom: 1px solid #dee2e6;
         }
-        button.secondary {
-            background: #2196F3;
+
+        .tab {
+            padding: 10px 20px;
+            background: none;
+            border: none;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 500;
+            color: #6c757d;
+            border-radius: 4px 4px 0 0;
         }
-        button.secondary:hover {
-            background: #1976D2;
+
+        .tab:hover {
+            background: #f8f9fa;
+            color: #495057;
         }
+
+        .tab.active {
+            color: #007bff;
+            border-bottom: 2px solid #007bff;
+            background: #f8f9fa;
+        }
+
+        .tab-content {
+            background: white;
+            padding: 20px;
+            border-radius: 0 0 8px 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            min-height: 500px;
+        }
+
+        .action-bar {
+            margin-bottom: 20px;
+            display: flex;
+            gap: 10px;
+            flex-wrap: wrap;
+        }
+
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 500;
+            display: inline-flex;
+            align-items: center;
+            gap: 5px;
+        }
+
+        .btn-primary {
+            background: #007bff;
+            color: white;
+        }
+
+        .btn-primary:hover {
+            background: #0069d9;
+        }
+
+        .btn-success {
+            background: #28a745;
+            color: white;
+        }
+
+        .btn-success:hover {
+            background: #218838;
+        }
+
+        .btn-danger {
+            background: #dc3545;
+            color: white;
+        }
+
+        .btn-danger:hover {
+            background: #c82333;
+        }
+
+        .btn-warning {
+            background: #ffc107;
+            color: #212529;
+        }
+
+        .btn-warning:hover {
+            background: #e0a800;
+        }
+
+        .btn-secondary {
+            background: #6c757d;
+            color: white;
+        }
+
+        .btn-secondary:hover {
+            background: #5a6268;
+        }
+
         table {
             width: 100%;
             border-collapse: collapse;
-            margin-top: 20px;
-        }
-        th, td {
-            border: 1px solid #ddd;
-            padding: 12px;
-            text-align: left;
+            margin-top: 10px;
+            font-size: 14px;
         }
+
         th {
-            background-color: #f2f2f2;
+            background: #f8f9fa;
+            padding: 12px 8px;
+            text-align: left;
+            font-weight: 600;
+            color: #495057;
+            border-bottom: 2px solid #dee2e6;
         }
+
+        td {
+            padding: 10px 8px;
+            border-bottom: 1px solid #e9ecef;
+            vertical-align: middle;
+        }
+
         tr:hover {
-            background-color: #f5f5f5;
+            background: #f8f9fa;
         }
+
         .badge {
+            display: inline-block;
             padding: 3px 8px;
-            border-radius: 4px;
+            border-radius: 12px;
             font-size: 12px;
-            font-weight: bold;
+            font-weight: 500;
         }
-        .badge.organizer {
-            background: #2196F3;
-            color: white;
+
+        .badge-organizer {
+            background: #cce5ff;
+            color: #004085;
         }
-        .badge.executor {
-            background: #4CAF50;
-            color: white;
+
+        .badge-executor {
+            background: #d4edda;
+            color: #155724;
         }
-        .badge.success {
-            background: #4CAF50;
-            color: white;
+
+        .badge-success {
+            background: #d4edda;
+            color: #155724;
         }
-        .badge.error {
-            background: #f44336;
-            color: white;
+
+        .badge-error {
+            background: #f8d7da;
+            color: #721c24;
         }
-        .badge.warning {
-            background: #ff9800;
-            color: white;
+
+        .badge-warning {
+            background: #fff3cd;
+            color: #856404;
         }
+
+        .badge-info {
+            background: #d1ecf1;
+            color: #0c5460;
+        }
+
+        .connection-status {
+            font-size: 12px;
+            margin-top: 5px;
+        }
+
+        .status-success {
+            color: #28a745;
+        }
+
+        .status-error {
+            color: #dc3545;
+        }
+
+        .status-warning {
+            color: #ffc107;
+        }
+
         .actions {
             display: flex;
             gap: 5px;
+            flex-wrap: wrap;
         }
-        .sync-status {
-            margin-top: 20px;
-            padding: 15px;
-            background: #e3f2fd;
+
+        .action-btn {
+            padding: 4px 8px;
+            font-size: 12px;
+            border: none;
+            border-radius: 3px;
+            cursor: pointer;
+            background: #f8f9fa;
+            color: #495057;
+        }
+
+        .action-btn:hover {
+            background: #e9ecef;
+        }
+
+        .action-btn-edit {
+            background: #e7f3ff;
+            color: #007bff;
+        }
+
+        .action-btn-sync {
+            background: #e8f5e9;
+            color: #28a745;
+        }
+
+        .action-btn-check {
+            background: #fff3e0;
+            color: #fd7e14;
+        }
+
+        .action-btn-delete {
+            background: #fee;
+            color: #dc3545;
+        }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .stat-card {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 8px;
+            text-align: center;
+        }
+
+        .stat-value {
+            font-size: 36px;
+            font-weight: bold;
+            color: #007bff;
+            margin-bottom: 5px;
+        }
+
+        .stat-label {
+            font-size: 14px;
+            color: #6c757d;
+        }
+
+        .logs-list {
+            max-height: 400px;
+            overflow-y: auto;
+            border: 1px solid #dee2e6;
             border-radius: 4px;
         }
+
+        .log-item {
+            padding: 10px;
+            border-bottom: 1px solid #e9ecef;
+            font-size: 13px;
+        }
+
+        .log-item:last-child {
+            border-bottom: none;
+        }
+
+        .log-service {
+            font-weight: 600;
+            color: #495057;
+        }
+
+        .log-time {
+            color: #6c757d;
+            font-size: 11px;
+            margin-left: 10px;
+        }
+
+        .log-status {
+            display: inline-block;
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            margin-right: 8px;
+        }
+
         .modal {
             display: none;
             position: fixed;
-            z-index: 1;
+            z-index: 1000;
             left: 0;
             top: 0;
             width: 100%;
             height: 100%;
-            background-color: rgba(0,0,0,0.4);
+            background-color: rgba(0,0,0,0.5);
         }
+
         .modal-content {
             background-color: white;
-            margin: 10% auto;
+            margin: 2% auto;
             padding: 20px;
-            border: 1px solid #888;
-            width: 50%;
             border-radius: 8px;
+            width: 450px;
+            max-width: 95%;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
         }
+
+        .modal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .modal-header h3 {
+            margin: 0;
+            font-size: 18px;
+        }
+
         .close {
+            font-size: 24px;
+            cursor: pointer;
             color: #aaa;
-            float: right;
-            font-size: 28px;
-            font-weight: bold;
-            cursor: pointer;
         }
+
         .close:hover {
-            color: black;
-        }
-        .tab {
-            overflow: hidden;
-            border: 1px solid #ccc;
-            background-color: #f1f1f1;
-            border-radius: 4px 4px 0 0;
-        }
-        .tab button {
-            background-color: inherit;
-            float: left;
-            border: none;
-            outline: none;
-            cursor: pointer;
-            padding: 14px 16px;
-            transition: 0.3s;
             color: #333;
         }
-        .tab button:hover {
-            background-color: #ddd;
+
+        .form-group {
+            margin-bottom: 12px;
         }
-        .tab button.active {
-            background-color: #ccc;
+
+        .form-group label {
+            display: block;
+            font-size: 12px;
+            font-weight: 500;
+            color: #495057;
+            margin-bottom: 3px;
         }
-        .tabcontent {
-            display: none;
-            padding: 20px;
-            border: 1px solid #ccc;
-            border-top: none;
-            border-radius: 0 0 4px 4px;
+
+        .form-group input,
+        .form-group select {
+            width: 100%;
+            padding: 6px 8px;
+            border: 1px solid #ced4da;
+            border-radius: 4px;
+            font-size: 13px;
+        }
+
+        .form-group input:focus,
+        .form-group select:focus {
+            outline: none;
+            border-color: #80bdff;
+            box-shadow: 0 0 0 0.2rem rgba(0,123,255,0.25);
+        }
+
+        .checkbox-group {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .checkbox-group input {
+            width: auto;
+        }
+
+        .form-row {
+            display: flex;
+            gap: 8px;
+        }
+
+        .form-row .form-group {
+            flex: 1;
+        }
+
+        .modal-footer {
+            display: flex;
+            gap: 10px;
+            margin-top: 20px;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #6c757d;
+        }
+
+        .loading::after {
+            content: '';
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 2px solid #f3f3f3;
+            border-top: 2px solid #3498db;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin-left: 10px;
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .error-message {
+            color: #dc3545;
+            font-size: 12px;
+            margin-top: 4px;
+        }
+
+        .success-message {
+            color: #28a745;
+            font-size: 12px;
+            margin-top: 4px;
+        }
+
+        .filter-bar {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 15px;
+            flex-wrap: wrap;
+        }
+
+        .filter-select {
+            padding: 6px 10px;
+            border: 1px solid #ced4da;
+            border-radius: 4px;
+            font-size: 13px;
+            min-width: 150px;
         }
     </style>
 </head>
 <body>
-    <div class="container">
+    <div class="header">
         <h1>Управление межсервисным взаимодействием</h1>
-        
-        <div class="tab">
-            <button class="tablinks active" onclick="openTab(event, 'connections')">Подключения</button>
-            <button class="tablinks" onclick="openTab(event, 'stats')">Статистика</button>
-            <button class="tablinks" onclick="openTab(event, 'logs')">Логи синхронизации</button>
+        <a href="/" class="back-button">← Вернуться на главную</a>
+    </div>
+
+    <div class="container">
+        <div class="tabs">
+            <button class="tab active" onclick="openTab('connections')">Подключения</button>
+            <button class="tab" onclick="openTab('stats')">Статистика</button>
+            <button class="tab" onclick="openTab('logs')">Журнал синхронизации</button>
         </div>
 
-        <div id="connections" class="tabcontent" style="display: block;">
-            <h2>Список подключений</h2>
-            <button onclick="showAddModal()">➕ Добавить подключение</button>
-            
+        <div id="connections-tab" class="tab-content">
+            <div class="action-bar">
+                <button class="btn btn-primary" onclick="showAddModal()">
+                    ➕ Добавить подключение
+                </button>
+                <button class="btn btn-secondary" onclick="refreshConnections()">
+                    🔄 Обновить список
+                </button>
+            </div>
+
+            <div class="filter-bar">
+                <select id="typeFilter" class="filter-select" onchange="applyFilters()">
+                    <option value="">Все типы</option>
+                    <option value="organizer">Организаторы</option>
+                    <option value="executor">Исполнители</option>
+                </select>
+                <select id="statusFilter" class="filter-select" onchange="applyFilters()">
+                    <option value="">Все статусы</option>
+                    <option value="active">Активные</option>
+                    <option value="inactive">Неактивные</option>
+                </select>
+            </div>
+
             <table id="connectionsTable">
                 <thead>
                     <tr>
@@ -193,198 +535,362 @@
                         <th>Service ID</th>
                         <th>Название</th>
                         <th>Тип</th>
-                        <th>Логин</th>
+                        <th>Логин API</th>
                         <th>Локальный пользователь</th>
-                        <th>Синхронизация</th>
-                        <th>Последняя синхр.</th>
                         <th>Статус</th>
+                        <th>Последняя синхр.</th>
+                        <th>Связь</th>
                         <th>Действия</th>
                     </tr>
                 </thead>
-                <tbody id="connectionsList"></tbody>
+                <tbody id="connectionsList">
+                    <tr>
+                        <td colspan="10" class="loading">Загрузка...</td>
+                    </tr>
+                </tbody>
             </table>
         </div>
 
-        <div id="stats" class="tabcontent">
-            <h2>Статистика синхронизации</h2>
-            <div id="statsContent" class="sync-status">Загрузка...</div>
+        <div id="stats-tab" class="tab-content" style="display: none;">
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="stat-value" id="totalConnections">0</div>
+                    <div class="stat-label">Всего подключений</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value" id="totalOrganizers">0</div>
+                    <div class="stat-label">Организаторов</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value" id="totalExecutors">0</div>
+                    <div class="stat-label">Исполнителей</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-value" id="successSync">0</div>
+                    <div class="stat-label">Успешных синхр.</div>
+                </div>
+            </div>
+
+            <h3>Последние синхронизации</h3>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Сервис</th>
+                        <th>Время</th>
+                        <th>Статус</th>
+                    </tr>
+                </thead>
+                <tbody id="lastSyncsList">
+                    <tr>
+                        <td colspan="3" class="loading">Загрузка...</td>
+                    </tr>
+                </tbody>
+            </table>
+
+            <h3 style="margin-top: 30px;">Ошибки</h3>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Сервис</th>
+                        <th>Ошибка</th>
+                        <th>Время</th>
+                    </tr>
+                </thead>
+                <tbody id="errorsList">
+                    <tr>
+                        <td colspan="3">Нет ошибок</td>
+                    </tr>
+                </tbody>
+            </table>
         </div>
 
-        <div id="logs" class="tabcontent">
-            <h2>Логи синхронизации</h2>
-            <div id="logsContent"></div>
+        <div id="logs-tab" class="tab-content" style="display: none;">
+            <div class="action-bar">
+                <button class="btn btn-secondary" onclick="refreshLogs()">
+                    🔄 Обновить
+                </button>
+                <button class="btn btn-warning" onclick="clearLogs()">
+                    🗑️ Очистить
+                </button>
+            </div>
+            <div id="logsList" class="logs-list">
+                <div class="loading">Загрузка...</div>
+            </div>
         </div>
     </div>
 
-    <!-- Модальное окно добавления/редактирования -->
     <div id="connectionModal" class="modal">
         <div class="modal-content">
-            <span class="close" onclick="closeModal()">&times;</span>
-            <h2 id="modalTitle">Добавление подключения</h2>
+            <div class="modal-header">
+                <h3 id="modalTitle">Добавление подключения</h3>
+                <span class="close" onclick="closeModal()">&times;</span>
+            </div>
             
             <form id="connectionForm">
                 <input type="hidden" id="editId">
                 
-                <div class="form-group">
-                    <label for="service_id">Service ID (1-4062):</label>
-                    <input type="number" id="service_id" min="1" max="4062" required>
+                <div class="form-row">
+                    <div class="form-group">
+                        <label>Service ID (1-4062):</label>
+                        <input type="number" id="service_id" min="1" max="4062" required>
+                    </div>
+                    <div class="form-group">
+                        <label>Название:</label>
+                        <input type="text" id="service_name" required>
+                    </div>
                 </div>
 
-                <div class="form-group">
-                    <label for="service_name">Название сервиса:</label>
-                    <input type="text" id="service_name" required>
+                <div class="form-row">
+                    <div class="form-group">
+                        <label>Тип:</label>
+                        <select id="service_type" required>
+                            <option value="organizer">Организатор</option>
+                            <option value="executor">Исполнитель</option>
+                        </select>
+                    </div>
+                    <div class="form-group">
+                        <label>Логин API:</label>
+                        <input type="text" id="login" required>
+                    </div>
                 </div>
 
-                <div class="form-group">
-                    <label for="service_type">Тип сервиса:</label>
-                    <select id="service_type" required>
-                        <option value="organizer">Организатор</option>
-                        <option value="executor">Исполнитель</option>
-                    </select>
+                <div class="form-row">
+                    <div class="form-group">
+                        <label>Пароль API:</label>
+                        <input type="password" id="password" required>
+                    </div>
+                    <div class="form-group">
+                        <label>Интервал (мин):</label>
+                        <input type="number" id="sync_interval" min="1" value="60">
+                    </div>
                 </div>
 
-                <div class="form-group">
-                    <label for="login">Логин для API:</label>
-                    <input type="text" id="login" required>
-                </div>
-
-                <div class="form-group">
-                    <label for="password">Пароль для API:</label>
-                    <input type="password" id="password" required>
-                </div>
-
-                <div class="form-group" id="apiUrlGroup">
-                    <label for="api_url">API URL организатора:</label>
+                <div id="apiUrlGroup" class="form-group">
+                    <label>API URL организатора:</label>
                     <input type="url" id="api_url" placeholder="https://example.com">
                 </div>
 
-                <div class="form-group">
-                    <label for="local_user_id">Локальный пользователь (ID):</label>
-                    <input type="number" id="local_user_id">
+                <div class="form-row">
+                    <div class="form-group">
+                        <label>ID пользователя:</label>
+                        <input type="number" id="local_user_id">
+                    </div>
+                    <div class="form-group">
+                        <label>Логин пользователя:</label>
+                        <input type="text" id="local_user_login">
+                    </div>
                 </div>
 
-                <div class="form-group">
-                    <label for="local_user_login">Логин локального пользователя:</label>
-                    <input type="text" id="local_user_login">
+                <div class="form-row">
+                    <div class="form-group">
+                        <label>Направление:</label>
+                        <select id="sync_direction">
+                            <option value="outgoing">Отправка статусов</option>
+                            <option value="incoming">Получение задач</option>
+                            <option value="both">Двусторонняя</option>
+                        </select>
+                    </div>
+                    <div class="form-group checkbox-group">
+                        <input type="checkbox" id="sync_enabled" checked>
+                        <label>Активно</label>
+                    </div>
                 </div>
 
-                <div class="form-group">
-                    <label for="sync_direction">Направление синхронизации:</label>
-                    <select id="sync_direction">
-                        <option value="outgoing">Отправка статусов</option>
-                        <option value="incoming">Получение задач</option>
-                        <option value="both">Двусторонняя</option>
-                    </select>
-                </div>
-
-                <div class="form-group">
-                    <label for="sync_interval">Интервал синхронизации (минут):</label>
-                    <input type="number" id="sync_interval" min="1" max="1440" value="60">
-                </div>
-
-                <div class="form-group">
-                    <label>
-                        <input type="checkbox" id="sync_enabled" checked> Включить синхронизацию
-                    </label>
-                </div>
-
-                <div class="actions">
-                    <button type="submit">Сохранить</button>
-                    <button type="button" class="danger" onclick="closeModal()">Отмена</button>
+                <div class="modal-footer">
+                    <button type="submit" class="btn btn-success" style="flex: 2;">Сохранить</button>
+                    <button type="button" class="btn btn-danger" style="flex: 1;" onclick="closeModal()">Отмена</button>
                 </div>
             </form>
         </div>
     </div>
 
     <script>
-        // Загрузка списка подключений
+        let connections = [];
+        let stats = null;
+
         async function loadConnections() {
             try {
                 const response = await fetch('/api/upravlenie/connections');
-                const connections = await response.json();
-                
-                const tbody = document.getElementById('connectionsList');
-                tbody.innerHTML = '';
-
-                connections.forEach(conn => {
-                    const tr = document.createElement('tr');
-                    tr.innerHTML = `
-                        <td>${conn.id}</td>
-                        <td><strong>${conn.service_id}</strong></td>
-                        <td>${conn.service_name}</td>
-                        <td><span class="badge ${conn.service_type}">${conn.service_type === 'organizer' ? 'Организатор' : 'Исполнитель'}</span></td>
-                        <td>${conn.login}</td>
-                        <td>${conn.local_user_login || conn.local_user_id || '-'}</td>
-                        <td>
-                            ${conn.sync_enabled ? 
-                                `<span class="badge success">Активна (${conn.sync_interval} мин)</span>` : 
-                                '<span class="badge warning">Отключена</span>'}
-                        </td>
-                        <td>${conn.last_sync_at ? new Date(conn.last_sync_at).toLocaleString() : 'Нет'}</td>
-                        <td>
-                            ${conn.last_sync_status === 'success' ? 
-                                '<span class="badge success">✓</span>' : 
-                                conn.last_sync_status === 'error' ?
-                                '<span class="badge error">✗</span>' :
-                                '<span class="badge warning">?</span>'}
-                        </td>
-                        <td class="actions">
-                            <button class="secondary" onclick="editConnection(${conn.id})">✏️</button>
-                            <button class="secondary" onclick="syncConnection(${conn.id})">🔄</button>
-                            <button class="danger" onclick="deleteConnection(${conn.id})">🗑️</button>
-                        </td>
-                    `;
-                    tbody.appendChild(tr);
-                });
+                connections = await response.json();
+                renderConnections();
             } catch (error) {
                 console.error('Ошибка загрузки подключений:', error);
+                document.getElementById('connectionsList').innerHTML = 
+                    '<tr><td colspan="10" style="color: red; text-align: center;">Ошибка загрузки данных</td></tr>';
             }
         }
 
-        // Загрузка статистики
         async function loadStats() {
             try {
                 const response = await fetch('/api/upravlenie/stats');
-                const stats = await response.json();
-                
-                const content = document.getElementById('statsContent');
-                content.innerHTML = `
-                    <p><strong>Всего подключений:</strong> ${stats.total}</p>
-                    <p><strong>Организаторов:</strong> ${stats.organizers}</p>
-                    <p><strong>Исполнителей:</strong> ${stats.executors}</p>
-                    
-                    <h3>Последние синхронизации:</h3>
-                    <ul>
-                        ${stats.lastSyncs.map(s => `
-                            <li>${s.service}: ${new Date(s.last_sync).toLocaleString()} 
-                                (${s.status === 'success' ? '✓' : s.status === 'error' ? '✗' : '?'})
-                            </li>
-                        `).join('')}
-                    </ul>
-                    
-                    ${stats.errors.length > 0 ? `
-                        <h3>Ошибки:</h3>
-                        <ul style="color: red;">
-                            ${stats.errors.map(e => `
-                                <li>${e.service}: ${e.error} (${new Date(e.time).toLocaleString()})</li>
-                            `).join('')}
-                        </ul>
-                    ` : ''}
-                `;
+                stats = await response.json();
+                renderStats();
             } catch (error) {
                 console.error('Ошибка загрузки статистики:', error);
             }
         }
 
-        // Открытие модального окна для добавления
+        function renderConnections() {
+            const typeFilter = document.getElementById('typeFilter').value;
+            const statusFilter = document.getElementById('statusFilter').value;
+
+            let filtered = [...connections];
+
+            if (typeFilter) {
+                filtered = filtered.filter(c => c.service_type === typeFilter);
+            }
+
+            if (statusFilter === 'active') {
+                filtered = filtered.filter(c => c.is_active === 1);
+            } else if (statusFilter === 'inactive') {
+                filtered = filtered.filter(c => c.is_active === 0);
+            }
+
+            const tbody = document.getElementById('connectionsList');
+            
+            if (filtered.length === 0) {
+                tbody.innerHTML = '<tr><td colspan="10" style="text-align: center;">Нет подключений</td></tr>';
+                return;
+            }
+
+            tbody.innerHTML = filtered.map(conn => `
+                <tr>
+                    <td>${conn.id}</td>
+                    <td><strong>${conn.service_id}</strong></td>
+                    <td>${conn.service_name}</td>
+                    <td><span class="badge badge-${conn.service_type}">${conn.service_type === 'organizer' ? 'Организатор' : 'Исполнитель'}</span></td>
+                    <td>${conn.login}</td>
+                    <td>${conn.local_user_login || conn.local_user_id || '-'}</td>
+                    <td>
+                        ${conn.is_active ? 
+                            '<span class="badge badge-success">Активен</span>' : 
+                            '<span class="badge badge-error">Неактивен</span>'}
+                        ${conn.sync_enabled ? 
+                            '<br><span class="badge badge-info">Синхр. ' + conn.sync_interval + ' мин</span>' : 
+                            ''}
+                    </td>
+                    <td>
+                        ${conn.last_sync_at ? new Date(conn.last_sync_at).toLocaleString() : 'Нет'}
+                        <br>
+                        <span class="badge ${conn.last_sync_status === 'success' ? 'badge-success' : 
+                            conn.last_sync_status === 'error' ? 'badge-error' : 'badge-warning'}">
+                            ${conn.last_sync_status || '?'}
+                        </span>
+                    </td>
+                    <td>
+                        <span id="connection-status-${conn.id}"></span>
+                        <button class="action-btn action-btn-check" onclick="checkConnection(${conn.id})">
+                            🔍 Проверить
+                        </button>
+                    </td>
+                    <td class="actions">
+                        <button class="action-btn action-btn-edit" onclick="editConnection(${conn.id})" title="Редактировать">
+                            ✏️
+                        </button>
+                        <button class="action-btn action-btn-sync" onclick="syncConnection(${conn.id})" title="Синхронизировать">
+                            🔄
+                        </button>
+                        <button class="action-btn action-btn-delete" onclick="deleteConnection(${conn.id})" title="Удалить">
+                            🗑️
+                        </button>
+                    </td>
+                </tr>
+            `).join('');
+        }
+
+        function renderStats() {
+            if (!stats) return;
+
+            document.getElementById('totalConnections').textContent = stats.total || 0;
+            document.getElementById('totalOrganizers').textContent = stats.organizers || 0;
+            document.getElementById('totalExecutors').textContent = stats.executors || 0;
+            document.getElementById('successSync').textContent = stats.lastSyncs?.filter(s => s.status === 'success').length || 0;
+
+            const lastSyncsList = document.getElementById('lastSyncsList');
+            if (stats.lastSyncs?.length > 0) {
+                lastSyncsList.innerHTML = stats.lastSyncs.map(s => `
+                    <tr>
+                        <td>${s.service}</td>
+                        <td>${new Date(s.last_sync).toLocaleString()}</td>
+                        <td><span class="badge ${s.status === 'success' ? 'badge-success' : 
+                            s.status === 'error' ? 'badge-error' : 'badge-warning'}">${s.status}</span></td>
+                    </tr>
+                `).join('');
+            } else {
+                lastSyncsList.innerHTML = '<tr><td colspan="3">Нет данных</td></tr>';
+            }
+
+            const errorsList = document.getElementById('errorsList');
+            if (stats.errors?.length > 0) {
+                errorsList.innerHTML = stats.errors.map(e => `
+                    <tr>
+                        <td>${e.service}</td>
+                        <td style="color: #dc3545;">${e.error}</td>
+                        <td>${new Date(e.time).toLocaleString()}</td>
+                    </tr>
+                `).join('');
+            } else {
+                errorsList.innerHTML = '<tr><td colspan="3">Нет ошибок</td></tr>';
+            }
+        }
+
+        async function refreshLogs() {
+            const logsList = document.getElementById('logsList');
+            logsList.innerHTML = '<div class="loading">Загрузка...</div>';
+            
+            try {
+                const response = await fetch('/api/upravlenie/connections');
+                const conns = await response.json();
+                
+                if (conns.length === 0) {
+                    logsList.innerHTML = '<div class="log-item">Нет данных</div>';
+                    return;
+                }
+
+                let html = '';
+                conns.sort((a, b) => new Date(b.last_sync_at) - new Date(a.last_sync_at)).forEach(conn => {
+                    if (conn.last_sync_at) {
+                        html += `
+                            <div class="log-item">
+                                <span class="log-status ${conn.last_sync_status === 'success' ? 'bg-success' : 
+                                    conn.last_sync_status === 'error' ? 'bg-danger' : 'bg-warning'}"></span>
+                                <span class="log-service">${conn.service_name}</span>
+                                <span class="log-time">${new Date(conn.last_sync_at).toLocaleString()}</span>
+                                <br>
+                                <small>${conn.last_sync_error || 'Статус: ' + conn.last_sync_status}</small>
+                            </div>
+                        `;
+                    }
+                });
+                
+                logsList.innerHTML = html || '<div class="log-item">Нет данных</div>';
+            } catch (error) {
+                logsList.innerHTML = '<div class="log-item" style="color: red;">Ошибка загрузки</div>';
+            }
+        }
+
+        function clearLogs() {
+            if (confirm('Очистить журнал синхронизации?')) {
+                document.getElementById('logsList').innerHTML = '<div class="log-item">Журнал очищен</div>';
+            }
+        }
+
+        function applyFilters() {
+            renderConnections();
+        }
+
         function showAddModal() {
             document.getElementById('modalTitle').textContent = 'Добавление подключения';
             document.getElementById('connectionForm').reset();
             document.getElementById('editId').value = '';
             document.getElementById('connectionModal').style.display = 'block';
+            toggleApiUrlField();
+        }
+
+        function closeModal() {
+            document.getElementById('connectionModal').style.display = 'none';
         }
 
-        // Редактирование подключения
         async function editConnection(id) {
             try {
                 const response = await fetch(`/api/upravlenie/connections/${id}`);
@@ -400,25 +906,39 @@
                 document.getElementById('api_url').value = conn.api_url || '';
                 document.getElementById('local_user_id').value = conn.local_user_id || '';
                 document.getElementById('local_user_login').value = conn.local_user_login || '';
-                document.getElementById('sync_direction').value = conn.sync_direction;
-                document.getElementById('sync_interval').value = conn.sync_interval;
+                document.getElementById('sync_direction').value = conn.sync_direction || 'outgoing';
+                document.getElementById('sync_interval').value = conn.sync_interval || 60;
                 document.getElementById('sync_enabled').checked = conn.sync_enabled === 1;
                 
-                document.getElementById('connectionModal').style.display = 'block';
-                
-                // Обновляем видимость поля API URL
                 toggleApiUrlField();
+                document.getElementById('connectionModal').style.display = 'block';
             } catch (error) {
-                console.error('Ошибка загрузки данных:', error);
+                alert('Ошибка загрузки данных');
             }
         }
 
-        // Закрытие модального окна
-        function closeModal() {
-            document.getElementById('connectionModal').style.display = 'none';
+        async function checkConnection(id) {
+            const statusSpan = document.getElementById(`connection-status-${id}`);
+            statusSpan.innerHTML = '⏳ Проверка...';
+            
+            try {
+                const response = await fetch(`/api/upravlenie/check/${id}`);
+                const result = await response.json();
+                
+                if (result.service_type === 'executor') {
+                    if (result.status === 'connected') {
+                        statusSpan.innerHTML = '<span class="badge badge-success">✅ Связь есть</span>';
+                    } else {
+                        statusSpan.innerHTML = `<span class="badge badge-error">❌ ${result.error_details || 'Нет связи'}</span>`;
+                    }
+                } else {
+                    statusSpan.innerHTML = `<span class="badge badge-info">📊 Исполнителей: ${result.executors_count || 0}</span>`;
+                }
+            } catch (error) {
+                statusSpan.innerHTML = '<span class="badge badge-error">❌ Ошибка</span>';
+            }
         }
 
-        // Ручная синхронизация
         async function syncConnection(id) {
             if (!confirm('Запустить синхронизацию?')) return;
             
@@ -431,14 +951,13 @@
                 if (result.success) {
                     alert('Синхронизация запущена');
                     loadConnections();
+                    loadStats();
                 }
             } catch (error) {
                 alert('Ошибка запуска синхронизации');
-                console.error(error);
             }
         }
 
-        // Удаление подключения
         async function deleteConnection(id) {
             if (!confirm('Удалить подключение?')) return;
             
@@ -454,45 +973,33 @@
                 }
             } catch (error) {
                 alert('Ошибка удаления');
-                console.error(error);
             }
         }
 
-        // Переключение вкладок
-        function openTab(evt, tabName) {
-            const tabcontent = document.getElementsByClassName('tabcontent');
-            for (let i = 0; i < tabcontent.length; i++) {
-                tabcontent[i].style.display = 'none';
-            }
+        function refreshConnections() {
+            loadConnections();
+        }
+
+        function openTab(tabName) {
+            document.querySelectorAll('.tab').forEach(tab => tab.classList.remove('active'));
+            document.querySelectorAll('.tab-content').forEach(content => content.style.display = 'none');
             
-            const tablinks = document.getElementsByClassName('tablinks');
-            for (let i = 0; i < tablinks.length; i++) {
-                tablinks[i].className = tablinks[i].className.replace(' active', '');
-            }
-            
-            document.getElementById(tabName).style.display = 'block';
-            evt.currentTarget.className += ' active';
+            event.target.classList.add('active');
+            document.getElementById(tabName + '-tab').style.display = 'block';
             
             if (tabName === 'stats') {
                 loadStats();
+            } else if (tabName === 'logs') {
+                refreshLogs();
             }
         }
 
-        // Переключение видимости поля API URL в зависимости от типа
         function toggleApiUrlField() {
             const type = document.getElementById('service_type').value;
             const apiUrlGroup = document.getElementById('apiUrlGroup');
-            
-            if (type === 'executor') {
-                apiUrlGroup.style.display = 'block';
-                document.getElementById('api_url').required = true;
-            } else {
-                apiUrlGroup.style.display = 'none';
-                document.getElementById('api_url').required = false;
-            }
+            apiUrlGroup.style.display = type === 'executor' ? 'block' : 'none';
         }
 
-        // Обработка отправки формы
         document.getElementById('connectionForm').addEventListener('submit', async (e) => {
             e.preventDefault();
             
@@ -532,18 +1039,20 @@
                 }
             } catch (error) {
                 alert('Ошибка сохранения');
-                console.error(error);
             }
         });
 
-        // Инициализация
         document.getElementById('service_type').addEventListener('change', toggleApiUrlField);
-        
-        // Загрузка при открытии страницы
-        window.onload = () => {
-            loadConnections();
-            loadStats();
-        };
+
+        window.onclick = function(event) {
+            const modal = document.getElementById('connectionModal');
+            if (event.target === modal) {
+                closeModal();
+            }
+        }
+
+        loadConnections();
+        loadStats();
     </script>
 </body>
 </html>
\ No newline at end of file
diff --git a/upravlenie-service.js b/upravlenie-service.js
index 26c97f5..a6590aa 100644
--- a/upravlenie-service.js
+++ b/upravlenie-service.js
@@ -1,23 +1,15 @@
 // upravlenie-service.js
-/**
- * Модуль управления подключениями между сервисами
- * Позволяет организовать цепочку сервисов (организатор -> исполнители)
- * Каждый сервис имеет общий service_id (1-4062) для идентификации в цепочке
- */
-
 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; // 1 минута
+const SYNC_INTERVAL = 60000;
 const MAX_RETRY_COUNT = 3;
-const RETRY_DELAY = 5000; // 5 секунд
+const RETRY_DELAY = 5000;
 
-// Статусы задач для синхронизации
 const TaskStatus = {
     PENDING: 'pending',
     IN_PROGRESS: 'in_progress',
@@ -28,24 +20,19 @@ const TaskStatus = {
     CANCELLED: 'cancelled'
 };
 
-// Направление синхронизации
 const SyncDirection = {
-    INCOMING: 'incoming',  // Получение задач от организатора
-    OUTGOING: 'outgoing'   // Отправка статусов исполнителю
+    INCOMING: 'incoming',
+    OUTGOING: 'outgoing'
 };
 
-// Класс для работы с подключениями между сервисами
 class UpravlenieService {
     constructor(db) {
         this.db = db;
-        this.syncIntervals = new Map(); // Интервалы синхронизации для каждого подключения
-        this.syncInProgress = new Set(); // Подключения в процессе синхронизации
+        this.syncIntervals = new Map();
+        this.syncInProgress = new Set();
         this.init();
     }
 
-    /**
-     * Инициализация сервиса
-     */
     async init() {
         console.log('🔧 Инициализация сервиса Upravlenie...');
         await this.createTable();
@@ -53,9 +40,6 @@ class UpravlenieService {
         console.log('✅ Сервис Upravlenie инициализирован');
     }
 
-    /**
-     * Создание таблицы upravlenie
-     */
     async createTable() {
         const createTableSQL = `
             CREATE TABLE IF NOT EXISTS upravlenie (
@@ -94,9 +78,6 @@ class UpravlenieService {
         });
     }
 
-    /**
-     * Создание индексов для таблицы upravlenie
-     */
     async createIndexes() {
         const indexes = [
             'CREATE INDEX IF NOT EXISTS idx_upravlenie_service_id ON upravlenie(service_id)',
@@ -126,69 +107,66 @@ class UpravlenieService {
         });
     }
 
-/**
- * Создание нового подключения
- */
-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;
+    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;
 
-    // Валидация service_id
-    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}`);
-    }
-
-    // Для организатора api_url может быть пустым
-    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} не существует`);
+        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}`);
         }
-    }
 
-    // Проверяем уникальность service_id для активных подключений
-    const existing = await this.getConnectionByServiceId(service_id);
-    if (existing && existing.is_active) {
-        throw new Error(`Подключение с service_id ${service_id} уже существует`);
-    }
+        if (service_type === 'executor' && !api_url) {
+            throw new Error('Для исполнителя необходимо указать api_url организатора');
+        }
 
-    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 });
+        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);
+            });
+        });
+    }
 
-    /**
-     * Получение подключения по ID
-     */
     getConnection(id) {
         return new Promise((resolve, reject) => {
             this.db.get('SELECT * FROM upravlenie WHERE id = ?', [id], (err, row) => {
@@ -198,9 +176,6 @@ async createConnection(data) {
         });
     }
 
-    /**
-     * Получение подключения по service_id
-     */
     getConnectionByServiceId(serviceId) {
         return new Promise((resolve, reject) => {
             this.db.get(
@@ -214,9 +189,6 @@ async createConnection(data) {
         });
     }
 
-    /**
-     * Получение всех подключений
-     */
     getAllConnections(filters = {}) {
         return new Promise((resolve, reject) => {
             let sql = 'SELECT * FROM upravlenie WHERE 1=1';
@@ -246,9 +218,6 @@ async createConnection(data) {
         });
     }
 
-    /**
-     * Обновление подключения
-     */
     async updateConnection(id, data) {
         const fields = [];
         const values = [];
@@ -288,16 +257,10 @@ async createConnection(data) {
         });
     }
 
-    /**
-     * Удаление подключения (мягкое удаление)
-     */
     async deleteConnection(id) {
         return this.updateConnection(id, { is_active: 0 });
     }
 
-    /**
-     * Запуск всех задач синхронизации
-     */
     async startAllSyncJobs() {
         const connections = await this.getAllConnections({ 
             is_active: true, 
@@ -311,9 +274,6 @@ async createConnection(data) {
         console.log(`✅ Запущено ${connections.length} задач синхронизации`);
     }
 
-    /**
-     * Запуск задачи синхронизации для конкретного подключения
-     */
     startSyncJob(connectionId, intervalMinutes) {
         this.stopSyncJob(connectionId);
 
@@ -325,15 +285,11 @@ async createConnection(data) {
         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));
@@ -342,9 +298,6 @@ async createConnection(data) {
         }
     }
 
-    /**
-     * Перезапуск задачи синхронизации
-     */
     async restartSyncJob(connectionId) {
         this.stopSyncJob(connectionId);
 
@@ -354,11 +307,7 @@ async createConnection(data) {
         }
     }
 
-    /**
-     * Синхронизация с подключенным сервисом
-     */
     async syncConnection(connectionId) {
-        // Предотвращаем одновременную синхронизацию одного подключения
         if (this.syncInProgress.has(connectionId)) {
             console.log(`⚠️ Синхронизация подключения ${connectionId} уже выполняется`);
             return;
@@ -374,14 +323,11 @@ async createConnection(data) {
 
             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);
             }
 
@@ -396,9 +342,6 @@ async createConnection(data) {
         }
     }
 
-    /**
-     * Обновление статуса синхронизации
-     */
     updateSyncStatus(connectionId, status, error = null) {
         return new Promise((resolve, reject) => {
             this.db.run(
@@ -416,89 +359,83 @@ async createConnection(data) {
         });
     }
 
-/**
- * Синхронизация от исполнителя к организатору
- */
-async syncToOrganizer(connection) {
-    if (!connection.api_url) {
-        throw new Error('Для исполнителя не указан api_url организатора');
-    }
+    async syncToOrganizer(connection) {
+        if (!connection.api_url) {
+            throw new Error('Для исполнителя не указан api_url организатора');
+        }
 
-    // Проверяем наличие локального пользователя
-    if (!connection.local_user_id) {
-        console.warn(`⚠️ Для подключения ${connection.service_name} не указан локальный пользователь. Задачи не будут создаваться.`);
-        return;
-    }
+        console.log(`🔍 Исполнитель ${connection.service_name} пытается связаться с организатором по URL: ${connection.api_url}`);
 
-    // Получаем задачи, назначенные локальному пользователю
-    const localTasks = await this.getTasksForLocalUser(connection.local_user_id);
-    
-    // Получаем задачи от организатора
-    const organizerTasks = await this.fetchTasksFromOrganizer(connection);
-    
-    if (organizerTasks.length === 0) {
-        console.log(`📭 Нет новых задач от организатора для ${connection.service_name}`);
-        return;
-    }
+        if (!connection.local_user_id) {
+            console.warn(`⚠️ Для подключения ${connection.service_name} не указан локальный пользователь. Задачи не будут создаваться.`);
+            return;
+        }
 
-    // Обновляем локальные задачи
-    await this.syncTasksWithOrganizer(connection, organizerTasks, localTasks);
-    
-    // Отправляем обновленные статусы организатору
-    await this.sendTaskStatusesToOrganizer(connection, localTasks);
-}
-
-/**
- * Синхронизация от организатора к исполнителям
- */
-async syncFromExecutors(connection) {
-    // Получаем все активные подключения исполнителей с таким же service_id
-    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);
+            console.log(`📡 Проверка доступности организатора...`);
             
-            if (taskStatuses.length > 0) {
-                // Обновляем статусы в локальной БД
-                await this.updateTaskStatusesFromExecutor(executor, taskStatuses);
-                console.log(`✅ Получено ${taskStatuses.length} статусов от исполнителя ${executor.service_name}`);
+            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(`❌ Ошибка получения статусов от исполнителя ${executor.service_name}:`, error.message);
+            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 checkLocalUserExists(userId) {
-    return new Promise((resolve) => {
-        this.db.get('SELECT id FROM users WHERE id = ?', [userId], (err, row) => {
-            resolve(!!row);
+
+    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) {
@@ -518,9 +455,6 @@ async checkLocalUserExists(userId) {
         });
     }
 
-    /**
-     * Получение задач от организатора через API
-     */
     async fetchTasksFromOrganizer(connection) {
         try {
             const response = await axios.get(`${connection.api_url}/api/external/tasks`, {
@@ -542,9 +476,6 @@ async checkLocalUserExists(userId) {
         }
     }
 
-    /**
-     * Получение статусов задач от исполнителя
-     */
     async fetchTaskStatusesFromExecutor(executor) {
         try {
             const response = await axios.get(`${executor.api_url}/api/external/task-statuses`, {
@@ -565,9 +496,6 @@ async checkLocalUserExists(userId) {
         }
     }
 
-    /**
-     * Отправка статусов задач организатору
-     */
     async sendTaskStatusesToOrganizer(connection, localTasks) {
         const statuses = localTasks.map(task => ({
             task_id: task.id,
@@ -596,119 +524,92 @@ async checkLocalUserExists(userId) {
         }
     }
 
-    /**
-     * Синхронизация задач с организатором
-     */
     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);
             }
         }
     }
 
-// upravlenie-service.js (исправленная версия метода createTaskFromOrganizer)
-
-/**
- * Создание задачи из данных организатора
- */
-async createTaskFromOrganizer(connection, taskData) {
-    return new Promise((resolve, reject) => {
-        // Проверяем, что local_user_id не NULL
-        if (!connection.local_user_id) {
-            reject(new Error('local_user_id не может быть пустым. Укажите локального пользователя для создания задач.'));
-            return;
-        }
-
-        // Сначала проверяем структуру таблицы tasks
-        this.db.all("PRAGMA table_info(tasks)", (err, columns) => {
-            if (err) {
-                reject(err);
+    async createTaskFromOrganizer(connection, taskData) {
+        return new Promise((resolve, reject) => {
+            if (!connection.local_user_id) {
+                reject(new Error('local_user_id не может быть пустым. Укажите локального пользователя для создания задач.'));
                 return;
             }
 
-            const columnNames = columns.map(c => c.name);
-            
-            // Формируем SQL запрос динамически
-            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, // теперь точно не NULL
-                taskData.start_date || new Date().toISOString(),
-                taskData.due_date || null,
-                'external'
-            ];
-
-            // Добавляем external_task_id если колонка существует
-            if (columnNames.includes('external_task_id')) {
-                fields.push('external_task_id');
-                placeholders.push('?');
-                values.push(taskData.id);
-            }
-
-            // Добавляем external_service_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(', ')})`;
-
-            console.log(`📝 Создание задачи от организатора:`, {
-                sql,
-                values,
-                local_user_id: connection.local_user_id,
-                service_id: connection.service_id
-            });
-
-            this.db.run(sql, values, function(err) {
+            this.db.all("PRAGMA table_info(tasks)", (err, columns) => {
                 if (err) {
-                    console.error('❌ Ошибка создания задачи:', err);
                     reject(err);
                     return;
                 }
 
-                const newTaskId = this.lastID;
+                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'
+                ];
 
-                // Назначаем задачу локальному пользователю
-                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) {
-                            console.error('❌ Ошибка назначения задачи:', err);
-                            reject(err);
-                            return;
-                        }
+                if (columnNames.includes('external_task_id')) {
+                    fields.push('external_task_id');
+                    placeholders.push('?');
+                    values.push(taskData.id);
+                }
 
-                        console.log(`✅ Создана задача ${newTaskId} от организатора ${connection.service_name}`);
-                        resolve(newTaskId);
+                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(
@@ -727,9 +628,6 @@ async createTaskFromOrganizer(connection, taskData) {
         });
     }
 
-    /**
-     * Обновление статусов задач от исполнителя
-     */
     async updateTaskStatusesFromExecutor(executor, taskStatuses) {
         for (const status of taskStatuses) {
             await new Promise((resolve, reject) => {
@@ -754,16 +652,12 @@ async createTaskFromOrganizer(connection, taskData) {
                 );
             });
 
-            // Если статус "completed" - проверяем и закрываем задачу если все выполнили
             if (status.status === 'completed') {
                 await this.checkAndCloseTaskIfAllCompleted(status.task_id);
             }
         }
     }
 
-    /**
-     * Проверка и закрытие задачи если все исполнители выполнили
-     */
     async checkAndCloseTaskIfAllCompleted(taskId) {
         return new Promise((resolve) => {
             this.db.all(
@@ -795,9 +689,6 @@ async createTaskFromOrganizer(connection, taskData) {
         });
     }
 
-    /**
-     * Загрузка файла в удаленный сервис
-     */
     async uploadFileToRemote(connection, taskId, fileId) {
         return new Promise((resolve, reject) => {
             this.db.get(
@@ -850,9 +741,6 @@ async createTaskFromOrganizer(connection, taskData) {
         });
     }
 
-    /**
-     * Получение файла из удаленного сервиса
-     */
     async downloadFileFromRemote(connection, remoteFileId, localTaskId) {
         try {
             const response = await axios.get(
@@ -868,7 +756,6 @@ async createTaskFromOrganizer(connection, taskData) {
                 }
             );
 
-            // Сохраняем файл локально
             const { createUserTaskFolder } = require('./database');
             const userFolder = createUserTaskFolder(localTaskId, connection.local_user_login || 'external');
             
@@ -883,7 +770,6 @@ async createTaskFromOrganizer(connection, taskData) {
                 writer.on('error', reject);
             });
 
-            // Сохраняем запись в БД
             const fileSize = fs.statSync(filePath).size;
             
             return new Promise((resolve, reject) => {
@@ -914,9 +800,6 @@ async createTaskFromOrganizer(connection, taskData) {
         }
     }
 
-    /**
-     * Генерация токена для внешней аутентификации
-     */
     generateAuthToken(serviceId, login) {
         const secret = process.env.EXTERNAL_API_SECRET || 'default_secret_change_me';
         const timestamp = Math.floor(Date.now() / 1000);
@@ -925,15 +808,11 @@ async createTaskFromOrganizer(connection, taskData) {
         return `${timestamp}:${hash}`;
     }
 
-    /**
-     * Проверка токена внешней аутентификации
-     */
     verifyAuthToken(token, serviceId, login) {
         try {
             const secret = process.env.EXTERNAL_API_SECRET || 'default_secret_change_me';
             const [timestamp, hash] = token.split(':');
             
-            // Проверяем, что токен не старше 5 минут
             const now = Math.floor(Date.now() / 1000);
             if (now - parseInt(timestamp) > 300) {
                 return false;
@@ -951,17 +830,73 @@ async createTaskFromOrganizer(connection, taskData) {
         }
     }
 
-    /**
-     * Ручная синхронизация подключения
-     */
     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 });
         
@@ -1001,11 +936,9 @@ async createTaskFromOrganizer(connection, taskData) {
     }
 }
 
-// Функция для настройки API endpoints
 function setupUpravlenieEndpoints(app, db) {
     const upravlenieService = new UpravlenieService(db);
 
-    // Middleware для проверки аутентификации
     const requireAuth = (req, res, next) => {
         if (!req.session || !req.session.user) {
             return res.status(401).json({ error: 'Требуется аутентификация' });
@@ -1013,7 +946,6 @@ function setupUpravlenieEndpoints(app, db) {
         next();
     };
 
-    // Middleware для проверки прав администратора
     const requireAdmin = (req, res, next) => {
         if (!req.session || !req.session.user) {
             return res.status(401).json({ error: 'Требуется аутентификация' });
@@ -1024,12 +956,6 @@ function setupUpravlenieEndpoints(app, db) {
         next();
     };
 
-    // ==================== ВНУТРЕННИЕ API (для администрирования) ====================
-
-    /**
-     * GET /api/upravlenie/connections
-     * Получение всех подключений
-     */
     app.get('/api/upravlenie/connections', requireAdmin, async (req, res) => {
         try {
             const filters = {
@@ -1046,10 +972,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * GET /api/upravlenie/connections/:id
-     * Получение подключения по ID
-     */
     app.get('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
         try {
             const connection = await upravlenieService.getConnection(req.params.id);
@@ -1062,10 +984,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * POST /api/upravlenie/connections
-     * Создание нового подключения
-     */
     app.post('/api/upravlenie/connections', requireAdmin, async (req, res) => {
         try {
             const connection = await upravlenieService.createConnection(req.body);
@@ -1080,10 +998,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * PUT /api/upravlenie/connections/:id
-     * Обновление подключения
-     */
     app.put('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
         try {
             const result = await upravlenieService.updateConnection(req.params.id, req.body);
@@ -1097,10 +1011,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * DELETE /api/upravlenie/connections/:id
-     * Удаление подключения
-     */
     app.delete('/api/upravlenie/connections/:id', requireAdmin, async (req, res) => {
         try {
             await upravlenieService.deleteConnection(req.params.id);
@@ -1110,10 +1020,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * POST /api/upravlenie/connections/:id/sync
-     * Ручная синхронизация подключения
-     */
     app.post('/api/upravlenie/connections/:id/sync', requireAdmin, async (req, res) => {
         try {
             await upravlenieService.manualSync(req.params.id);
@@ -1123,10 +1029,15 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * GET /api/upravlenie/stats
-     * Статистика синхронизации
-     */
+    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();
@@ -1136,11 +1047,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    // ==================== ВНЕШНИЕ API (для взаимодействия между сервисами) ====================
-
-    /**
-     * Middleware для аутентификации внешних запросов
-     */
     const authenticateExternal = async (req, res, next) => {
         const authHeader = req.headers.authorization;
         
@@ -1153,7 +1059,6 @@ function setupUpravlenieEndpoints(app, db) {
         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',
@@ -1177,22 +1082,15 @@ function setupUpravlenieEndpoints(app, db) {
         }
     };
 
-    /**
-     * GET /api/external/tasks
-     * Получение задач для внешнего сервиса
-     * (используется исполнителем для получения задач от организатора)
-     */
     app.get('/api/external/tasks', authenticateExternal, async (req, res) => {
         try {
             const { service_id, user_login } = req.query;
             const connection = req.externalConnection;
 
-            // Проверяем соответствие service_id
             if (parseInt(service_id) !== connection.service_id) {
                 return res.status(403).json({ error: 'Неверный service_id' });
             }
 
-            // Если указан user_login, ищем задачи для этого пользователя
             let userId = null;
             if (user_login) {
                 const user = await new Promise((resolve) => {
@@ -1203,10 +1101,8 @@ function setupUpravlenieEndpoints(app, db) {
                 userId = user?.id;
             }
 
-            // Получаем задачи
             let tasks = [];
             if (userId) {
-                // Задачи для конкретного пользователя
                 tasks = await new Promise((resolve) => {
                     db.all(`
                         SELECT t.*, ta.status as assignment_status
@@ -1218,7 +1114,6 @@ function setupUpravlenieEndpoints(app, db) {
                     });
                 });
             } else {
-                // Все активные задачи
                 tasks = await new Promise((resolve) => {
                     db.all(`
                         SELECT t.*, GROUP_CONCAT(ta.user_id) as assigned_users
@@ -1251,10 +1146,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * POST /api/external/task-statuses
-     * Получение статусов задач от исполнителя
-     */
     app.post('/api/external/task-statuses', authenticateExternal, async (req, res) => {
         try {
             const { service_id, statuses } = req.body;
@@ -1268,7 +1159,6 @@ function setupUpravlenieEndpoints(app, db) {
                 return res.status(400).json({ error: 'statuses должен быть массивом' });
             }
 
-            // Обновляем статусы в локальной БД
             for (const status of statuses) {
                 await new Promise((resolve, reject) => {
                     db.run(
@@ -1283,7 +1173,6 @@ function setupUpravlenieEndpoints(app, db) {
                     );
                 });
 
-                // Если статус "completed" - закрываем задачу если все исполнители выполнили
                 if (status.status === 'completed') {
                     await checkAndCloseTaskIfAllCompleted(db, status.task_id);
                 }
@@ -1301,10 +1190,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * GET /api/external/task-statuses
-     * Получение статусов задач для организатора
-     */
     app.get('/api/external/task-statuses', authenticateExternal, async (req, res) => {
         try {
             const { service_id } = req.query;
@@ -1314,7 +1199,6 @@ function setupUpravlenieEndpoints(app, db) {
                 return res.status(403).json({ error: 'Неверный service_id' });
             }
 
-            // Получаем задачи, созданные для этого внешнего сервиса
             const statuses = await new Promise((resolve) => {
                 db.all(`
                     SELECT 
@@ -1342,10 +1226,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * POST /api/external/upload-file
-     * Загрузка файла от исполнителя
-     */
     app.post('/api/external/upload-file', authenticateExternal, async (req, res) => {
         if (!req.files || !req.files.file) {
             return res.status(400).json({ error: 'Файл не загружен' });
@@ -1360,17 +1240,14 @@ function setupUpravlenieEndpoints(app, db) {
                 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)
@@ -1402,10 +1279,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    /**
-     * GET /api/external/download-file/:fileId
-     * Скачивание файла для исполнителя
-     */
     app.get('/api/external/download-file/:fileId', authenticateExternal, async (req, res) => {
         try {
             const { fileId } = req.params;
@@ -1416,7 +1289,6 @@ function setupUpravlenieEndpoints(app, db) {
                 return res.status(403).json({ error: 'Неверный service_id' });
             }
 
-            // Получаем информацию о файле
             const file = await new Promise((resolve, reject) => {
                 db.get(
                     'SELECT * FROM task_files WHERE id = ?',
@@ -1436,7 +1308,6 @@ function setupUpravlenieEndpoints(app, db) {
                 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');
@@ -1449,7 +1320,6 @@ function setupUpravlenieEndpoints(app, db) {
         }
     });
 
-    // Вспомогательная функция для проверки и закрытия задачи
     async function checkAndCloseTaskIfAllCompleted(db, taskId) {
         return new Promise((resolve) => {
             db.all(