chore: bump version to 0.2.3

улучшено debug-логирование и обработка путей
- Добавлен детальный вывод при парсинге листа TEAMS - Добавлен вывод поиска логотипов и сводка по отсутствующим - Исправлен порядок инициализации RUST_LOG - Добавлена поддержка smb:// путей в unc_to_uri
2026-04-17 16:29:03 +03:00 · 2026-04-17 16:00:46 +03:00 · 2026-04-17 14:39:27 +03:00 · 2026-04-17 14:38:38 +03:00 · 2026-04-17 14:20:43 +03:00 · 2026-04-17 12:54:43 +03:00
15 changed files with 2627 additions and 617 deletions
--- a/.env.example
+++ b/.env.example
@@ -0,0 +1,22 @@
 # Synology NAS
 NAS_FQDN="https://your-nas.example.com"
 NAS_USER="your_username"
 NAS_PASS="your_password"
 NAS_FILE="/Team Folder/path/to/file.osheet"
 # Logging (optional, defaults to info)
 RUST_LOG="info"
 # Web Server (optional, defaults to 3000)
 WEB_PORT="3000"
 # Nexrender
 NEXRENDER_API_URL="http://nexrender-server:3050/api/v1/jobs"
 OUTPUT_FOLDER="/path/to/output"
 # After Effects Templates
 TEMPLATE_DOUBLE_SRC="file:///path/to/double_team_template.aep"
 TEMPLATE_SINGLE_SRC="file:///path/to/single_team_template.aep"
 TEMPLATE_COMPOSITION="main"
 TEMPLATE_OUTPUT_MODULE="h264"
 TEMPLATE_OUTPUT_EXT="mp4"
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 .DS_Store
 *.xlsx
 *.txt
 makefile
 # Файлы окружения
 .env
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -10,21 +10,28 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 [[package]]
 name = "ae_anons"
-version = "0.1.0"
+version = "0.2.2"
 dependencies = [
 "anyhow",
 "askama",
 "axum",
 "bytes",
 "calamine",
 "chrono",
 "clap",
 "dotenv",
 "env_logger",
 "futures",
 "log",
 "openssl",
 "regex",
 "reqwest",
 "serde",
 "serde_json",
 "thiserror",
 "tokio",
 "tower",
 "tower-http",
 "urlencoding",
 ]
@@ -111,6 +118,58 @@ dependencies = [
 "derive_arbitrary",
 ]
 [[package]]
 name = "askama"
 version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b8246bcbf8eb97abef10c2d92166449680d41d55c0fc6978a91dec2e3619608"
 dependencies = [
 "askama_macros",
 "itoa",
 "percent-encoding",
 "serde",
 "serde_json",
 ]
 [[package]]
 name = "askama_derive"
 version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f9670bc84a28bb3da91821ef74226949ab63f1265aff7c751634f1dd0e6f97c"
 dependencies = [
 "askama_parser",
 "basic-toml",
 "memchr",
 "proc-macro2",
 "quote",
 "rustc-hash",
 "serde",
 "serde_derive",
 "syn",
 ]
 [[package]]
 name = "askama_macros"
 version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0756b45480437dded0565dfc568af62ccce146fb6cfe902e808ba86e445f44f"
 dependencies = [
 "askama_derive",
 ]
 [[package]]
 name = "askama_parser"
 version = "0.15.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d0af3691ba3af77949c0b5a3925444b85cb58a0184cc7fec16c68ba2e7be868"
 dependencies = [
 "rustc-hash",
 "serde",
 "serde_derive",
 "unicode-ident",
 "winnow",
 ]
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -123,12 +182,73 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 [[package]]
 name = "axum"
 version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
 dependencies = [
 "axum-core",
 "bytes",
 "form_urlencoded",
 "futures-util",
 "http",
 "http-body",
 "http-body-util",
 "hyper",
 "hyper-util",
 "itoa",
 "matchit",
 "memchr",
 "mime",
 "percent-encoding",
 "pin-project-lite",
 "serde_core",
 "serde_json",
 "serde_path_to_error",
 "serde_urlencoded",
 "sync_wrapper",
 "tokio",
 "tower",
 "tower-layer",
 "tower-service",
 "tracing",
 ]
 [[package]]
 name = "axum-core"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
 dependencies = [
 "bytes",
 "futures-core",
 "http",
 "http-body",
 "http-body-util",
 "mime",
 "pin-project-lite",
 "sync_wrapper",
 "tower-layer",
 "tower-service",
 "tracing",
 ]
 [[package]]
 name = "base64"
 version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 [[package]]
 name = "basic-toml"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba62675e8242a4c4e806d12f11d136e626e6c8361d6b829310732241652a178a"
 dependencies = [
 "serde",
 ]
 [[package]]
 name = "bitflags"
 version = "2.11.0"
@@ -197,6 +317,46 @@ dependencies = [
 "windows-link",
 ]
 [[package]]
 name = "clap"
 version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ddb117e43bbf7dacf0a4190fef4d345b9bad68dfc649cb349e7d17d28428e51"
 dependencies = [
 "clap_builder",
 "clap_derive",
 ]
 [[package]]
 name = "clap_builder"
 version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "714a53001bf66416adb0e2ef5ac857140e7dc3a0c48fb28b2f10762fc4b5069f"
 dependencies = [
 "anstream",
 "anstyle",
 "clap_lex",
 "strsim",
 ]
 [[package]]
 name = "clap_derive"
 version = "4.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2ce8604710f6733aa641a2b3731eaa1e8b3d9973d5e3565da11800813f997a9"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "clap_lex"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 [[package]]
 name = "codepage"
 version = "0.1.2"
@@ -517,6 +677,12 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
 [[package]]
 name = "heck"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -550,12 +716,24 @@ dependencies = [
 "pin-project-lite",
 ]
 [[package]]
 name = "http-range-header"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9171a2ea8a68358193d15dd5d70c1c10a2afc3e7e4c5bc92bc9f025cebd7359c"
 [[package]]
 name = "httparse"
 version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 [[package]]
 name = "httpdate"
 version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 [[package]]
 name = "hyper"
 version = "1.9.0"
@@ -570,6 +748,7 @@ dependencies = [
 "http",
 "http-body",
 "httparse",
 "httpdate",
 "itoa",
 "pin-project-lite",
 "smallvec",
@@ -867,6 +1046,12 @@ version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 [[package]]
 name = "matchit"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -980,6 +1165,15 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 [[package]]
 name = "openssl-src"
 version = "300.6.0+3.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8e8cbfd3a4a8c8f089147fd7aaa33cf8c7450c4d09f8f80698a0cf093abeff4"
 dependencies = [
 "cc",
 ]
 [[package]]
 name = "openssl-sys"
 version = "0.9.113"
@@ -988,6 +1182,7 @@ checksum = "ad2f2c0eba47118757e4c6d2bff2838f3e0523380021356e7875e858372ce644"
 dependencies = [
 "cc",
 "libc",
 "openssl-src",
 "pkg-config",
 "vcpkg",
 ]
@@ -1187,6 +1382,12 @@ dependencies = [
 "windows-sys 0.52.0",
 ]
 [[package]]
 name = "rustc-hash"
 version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
 [[package]]
 name = "rustix"
 version = "1.1.4"
@@ -1326,6 +1527,17 @@ dependencies = [
 "zmij",
 ]
 [[package]]
 name = "serde_path_to_error"
 version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
 dependencies = [
 "itoa",
 "serde",
 "serde_core",
 ]
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
@@ -1388,6 +1600,12 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 [[package]]
 name = "strsim"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -1563,6 +1781,7 @@ dependencies = [
 "tokio",
 "tower-layer",
 "tower-service",
 "tracing",
 ]
 [[package]]
@@ -1573,14 +1792,24 @@ checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
 "bitflags",
 "bytes",
 "futures-core",
 "futures-util",
 "http",
 "http-body",
 "http-body-util",
 "http-range-header",
 "httpdate",
 "iri-string",
 "mime",
 "mime_guess",
 "percent-encoding",
 "pin-project-lite",
 "tokio",
 "tokio-util",
 "tower",
 "tower-layer",
 "tower-service",
 "tracing",
 ]
 [[package]]
@@ -1601,6 +1830,7 @@ version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
 dependencies = [
 "log",
 "pin-project-lite",
 "tracing-core",
 ]
@@ -1928,6 +2158,15 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 [[package]]
 name = "winnow"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09dac053f1cd375980747450bfc7250c264eaae0583872e845c0c7cd578872b5"
 dependencies = [
 "memchr",
 ]
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,15 @@
 [package]
 name = "ae_anons"
-version = "0.1.0"
+version = "0.2.3"
 edition = "2021"
 license = "MIT"
 license-file = "LICENSE"
 authors = ["Alexey Barabanov <a.barabanov@tvstart.ru>"]
 description = "Automated Nexrender job generator from Synology Office spreadsheets"
 repository = "https://git.tvstart.ru/lexx/AE_Anons"
 readme = "README.md"
 keywords = ["nexrender", "after-effects", "synology", "automation"]
 categories = ["command-line-utilities", "multimedia"]
 [dependencies]
 reqwest = { version = "0.12", features = ["json", "multipart", "stream"] }
@@ -18,6 +26,26 @@ futures = "0.3"
 anyhow = "1.0"
 log = "0.4"
 env_logger = "0.11"
 bytes = "1.9"
 # Web server (updated to latest stable versions)
 axum = "0.8.9"
 tower = "0.5"
 tower-http = { version = "0.6", features = ["fs", "trace"] }
 askama = "0.15"
 clap = { version = "4.5", features = ["derive"] }
 [dev-dependencies]
 tokio = { version = "1.0", features = ["full", "rt-multi-thread"] }
 [target.x86_64-unknown-linux-gnu.dependencies]
 openssl = { version = "0.10", features = ["vendored"] }
 [target.x86_64-unknown-linux-musl.dependencies]
 openssl = { version = "0.10", features = ["vendored"] }
 [profile.release]
 opt-level = "z"
 lto = true
 codegen-units = 1
 strip = true
--- a/21
+++ b/21
@@ -0,0 +1,21 @@
 # MIT License
 Copyright (c) 2026 [Your Name or Company]
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -1,40 +1,68 @@
-# AE Anons - Автоматизированный генератор спортивных анонсов After Effects
+# AE Anons - Автоматизированный генератор спортивных анонсов в After Effects
 <!-- markdownlint-disable MD033 -->
 <p align="left">
  <img src="assets/logo.png" alt="AE Anons Logo" width="250"/>
 </p>
 <!-- markdownlint-enable MD033 -->
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/Rust-1.70%2B-orange.svg)](https://www.rust-lang.org/)
 [![Status](https://img.shields.io/badge/status-production-green.svg)](https://git.tvstart.ru/lexx/AE_Anons)
 Автоматизированная система для создания спортивных анонсов с использованием шаблонов After Effects через Nexrender, с данными из электронных таблиц Synology Office.
 ## Новое в версии 0.2.2
 - **Веб-интерфейс**: Удобное управление заданиями через браузер
 - **Мониторинг в реальном времени**: Отслеживание статуса всех заданий
 - **Управление очередью**: Остановка, очистка и генерация заданий из веб-интерфейса
 - **Тёмная/светлая тема**: Автоматическое определение системной темы
 - **Сортировка и фильтрация**: Удобная работа с большим количеством заданий
 ## Обзор
-AE Anons автоматизирует создание видеороликов спортивных анонсов путем:
+AE Anons — это CLI-утилита и веб-сервер на Rust, которая выступает как **интеллектуальный генератор заданий**
 для [Nexrender](https://github.com/inlife/nexrender) — опенсорсного оркестратора рендеринга
 After Effects (лицензия MIT).
-1. Подключения к NAS Synology для получения данных расписания из файлов офисных таблиц (.osheet)
+### Режимы работы
-2. Парсинга Excel данных, содержащих информацию о спортивных событиях, командах, каналах и временных интервалах
+
-3. Генерации заданий Nexrender с соответствующими шаблонами и ресурсами
+1. **Однократная обработка** (`--once` или без флагов):
-4. Мониторинга завершения рендеринга и управления выходными файлами
+   - Подключение к NAS Synology
   - Парсинг Excel данных
   - Генерация и отправка заданий Nexrender
   - Мониторинг завершения и выход
 2. **Веб-сервер** (`--web`):
   - Запуск веб-интерфейса на порту `:3000`
   - Управление заданиями через браузер
   - Автообновление статуса каждую минуту
 ## Особенности
- **Интеграция с Synology**: Плавная аутентификация и загрузка файлов с NAS Synology
+- **Интеграция с Synology**: Аутентификация и загрузка файлов с NAS Synology
 - **Экспорт офисных таблиц**: Автоматическое преобразование файлов .osheet в формат Excel
 - **Гибкий парсинг данных**: Динамический парсинг листов с обнаружением заголовков
- **Множественная генерация вариантов**: Создание "Сегодня", "Завтра" и датированных версий для каждого анонса
+- **Множественная генерация вариантов**: Создание "Сегодня", "Завтра" и датированных версий
- **Умное управление логотипами**: Автоматическое разрешение и масштабирование логотипов на основе связей команд/спорта
+- **Умное управление логотипами**: Автоматическое разрешение и масштабирование логотипов
- **Оркестрация заданий Nexrender**: Автоматическая отправка, мониторинг и очистка заданий
+- **Веб-интерфейс**: Удобное управление и мониторинг заданий
- **Профессиональное логирование**: Структурированный журнал с возможностью настройки уровня детализации
+- **REST API**: Программный доступ к управлению заданиями
- **Конфигурация через переменные окружения**: Все параметры управляются через файл `.env`
+- **Профессиональное логирование**: Структурированный журнал с настройкой уровня
 ## Предварительные требования
 - Rust 1.70 или выше
- Доступ к NAS Synology с включенными File Station и Office
+- Доступ к NAS Synology с пакетами File Station и Office
- Экземпляр сервера Nexrender
+- Экземпляр _server_ и _worker_(не менее одного) Nexrender
- Шаблоны After Effects, настроенные на узлах рендеринга (формат Adobe After Effects 2024 .aepx)
+- Шаблоны After Effects (формат Adobe After Effects 2024 .aepx)
 ## Установка
 ### 1. Клонирование репозитория
 ```bash
-git clone https://github.com/your-org/ae_anons.git
+git clone https://git.tvstart.ru/lexx/AE_Anons.git
 cd ae_anons
 ```
@@ -44,36 +72,57 @@ cd ae_anons
 cargo build --release
 ```
 Бинарный файл будет доступен по пути `target/release/ae_anons`
 ### 3. Настройка окружения
-Создайте файл `.env` в корне проекта:
+Скопируйте пример конфигурации и заполните своими данными:
-```env
+```bash
-NAS_FQDN=https://your-synology-nas.example.com:5001
+cp .env.example .env
 NAS_USER=service_account
 NAS_PASS=secure_password
 NAS_FILE=/Team Folder/Broadcast/Auto_Anons/schedule.osheet
 NEXRENDER_API_URL=http://nexrender-server:3000/api/v1/jobs
 OUTPUT_FOLDER=//file-server/edit/Auto_Anons
 RUST_LOG=info
 ```
 Затем отредактируйте файл .env:
 См. раздел Конфигурация для подробной информации.
 ## Использование
-### Базовое выполнение
+### Однократная обработка
 ```bash
 # Запуск с настройками по умолчанию
 ./target/release/ae_anons
-# Запуск с пользовательским уровнем логирования
+# Явно указать однократный режим
 ./target/release/ae_anons --once
 # С отладочным логированием
 RUST_LOG=debug ./target/release/ae_anons
 ```
 ### Веб-сервер
 ```bash
 # Запуск веб-интерфейса на порту по умолчанию (3000)
 ./target/release/ae_anons --web
 # Или с указанием другого порта через .env файл
 # WEB_PORT=8080 ./target/release/ae_anons --web
 ```
 ## Веб-интерфейс
 После запуска веб-сервера откройте браузер:
 - Главная страница: <http://localhost:3000>
 - API эндпоинты:
  - `GET /api/jobs` - список всех заданий
  - `POST /api/generate` - запуск генерации
  - `POST /api/cleanup` - очистка завершённых
  - `POST /api/jobs/stop-all` - остановка активных
  - `GET /api/status` - статус сервера
 ## Уровни логирования
 Управляйте детализацией вывода через переменную окружения `RUST_LOG`:
@@ -93,15 +142,48 @@ RUST_LOG=debug cargo run
 ### Переменные окружения
 | Переменная              | Обязательна | Описание                                             |
-|---------------------|-------------|------------------------------------------------------|
+|-------------------------|-------------|------------------------------------------------------|
 | `NAS_FQDN`              | Да          | URL NAS Synology с протоколом и портом               |
 | `NAS_USER`              | Да          | Имя пользователя учетной записи Synology             |
 | `NAS_PASS`              | Да          | Пароль учетной записи Synology                       |
 | `NAS_FILE`              | Да          | Полный путь к файлу .osheet на NAS                   |
 | `NEXRENDER_API_URL`     | Да          | Конечная точка API сервера Nexrender                 |
 | `OUTPUT_FOLDER`         | Да          | Сетевой путь для рендеренных видео                   |
 | `TEMPLATE_DOUBLE_SRC`   | Да          | Путь к AEP-шаблону для двух команд                   |
 | `TEMPLATE_SINGLE_SRC`   | Да          | Путь к AEP-шаблону для одной команды                 |
 | `TEMPLATE_COMPOSITION`  | Да          | Имя композиции в проекте AE (например, `main`)       |
 | `TEMPLATE_OUTPUT_MODULE`| Да          | Имя модуля вывода в AE (например, `h264`)            |
 | `TEMPLATE_OUTPUT_EXT`   | Да          | Расширение выходного файла (например, `mp4`)         |
 | `WEB_PORT`              | Нет         | Порт для веб-сервера (по умолчанию: 3000)            |
 | `RUST_LOG`              | Нет         | Уровень детализации логирования (по умолчанию: info) |
 ### Пример файла `.env`
 ```env
 # Synology NAS
 NAS_FQDN="https://your-nas.example.com"
 NAS_USER="your_username"
 NAS_PASS="your_password"
 NAS_FILE="/Team Folder/path/to/file.osheet"
 # Logging
 RUST_LOG="info"
 # Web Server
 WEB_PORT="3000"
 # Nexrender
 NEXRENDER_API_URL="http://nexrender-server:3050/api/v1/jobs"
 OUTPUT_FOLDER="/path/to/output"
 # After Effects Templates
 TEMPLATE_DOUBLE_SRC="file:///path/to/double_team_template.aepx"
 TEMPLATE_SINGLE_SRC="file:///path/to/single_team_template.aepx"
 TEMPLATE_COMPOSITION="main"
 TEMPLATE_OUTPUT_MODULE="h264"
 TEMPLATE_OUTPUT_EXT="mp4"
 ```
 ## Структура электронной таблицы
 Файл Excel должен содержать следующие листы со специфичными структурами:
@@ -133,7 +215,7 @@ RUST_LOG=debug cargo run
 Сопоставляет названия каналов с их логотипами. Поля заполняются вручную без выпадающих списков.
-| CHANEL  | LINK                                    |
+| CHANELL | LINK                                    |
 |---------|-----------------------------------------|
 | КАНАЛ   | \\server\share\path\to\channel_logo.png |
 | TRIUMPH | \\server\share\path\to\triumph_logo.png |
@@ -142,12 +224,15 @@ RUST_LOG=debug cargo run
 Основной источник данных для генерации анонсов. Большинство полей заполняются из выпадающих списков, основанных на других листах.
-Обязательные колонки: DATA, TIME, CHANEL, SPORT, LEAGUE, TEAM A, TEAM B
+Обязательные колонки: DATA, TIME, CHANELL, SPORT, LEAGUE, TEAM A, TEAM B
-**Примечание**: Колонка LEAGUE обязательна для заполнения, но не имеет выпадающего списка. Проверка орфографии и опечаток отсутствует!
+**Примечания:**
-| STATE  | TRIPPLE | DATA      | TIME  |   SPORT  |           LEAGUE          | CHANEL  |     TEAM A      |      TEAM B       |
+- Колонка LEAGUE обязательна для заполнения, но не имеет выпадающего списка. Проверка орфографии и опечаток отсутствует!
-|--------|---------|-----------|-------|----------|---------------------------|---------|-----------------|-------------------|
+- Колонка DATA должна содержать дату в формате `ДД.ММ.ГГГГ` (например, `28.2.2026`).
 | STATE | TRIPPLE | DATA      | TIME  | SPORT   | LEAGUE                    | CHANELL | TEAM A          | TEAM B           |
 |-------|---------|-----------|-------|---------|---------------------------|---------|-----------------|------------------|
 | TRUE  | TRUE    | 27.2.2026 | 23:40 | Футбол  | Чемпионат Португалии      | START   | Спортинг#ll#550 | Эшторил#ll#550   |
 | FALSE | TRUE    | 28.2.2026 | 12:55 | Волейбол| Чемпионат Турции. Женщины | TRIUMPH | Бешикташ        | Галатасарай#Turki|
@@ -175,13 +260,6 @@ RUST_LOG=debug cargo run
 ## Выходные файлы
 ### Экспорт JSON
 Во время обработки сохраняются представления таблицы в формате JSON:
 - `{filename}_workbook.json` - Полная структура книги
 - `{filename}_{SheetName}.json` - Данные отдельного листа
 ### Рендеренные видео
 Рендерные видео сохраняются в `OUTPUT_FOLDER` по следующему шаблону именования:
@@ -190,7 +268,8 @@ RUST_LOG=debug cargo run
 YYYYMMDD_Sport_League_TeamA_TeamB_Channel[_Variant].mp4
 ```
-Имена файлов транслитерируются в латиницу. Примеры:
+Имена файлов транслитерируются в латиницу.
 **Примеры:**
 - `20260228_Volleyball_Championship-Turkey-Women_Beşiktaş_Galatasaray_TRIUMPH.mp4`
 - `20260228_Volleyball_Championship-Turkey-Women_Beşiktaş_Galatasaray_TRIUMPH_Today.mp4`
@@ -210,35 +289,174 @@ YYYYMMDD_Sport_League_TeamA_TeamB_Channel[_Variant].mp4
 ## Требования к шаблонам After Effects
-Шаблоны должны быть предварительно настроены на узлах рендеринга со следующими именами слоев:
+Шаблоны должны быть предварительно настроены на узлах рендеринга со следующими именами слоёв.
-### Типы шаблонов
+### Файлы шаблонов
-| Файл шаблона           | Назначение                      |
+Настраиваются через переменные окружения:
 |------------------------|---------------------------------|
 | `PackShot_DOUBLE.aepx` | Сопоставление с двумя командами |
 | `PackShot_SINGLE.aepx` | Анонсы для одной команды        |
-### Обязательные слои
+| Переменная              | Назначение                          | Пример значения                    |
 |-------------------------|-------------------------------------|------------------------------------|
 | `TEMPLATE_DOUBLE_SRC`   | Шаблон для матчей с двумя командами | `file:///path/to/double.aepx`      |
 | `TEMPLATE_SINGLE_SRC`   | Шаблон для анонсов с одной командой | `file:///path/to/single.aepx`      |
 | `TEMPLATE_COMPOSITION`  | Имя главной композиции              | `main`                             |
 | `TEMPLATE_OUTPUT_MODULE`| Имя модуля вывода                   | `h264`                             |
 | `TEMPLATE_OUTPUT_EXT`   | Расширение выходного файла          | `mp4`                              |
-| Имя слоя               | Тип   | Описание                                        |
+### Обязательные слои в шаблонах
-|------------------------|-------|-------------------------------------------------|
+
-| DATA                   | Text  | Отображение даты (автоматически подстраивается) |
+#### Текстовые слои
-| TIME / TIME_H / TIME_M | Text  | Отображение времени                             |
+
-| LEAGUE                 | Text  | Название лиги                                   |
+| Имя слоя  | Шаблон DOUBLE | Шаблон SINGLE | Описание                                        |
-| SPORT                  | Text  | Категория спорта                                |
+|-----------|:-------------:|:-------------:|-------------------------------------------------|
-| TEAMS                  | Text  | Скомбинированные имена команд                   |
+| `DATA`    | ✅            | ✅            | Отображение даты (автоматически подстраивается) |
-| TEAM_A_LOGO            | Image | Логотип домашней команды                        |
+| `TIME_H`  | ✅            | ❌            | Часы (отдельный слой)                           |
-| TEAM_B_LOGO            | Image | Логотип гостевой команды                        |
+| `TIME_M`  | ✅            | ❌            | Минуты (отдельный слой)                         |
-| CHANEL                 | Image | Логотип канала                                  |
+| `TIME`    | ❌            | ✅            | Полное время (единый слой)                      |
-| TOP                    | Video | Наложение видео оформления                      |
+| `LEAGUE`  | ✅            | ✅            | Название лиги/турнира                           |
 | `SPORT`   | ✅            | ✅            | Категория спорта                                |
 | `TEAMS`   | ✅            | ✅            | Скомбинированные имена команд                   |
 #### Слои с изображениями
 | Имя слоя       | Шаблон DOUBLE | Шаблон SINGLE | Описание                    |
 |----------------|:-------------:|:-------------:|-----------------------------|
 | `TEAM_A_LOGO`  | ✅            | ✅            | Логотип команды A           |
 | `TEAM_B_LOGO`  | ✅            | ❌            | Логотип команды B           |
 | `CHANELL`      | ✅            | ✅            | Логотип канала (две буквы L)|
 #### Видео слои
 | Имя слоя  | Шаблон DOUBLE | Шаблон SINGLE | Описание                   |
 |-----------|:-------------:|:-------------:|----------------------------|
 | `TOP`     | ✅            | ✅            | Наложение видео оформления |
 ### Особенности шаблонов
 #### Шаблон DOUBLE (две команды)
 Используется когда в строке Excel заполнены оба поля `TEAM A` и `TEAM B`.
 Обязательные слои:
 - Все текстовые слои с `TIME_H` и `TIME_M` вместо `TIME`
 - Оба логотипа команд: `TEAM_A_LOGO` и `TEAM_B_LOGO`
 #### Шаблон SINGLE (одна команда)
 Используется когда заполнено только одно поле команды.
 Обязательные слои:
 - Текстовый слой `TIME` вместо `TIME_H` и `TIME_M`
 - Только логотип `TEAM_A_LOGO`
 ### Автоматические корректировки
 AE Anons автоматически применяет следующие настройки к слоям:
 #### Слой DATA
 В зависимости от отображаемого текста и типа шаблона:
 | Текст      | Шаблон   | Font Size | Anchor Point |
 |------------|----------|-----------|--------------|
 | "сегодня"  | DOUBLE   | 105       | [0, 5]       |
 | "завтра"   | DOUBLE   | 115       | [0, 25]      |
 | дата (<6)  | DOUBLE   | 120       | [0, 20]      |
 #### Слои TIME_H, TIME_M, TIME
 Корректировка Anchor Point в зависимости от длины текста:
 | Условие           | Anchor Point |
 |-------------------|--------------|
 | 1 символ          | [60, 0]      |
 | 2 символа, <20    | [20, 0]      |
 #### Слой LEAGUE
 Если длина текста превышает 16 символов, размер шрифта уменьшается до 73.
 #### Слой TEAMS
 Если суммарная длина имён команд ≥ 32 символов, размер шрифта уменьшается до 55.
 #### Логотипы (TEAM_A_LOGO, TEAM_B_LOGO)
 Если в имени команды указан целевой размер через `#` (например, `Спортинг##550`), применяется выражение масштабирования:
 ```javascript
 if (width > height) {
    max_size = width;
 } else {
    max_size = height;
 }
 var real_size = 550 / max_size * 100;
 [real_size, real_size]
 ```
 ### Пример структуры слоёв в After Effects
 Ниже представлен рекомендуемый порядок слоёв в композиции. Порядок важен для правильного наложения элементов.
 ```text
 📁 main (композиция)
 ├── 🎬 TOP (видео слой)                    # Видео-оверлей (обязательный)
 ├── 📝 TEAMS (текстовый слой)              # Имена команд (обязательный)
 ├── 📝 LEAGUE (текстовый слой)             # Название лиги (обязательный)
 ├── 📝 SPORT (текстовый слой)              # Вид спорта (обязательный)
 ├── 📝 DATA (текстовый слой)               # Дата (обязательный)
 ├── 📝 TIME (текстовый слой)               # Время (только SINGLE)
 ├── 📝 TIME_H (текстовый слой)             # Часы (только DOUBLE)
 ├── 📝 TIME_M (текстовый слой)             # Минуты (только DOUBLE)
 ├── 🖼️ CHANELL (слой изображения)          # Логотип канала (обязательный)
 ├── 🖼️ TEAM_A_LOGO (слой изображения)      # Логотип команды A (обязательный)
 ├── 🖼️ TEAM_B_LOGO (слой изображения)      # Логотип команды B (только DOUBLE)
 └── 🖼️ BOTTOM (слой изображения)           # Фоновый слой (опционально)
 ```
 ### Формат проекта и совместимость с After Effects
 **Поддерживаемые форматы проектов:**
 - `.aep` — стандартный бинарный формат After Effects (рекомендуется)
 - `.aepx` — XML-формат проекта (поддерживается с AE CC 2015)
 **Совместимость версий After Effects:**
 | Версия After Effects | Поддерживаемые форматы | Особенности                                     |
 |----------------------|------------------------|-------------------------------------------------|
 | CS 5.5               | `.aep`                 | Базовая поддержка                               |
 | CC / CC 2014         | `.aep`                 | Полная поддержка                                |
 | CC 2015 - CC 2019    | `.aep`, `.aepx`        | Добавлена поддержка XML формата `.aepx`         |
 | CC 2020 - CC 2022    | `.aep`, `.aepx`        | Рекомендуется использовать `.aep`               |
 | CC 2023 и новее      | `.aep`, `.aepx`        | **Требуется настройка Output Module** (см. ниже)|
 > **⚠️ Важно для After Effects 2023+:**
 >
 > В версиях After Effects 2023 и новее критически важно настроить **Output Module** в шаблоне проекта. Бинарный файл рендеринга (`aerender`) не будет обрабатывать композицию без явно указанного модуля вывода, даже если в проекте используется модуль по умолчанию.
 >
 > AE Anons автоматически решает эту проблему, используя параметры `TEMPLATE_OUTPUT_MODULE` и `TEMPLATE_OUTPUT_EXT` из `.env` файла. Убедитесь, что эти значения соответствуют настройкам вашего шаблона.
 ### Настройки композиции
- Имя композиции: `pack`
+| Параметр                  | Переменная окружения     | Пример значения | Описание                                    |
- Выходной модуль: `Start_h264`
+|---------------------------|--------------------------|-----------------|---------------------------------------------|
- Формат вывода: `mp4`
+| Имя композиции            | `TEMPLATE_COMPOSITION`   | `main`          | Имя главной композиции в проекте AE         |
- Формат проекта: Adobe After Effects 2024 .aepx
+| Выходной модуль           | `TEMPLATE_OUTPUT_MODULE` | `h264`          | Имя модуля вывода в AE                      |
 | Расширение выходного файла| `TEMPLATE_OUTPUT_EXT`    | `mp4`           | Расширение выходного файла                  |
 **Рекомендации по выбору формата:**
 1. Используйте `.aep` для максимальной совместимости со всеми версиями AE
 2. Версия After Effects на worker-машине должна быть не ниже версии, в которой создан проект
 3. Для AE 2023+ убедитесь, что в шаблоне настроен Output Module с именем, указанным в `TEMPLATE_OUTPUT_MODULE`
 **Источники:**
 - [Nexrender - Tested with After Effects versions](https://github.com/inlife/nexrender#tested-with)
 - [Adobe Aerender documentation](https://helpx.adobe.com/after-effects/using/automated-rendering-network-rendering.html)
 ## Устранение неисправностей
@@ -250,7 +468,7 @@ YYYYMMDD_Sport_League_TeamA_TeamB_Channel[_Variant].mp4
 - Проверьте сетевую связность с NAS
 - Убедитесь, что сервисы File Station и Office включены
-#### Файл не найден**
+#### Файл не найден
 - Убедитесь, что путь в `NAS_FILE` точно соответствует пути в Synology Drive
 - Путь должен начинаться с `/Team Folder/` для рабочих папок
@@ -282,7 +500,6 @@ RUST_LOG=debug ./target/release/ae_anons
 - **Большие таблицы**: Ограничение обработки до 10,000 строк на лист
 - **Задержка сети**: Загрузка файлов с NAS может занимать время для больших файлов
 - **Параллельные задания**: Nexrender управляет очередью заданий внутренне
 - **Использование памяти**: Парсинг Excel сохраняет всю книгу в памяти
 ## Примечания по безопасности
@@ -296,37 +513,85 @@ RUST_LOG=debug ./target/release/ae_anons
 ### Структура кода
 ```shell
-src/
+ae_anons/
-├── main.rs       # Точка входа и оркестрация приложения
+├── .gitignore
-├── config.rs     # Управление конфигурацией
+├── .env.example
-├── nexrender.rs  # Генерация заданий Nexrender и структура данных
+├── Cargo.toml
-└── synology.rs   # Клиент API Synology
+├── LICENSE
 ├── README.md
 ├── assets/
 │   └── logo.png
 └── src/
    ├── main.rs           # Точка входа, CLI
    ├── config.rs         # Конфигурация из .env
    ├── nexrender.rs      # Модели заданий Nexrender
    ├── synology.rs       # Клиент Synology API
    ├── processor.rs      # Логика обработки
    ├── web.rs            # Веб-сервер и API
    └── static/
        ├── index.html    # Веб-интерфейс
        └── style.css     # Стили
 ```
 ### Планируемые новые возможностеи
 1. Расширь `JobData` в `nexrender.rs` для новых полей данных
 2. Обновить логику парсинга листов при необходимости добавления новых колонок  
 3. Добавьть соответствующие слои After Effects в шаблоны
 4. Обновите метод `to_nexrender_job()` с новыми сопоставлениями ресурсов
 ## Зависимости
 ### Основные зависимости
 | Crate              | Версия  | Назначение                              |
-|--------------------|--------|-----------------------------------------|
+|--------------------|---------|-----------------------------------------|
-| reqwest            | 0.12   | HTTP клиент для коммуникации API        |
+| reqwest            | 0.12    | HTTP клиент для коммуникации с API      |
-| serde / serde_json | 1.0    | Сериализация JSON                       |
+| serde / serde_json | 1.0     | Сериализация и десериализация JSON      |
-| calamine           | 0.26   | Парсинг файлов Excel                    |
+| calamine           | 0.26    | Парсинг файлов Excel (.xlsx, .xls)      |
 | chrono             | 0.4     | Обработка дат и времени                 |
 | tokio              | 1.0     | Асинхронная среда выполнения            |
-| dotenv             | 0.15   | Конфигурация через переменные окружения |
+| dotenv             | 0.15    | Загрузка конфигурации из .env файла     |
-| log / env_logger   | 0.11   | Инфраструктура логирования              |
+| log / env_logger   | 0.4/0.11| Система логирования с уровнями          |
-| thiserror          | 2.0    | Определение типов ошибок                |
+| thiserror          | 2.0     | Эргономичные определения типов ошибок   |
-| anyhow             | 1.0    | Обработка ошибок                        |
+| anyhow             | 1.0     | Упрощённая обработка ошибок             |
 | regex              | 1.11    | Регулярные выражения                    |
 | urlencoding        | 2.1     | Кодирование URL для API запросов        |
 | bytes              | 1.9     | Работа с байтовыми данными              |
 | futures            | 0.3     | Асинхронные примитивы                   |
 ### Веб-сервер и CLI
 | Crate              | Версия | Назначение                              |
 |--------------------|--------|-----------------------------------------|
 | axum               | 0.8    | Веб-фреймворк для REST API              |
 | tower              | 0.5    | Промежуточное ПО для веб-сервера        |
 | tower-http         | 0.6    |HTTP утилиты (CORS, статика, трассировка)|
 | askama             | 0.15   | Шаблонизация (опционально)              |
 | clap               | 4.5    | Парсинг аргументов командной строки     |
 ### Платформозависимые зависимости
 | Crate              | Версия | Платформа | Назначение                       |
 |--------------------|--------|-----------|----------------------------------|
 | openssl            | 0.10   | Linux     | Криптография для HTTPS (vendored)|
 ## 🙏 Благодарности
 Особая благодарность проекту **[Nexrender](https://github.com/inlife/nexrender)**
 ([@inlife](https://github.com/inlife) и контрибьюторам) за создание надёжной платформы
 для автоматизации After Effects.
 ## Лицензия
-Ещё не выбранна
+**AE Anons** — [License](LICENSE)  
 **Nexrender** — [MIT License](https://github.com/inlife/nexrender/blob/master/LICENSE)
 Обе лицензии MIT обеспечивают полную свободу использования и модификации кода.
 **Разрешается:**
 - ✅ Использовать в коммерческих целях
 - ✅ Изменять исходный код
 - ✅ Распространять копии
 - ✅ Использовать приватно
 **Требуется:**
 - Сохранять копирайт и текст лицензии
 ## Поддержка
@@ -337,12 +602,44 @@ src/
 ## История изменений
 ### v0.2.2 (текущая)
 - Исправлено отображение имён выходных файлов в веб-интерфейсе
 - Улучшена цветовая схема
 - Добавлена сортировка по всем колонкам
 - Вынесены стили в отдельный CSS файл
 ### v0.2.0
 - Добавлен веб-интерфейс для управления заданиями
 - Реализован REST API
 - Добавлена поддержка тёмной/светлой темы
 - Автообновление статуса заданий
 - Возможность остановки всех активных заданий
 ### v0.1.1
 - Оптимизирована работа с памятью
 - Убрана функция создания .json
 ### v0.1.0
 - Первый выпуск
 - Интеграция с Synology Office
 - Базовая генерация заданий Nexrender
 - Парсинг Excel с динамическим обнаружением листов
- Создание множественных вариантов
+
- Автоматические настройки размера шрифта и позиции
+---
- Умное масштабирование логотипов по целевому размеру
+
 Made with 🦀 Rust and ☕ coffee
--- a/assets/logo.png
+++ b/assets/logo.png
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,28 +1,50 @@
 use anyhow::{Context, Result};
 use dotenv::dotenv;
 use std::env;
 #[derive(Debug, Clone)]
 pub struct Config {
    // Synology
    pub nas_fqdn: String,
    pub nas_user: String,
    pub nas_pass: String,
    pub nas_file: String,
    // Nexrender
    pub nexrender_api_url: String,
    pub output_folder: String,
    // Templates (all required)
    pub template_double_src: String,
    pub template_single_src: String,
    pub template_composition: String,
    pub template_output_module: String,
    pub template_output_ext: String,
    //web_serwer
    pub web_port: u16,
 }
 impl Config {
    pub fn from_env() -> Result<Self> {
        dotenv().ok();
        Ok(Self {
            nas_fqdn: env::var("NAS_FQDN").context("NAS_FQDN not set")?,
            nas_user: env::var("NAS_USER").context("NAS_USER not set")?,
            nas_pass: env::var("NAS_PASS").context("NAS_PASS not set")?,
            nas_file: env::var("NAS_FILE").context("NAS_FILE not set")?,
-            nexrender_api_url: env::var("NEXRENDER_API_URL").context("NEXRENDER_API_URL not set")?,
+            nexrender_api_url: env::var("NEXRENDER_API_URL")
                .context("NEXRENDER_API_URL not set")?,
            output_folder: env::var("OUTPUT_FOLDER").context("OUTPUT_FOLDER not set")?,
            template_double_src: env::var("TEMPLATE_DOUBLE_SRC")
                .context("TEMPLATE_DOUBLE_SRC not set")?,
            template_single_src: env::var("TEMPLATE_SINGLE_SRC")
                .context("TEMPLATE_SINGLE_SRC not set")?,
            template_composition: env::var("TEMPLATE_COMPOSITION")
                .context("TEMPLATE_COMPOSITION not set")?,
            template_output_module: env::var("TEMPLATE_OUTPUT_MODULE")
                .context("TEMPLATE_OUTPUT_MODULE not set")?,
            template_output_ext: env::var("TEMPLATE_OUTPUT_EXT")
                .context("TEMPLATE_OUTPUT_EXT not set")?,
            web_port: env::var("WEB_PORT")
                .unwrap_or_else(|_| "3000".to_string())
                .parse()
                .context("Invalid WEB_PORT")?,
        })
    }
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,510 +1,52 @@
 mod config;
 mod nexrender;
 mod processor;
 mod synology;
 mod web;
-use anyhow::{anyhow, Context, Result};
+use anyhow::Result;
-use calamine::{Data, Reader, Xlsx};
+use clap::Parser;
 use chrono::{Duration, NaiveDate};
 use config::Config;
-use log::{debug, error, info};
+use dotenv::dotenv;
-use nexrender::{JobData, LogoRegistry};
+use log::info;
 use reqwest::Client;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 use std::time::Duration as StdDuration;
 use synology::SynologyClient;
 use tokio::time::sleep;
-#[derive(Debug, Clone)]
+#[derive(Parser)]
-pub struct SheetData {
+#[command(author, version, about, long_about = None)]
-    pub name: String,
+struct Cli {
-    pub headers: Vec<String>,
+    /// Run web server instead of one-time processing
-    pub rows: Vec<HashMap<String, String>>,
+    #[arg(short, long)]
-}
+    web: bool,
-impl SheetData {
+    /// Run one-time processing (default if no flags)
-    pub fn to_json(&self) -> Value {
+    #[arg(short, long)]
-        let rows_json: Vec<Value> = self
+    once: bool,
            .rows
            .iter()
            .map(|row| {
                let map: serde_json::Map<String, Value> = row
                    .iter()
                    .map(|(k, v)| (k.clone(), Value::String(v.clone())))
                    .collect();
                Value::Object(map)
            })
            .collect();
        serde_json::json!({
            "name": self.name,
            "headers": self.headers,
            "rows": rows_json,
            "row_count": self.rows.len(),
            "column_count": self.headers.len()
        })
    }
 }
 #[derive(Debug, Default)]
 pub struct ExcelWorkbook {
    pub sheets: Vec<SheetData>,
 }
 impl ExcelWorkbook {
    pub fn get_sheet(&self, name: &str) -> Option<&SheetData> {
        self.sheets.iter().find(|s| s.name == name)
    }
    pub fn to_json(&self) -> Value {
        let sheets_json: Vec<Value> = self.sheets.iter().map(|s| s.to_json()).collect();
        serde_json::json!(sheets_json)
    }
 }
 #[tokio::main]
 async fn main() -> Result<()> {
    // Загружаем .env до инициализации логгера
    dotenv().ok();
    // Инициализируем логгер
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();
-    info!("Starting AE Anons processor");
+    let cli = Cli::parse();
    let config = Config::from_env()?;
    debug!("Configuration loaded: {:?}", config);
    let mut client = SynologyClient::new(&config.nas_fqdn);
    client.login(&config.nas_user, &config.nas_pass).await?;
    info!("Successfully authenticated with Synology NAS");
    let info = client.get_info().await?;
    info!("Connected to NAS: {}", info.hostname);
    let workbook = download_and_parse_excel(&mut client, &config).await?;
    display_workbook_structure(&workbook);
    save_workbook_json(&workbook, &config.nas_file)?;
    process_nexrender_jobs(&workbook, &config).await?;
    client.logout().await?;
    info!("Session terminated successfully");
    Ok(())
 }
 async fn download_and_parse_excel(
    client: &mut SynologyClient,
    config: &Config,
 ) -> Result<ExcelWorkbook> {
    let file_name_full = Path::new(&config.nas_file)
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("unknown");
    let search_name = file_name_full.replace(".osheet", "");
    let expected_path = Path::new(&config.nas_file)
        .parent()
        .and_then(|p| p.to_str())
        .unwrap_or("");
    let api_format_path = expected_path
        .replace("Team Folder", "team-folders")
        .replace(' ', "");
    let full_expected_path_api = format!("{}/{}", api_format_path, file_name_full);
    info!("Searching for file: {}", full_expected_path_api);
    let search_result = client.search_file_by_name(&search_name).await?;
    let items = search_result["data"]["items"]
        .as_array()
        .ok_or_else(|| anyhow!("No items in search result"))?;
    if items.is_empty() {
        return Err(anyhow!("File '{}' not found", file_name_full));
    }
    let exact_match: Vec<&Value> = items
        .iter()
        .filter(|item| {
            item.get("display_path")
                .and_then(|p| p.as_str())
                .unwrap_or("")
                == full_expected_path_api
        })
        .collect();
    if exact_match.is_empty() {
        return Err(anyhow!("File not found at: {}", full_expected_path_api));
    }
    let file = exact_match[0];
    let file_id = file["file_id"]
        .as_str()
        .ok_or_else(|| anyhow!("Missing file_id"))?;
    let actual_file_name = file["name"]
        .as_str()
        .ok_or_else(|| anyhow!("Missing name"))?;
    info!("Found file: {}", actual_file_name);
    info!("Exporting file from Synology Office to Excel format...");
    let output_path = format!("./{}_export.xlsx", search_name);
    let data = client.export_by_file_id(file_id, actual_file_name).await?;
    let mut file = File::create(&output_path)?;
    file.write_all(&data)?;
    info!("Exported to: {} ({} bytes)", output_path, data.len());
    info!("Parsing Excel workbook...");
    read_excel_workbook(&output_path)
 }
 fn display_workbook_structure(workbook: &ExcelWorkbook) {
    info!("Workbook contains {} sheets", workbook.sheets.len());
    for (idx, sheet) in workbook.sheets.iter().enumerate() {
        debug!(
            "Sheet #{}: '{}' | Headers: {} | Rows: {}",
            idx + 1,
            sheet.name,
            sheet.headers.len(),
            sheet.rows.len()
        );
        if log::log_enabled!(log::Level::Debug) {
            debug!("  Headers: {:?}", sheet.headers);
        }
    }
 }
 fn save_workbook_json(workbook: &ExcelWorkbook, nas_file: &str) -> Result<()> {
    let search_name = Path::new(nas_file)
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("unknown")
        .replace(".osheet", "");
    let json_output = format!("./{}_workbook.json", search_name);
    let json_data = workbook.to_json();
    std::fs::write(&json_output, serde_json::to_string_pretty(&json_data)?)?;
    info!("Full workbook saved to: {}", json_output);
    for sheet in &workbook.sheets {
        let safe_name = sheet
            .name
            .replace(['/', '\\', ':', '*', '?', '"', '<', '>', '|'], "_");
        let sheet_json_path = format!("./{}_{}.json", search_name, safe_name);
        std::fs::write(
            &sheet_json_path,
            serde_json::to_string_pretty(&sheet.to_json())?,
        )?;
    }
    Ok(())
 }
 async fn process_nexrender_jobs(workbook: &ExcelWorkbook, config: &Config) -> Result<()> {
    info!("Preparing Nexrender jobs...");
    let start_sheet = workbook
        .get_sheet("Start")
        .ok_or_else(|| anyhow!("Sheet 'Start' not found"))?;
    let sport_sheet = workbook
        .get_sheet("SPORT")
        .ok_or_else(|| anyhow!("Sheet 'SPORT' not found"))?;
    let teams_sheet = workbook
        .get_sheet("TEAMS")
        .ok_or_else(|| anyhow!("Sheet 'TEAMS' not found"))?;
    let channel_sheet = workbook
        .get_sheet("CHANELL")
        .ok_or_else(|| anyhow!("Sheet 'CHANELL' not found"))?;
    let packs: HashMap<String, String> = sport_sheet
        .rows
        .iter()
        .filter_map(|row| Some((row.get("SPORT")?.clone(), row.get("LINK")?.clone())))
        .collect();
    info!("Loaded {} sport packs", packs.len());
    let mut logos = LogoRegistry::new();
    for row in &teams_sheet.rows {
        if let (Some(team), Some(sport), Some(link)) =
            (row.get("TEAM"), row.get("SPORT"), row.get("LINK"))
        {
            logos.insert(team.clone(), sport.clone(), link.clone());
        }
    }
    info!("Loaded {} team logos", teams_sheet.rows.len());
    let channels: HashMap<String, String> = channel_sheet
        .rows
        .iter()
        .filter_map(|row| Some((row.get("CHANELL")?.clone(), row.get("LINK")?.clone())))
        .collect();
    info!("Loaded {} channel logos", channels.len());
    let mut jobs: Vec<JobData> = Vec::new();
    for (idx, row) in start_sheet.rows.iter().enumerate() {
        if let Some(state) = row.get("STATE") {
            if state == "FALSE" {
                if let Some(job) = JobData::from_row(row, idx, &packs, &logos, &channels) {
                    debug!("Created job for row {}: {}", idx, job.outfile_name);
                    jobs.extend(job.create_variants());
                }
            }
        }
    }
    info!("Generated {} total jobs (including variants)", jobs.len());
    if jobs.is_empty() {
        info!("No jobs with STATE='FALSE' found");
        return Ok(());
    }
    cleanup_finished_jobs(&config.nexrender_api_url).await?;
    let http_client = Client::new();
    let mut submitted_jobs: Vec<(String, String)> = Vec::new();
    for job in &jobs {
        let nexrender_job = job.to_nexrender_job(&config.output_folder);
        info!("Submitting job: {}", job.outfile_name);
        let response = http_client
            .post(&config.nexrender_api_url)
            .json(&nexrender_job)
            .send()
            .await?;
        if response.status().is_success() {
            let result: Value = response.json().await?;
            if let Some(uid) = result.get("uid").and_then(|u| u.as_str()) {
                submitted_jobs.push((uid.to_string(), job.outfile_name.clone()));
                info!("Job submitted successfully, UID: {}", uid);
            }
        } else {
            let status = response.status();
            let text = response.text().await.unwrap_or_default();
            error!("Failed to submit job ({}): {}", status, text);
        }
    }
    if cli.web {
        info!(
-        "Successfully submitted {} jobs to Nexrender",
+            "Starting AE Anons web server v{}",
-        submitted_jobs.len()
+            env!("CARGO_PKG_VERSION")
        );
-
+        web::run_web_server(config).await?;
    if !submitted_jobs.is_empty() {
        info!("Monitoring job completion...");
        monitor_jobs(&http_client, &config.nexrender_api_url, submitted_jobs).await?;
    }
    Ok(())
 }
 fn read_excel_workbook(file_path: &str) -> Result<ExcelWorkbook> {
    let mut workbook: Xlsx<_> = calamine::open_workbook(file_path)
        .map_err(|e| anyhow!("Failed to open workbook: {}", e))?;
    let sheet_names = workbook.sheet_names().to_vec();
    let mut excel_workbook = ExcelWorkbook::default();
    for sheet_name in sheet_names {
        debug!("Processing sheet: '{}'", sheet_name);
        let range = workbook
            .worksheet_range(&sheet_name)
            .map_err(|e| anyhow!("Failed to read sheet '{}': {}", sheet_name, e))?;
        let sheet_data = parse_sheet_dynamic(&sheet_name, &range)?;
        excel_workbook.sheets.push(sheet_data);
    }
    Ok(excel_workbook)
 }
 fn parse_sheet_dynamic(sheet_name: &str, range: &calamine::Range<Data>) -> Result<SheetData> {
    let mut cell_map: HashMap<(usize, usize), String> = HashMap::new();
    let mut max_row = 0usize;
    let mut max_col = 0usize;
    for (row, col, cell) in range.cells() {
        let value = cell_to_string(cell);
        if !value.is_empty() {
            cell_map.insert((row, col), value);
            max_row = max_row.max(row);
            max_col = max_col.max(col);
        }
    }
    if cell_map.is_empty() {
        return Ok(SheetData {
            name: sheet_name.to_string(),
            headers: Vec::new(),
            rows: Vec::new(),
        });
    }
    let mut data_matrix: Vec<Vec<String>> = Vec::new();
    for row in 0..=max_row {
        let mut row_data = Vec::new();
        for col in 0..=max_col {
            row_data.push(cell_map.get(&(row, col)).cloned().unwrap_or_default());
        }
        data_matrix.push(row_data);
    }
    let headers: Vec<String> = if !data_matrix.is_empty() {
        data_matrix[0]
            .iter()
            .enumerate()
            .map(|(idx, header)| {
                let h = header.trim().to_string();
                if h.is_empty() {
                    format!("Column_{}", idx + 1)
    } else {
                    h
                }
            })
            .collect()
    } else {
        Vec::new()
    };
    let mut rows_data = Vec::new();
    for row_values in data_matrix.iter().skip(1) {
        let mut row_map = HashMap::new();
        for (col_idx, value) in row_values.iter().enumerate() {
            if col_idx < headers.len() && !value.is_empty() {
                row_map.insert(headers[col_idx].clone(), value.clone());
            }
        }
        if !row_map.is_empty() {
            rows_data.push(row_map);
        }
        if rows_data.len() >= 10000 {
            break;
        }
    }
    Ok(SheetData {
        name: sheet_name.to_string(),
        headers,
        rows: rows_data,
    })
 }
 fn excel_date_to_string(serial: f64) -> String {
    let days = serial as i64;
    let base = NaiveDate::from_ymd_opt(1899, 12, 30).unwrap();
    if let Some(date) = base.checked_add_signed(Duration::days(days)) {
        date.format("%d.%m.%Y").to_string()
    } else {
        serial.to_string()
    }
 }
 fn is_excel_date(value: f64) -> bool {
    (1.0..100000.0).contains(&value)
 }
 fn cell_to_string(cell: &Data) -> String {
    match cell {
        Data::Empty => String::new(),
        Data::String(s) => s.clone(),
        Data::Float(f) => {
            if is_excel_date(*f) {
                excel_date_to_string(*f)
            } else if f.fract() == 0.0 {
                format!("{:.0}", f)
            } else {
                f.to_string()
            }
        }
        Data::Int(i) => {
            let f = *i as f64;
            if is_excel_date(f) {
                excel_date_to_string(f)
            } else {
                i.to_string()
            }
        }
        Data::Bool(b) => b.to_string(),
        Data::DateTime(dt) => {
            let serial = dt.as_f64();
            if is_excel_date(serial) {
                excel_date_to_string(serial)
            } else {
                dt.to_string()
            }
        }
        Data::DateTimeIso(s) => s.clone(),
        Data::DurationIso(s) => s.clone(),
        Data::Error(e) => format!("{:?}", e),
    }
 }
 async fn cleanup_finished_jobs(api_url: &str) -> Result<()> {
    let client = Client::new();
    let response = client.get(api_url).send().await?;
    if response.status().is_success() {
        let jobs: Vec<Value> = response.json().await?;
        for job in jobs {
            if let (Some(uid), Some(state)) = (
                job.get("uid").and_then(|u| u.as_str()),
                job.get("state").and_then(|s| s.as_str()),
            ) {
                if state == "finished" || state == "error" {
                    client
                        .delete(&format!("{}/{}", api_url, uid))
                        .send()
                        .await?;
                    info!("Cleaned up completed job: {}", uid);
                }
            }
        }
    }
    Ok(())
 }
 async fn monitor_jobs(
    client: &Client,
    api_url: &str,
    mut pending: Vec<(String, String)>,
 ) -> Result<()> {
    while !pending.is_empty() {
        sleep(StdDuration::from_secs(25)).await;
        let mut remaining = Vec::new();
        for (uid, outname) in &pending {
            let response = client.get(&format!("{}/{}", api_url, uid)).send().await?;
            if response.status().is_success() {
                let job: Value = response.json().await?;
                let state = job
                    .get("state")
                    .and_then(|s| s.as_str())
                    .unwrap_or("unknown");
                match state {
                    "finished" => {
        info!(
-                            "Job completed: {} ({} remaining)",
+            "Starting AE Anons processor v{} (one-time mode)",
-                            outname,
+            env!("CARGO_PKG_VERSION")
-                            pending.len() - 1
+        );
-                        )
+        let submitted = processor::process_spreadsheet(&config).await?;
        info!("Submitted {} jobs. Exiting.", submitted.len());
    }
-                    "error" => error!("Job failed: {} ({} remaining)", outname, pending.len() - 1),
+
                    _ => remaining.push((uid.clone(), outname.clone())),
                }
            } else {
                remaining.push((uid.clone(), outname.clone()));
            }
        }
        pending = remaining;
        if !pending.is_empty() {
            info!("Waiting for {} jobs to complete...", pending.len());
        }
    }
    info!("All jobs completed successfully");
    Ok(())
 }
--- a/src/nexrender.rs
+++ b/src/nexrender.rs
@@ -1,3 +1,4 @@
 #![allow(dead_code)]
 use chrono::{Datelike, NaiveDate};
 use serde::Serialize;
 use serde_json::json;
@@ -89,22 +90,32 @@ pub struct Template {
    pub output_ext: String,
 }
-impl Default for Template {
+impl Template {
-    fn default() -> Self {
+    pub fn double(
        src: String,
        composition: String,
        output_module: String,
        output_ext: String,
    ) -> Self {
        Self {
-            src: "file:///c:/users/virtVmix-2/Downloads/PackShot_DOUBLE.aepx".to_string(),
+            src,
-            composition: "pack".to_string(),
+            composition,
-            output_module: "Start_h264".to_string(),
+            output_module,
-            output_ext: "mp4".to_string(),
+            output_ext,
        }
        }
    }
-impl Template {
+    pub fn single(
-    pub fn single() -> Self {
+        src: String,
        composition: String,
        output_module: String,
        output_ext: String,
    ) -> Self {
        Self {
-            src: "file:///c:/users/virtVmix-2/Downloads/PackShot_SINGLE.aepx".to_string(),
+            src,
-            ..Default::default()
+            composition,
            output_module,
            output_ext,
        }
    }
 }
@@ -291,17 +302,31 @@ impl JobData {
        variants
    }
-    pub fn to_nexrender_job(&self, output_folder: &str) -> NexrenderJob {
+    pub fn to_nexrender_job(&self, config: &crate::config::Config) -> NexrenderJob {
        let template = if self.team_b.is_empty() {
-            Template::single()
+            Template::single(
                config.template_single_src.clone(),
                config.template_composition.clone(),
                config.template_output_module.clone(),
                config.template_output_ext.clone(),
            )
        } else {
-            Template::default()
+            Template::double(
                config.template_double_src.clone(),
                config.template_composition.clone(),
                config.template_output_module.clone(),
                config.template_output_ext.clone(),
            )
        };
-        let output_path = format!("{}/{}.mp4", output_folder, self.outfile_name);
+        let output_path = format!(
            "{}/{}.{}",
            config.output_folder, self.outfile_name, config.template_output_ext
        );
        let mut actions = Actions::default();
        actions.postrender.push(PostrenderAction::Copy {
-            input: "encoded.mp4".to_string(),
+            input: format!("encoded.{}", config.template_output_ext),
            output: output_path,
        });
@@ -502,19 +527,33 @@ impl LogoRegistry {
        Self::default()
    }
    pub fn with_capacity(capacity: usize) -> Self {
        Self {
            logos: HashMap::with_capacity(capacity),
        }
    }
    pub fn insert(&mut self, team: String, sport: String, link: String) {
        self.logos.insert((team, sport), link);
    }
    // В impl LogoRegistry, функция find()
    pub fn find(&self, team: &str, sport: &str) -> Option<String> {
        log::debug!("LogoRegistry::find: team='{}', sport='{}'", team, sport);
        if let Some(link) = self.logos.get(&(team.to_string(), sport.to_string())) {
            log::debug!("Found exact match: {}", link);
            return Some(link.clone());
        }
        for ((t, s), link) in &self.logos {
            if s == sport && team.starts_with(t) {
                log::debug!("Found prefix match: t='{}', link='{}'", t, link);
                return Some(link.clone());
            }
        }
        log::warn!("No logo found for team='{}', sport='{}'", team, sport);
        None
    }
 }
@@ -572,12 +611,26 @@ fn unc_to_uri(path: &str) -> String {
    if path.is_empty() {
        return String::new();
    }
    // Уже правильный URI
    if path.starts_with("http://") || path.starts_with("https://") || path.starts_with("file://") {
        return path.to_string();
    }
-    format!("file://{}", path.replace('\\', "/").trim_start_matches('/'))
+
    // Mac SMB путь: smb://server/share/path -> file://server/share/path
    if path.starts_with("smb://") {
        let without_smb = path.strip_prefix("smb:").unwrap_or(path);
        return format!("file:{}", without_smb.replace('\\', "/"));
    }
    // Windows UNC путь: \\server\share\path -> file://server/share/path
    let normalized = path.replace('\\', "/");
    // Убираем ведущие слеши (для UNC их быть не должно)
    let trimmed = normalized.trim_start_matches('/');
    format!("file://{}", trimmed)
 }
 fn logo_scale_expression(target_size: &str) -> String {
    format!(
        "if (width > height) {{max_size = width;}} else {{max_size = height;}} var real_size = {}/max_size*100;[real_size,real_size]",
--- a/src/processor.rs
+++ b/src/processor.rs
@@ -0,0 +1,521 @@
 use crate::config::Config;
 use crate::nexrender::{JobData, LogoRegistry};
 use crate::synology::SynologyClient;
 use anyhow::{anyhow, Result};
 use calamine::{Data, Reader, Xlsx};
 use chrono::{Duration, NaiveDate};
 use log::{debug, error, info, log_enabled, Level};
 use reqwest::Client;
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
 use std::io::Cursor;
 use std::path::Path;
 #[derive(Debug, Clone)]
 pub struct SheetData {
    pub name: String,
    pub headers: Vec<String>,
    pub rows: Vec<HashMap<String, String>>,
 }
 #[derive(Debug, Default)]
 pub struct ExcelWorkbook {
    pub sheets: Vec<SheetData>,
 }
 impl ExcelWorkbook {
    pub fn get_sheet(&self, name: &str) -> Option<&SheetData> {
        self.sheets.iter().find(|s| s.name == name)
    }
 }
 /// Основная функция обработки: скачивает Excel, генерирует задания, отправляет в Nexrender
 pub async fn process_spreadsheet(config: &Config) -> Result<Vec<(String, String)>> {
    let mut client = SynologyClient::new(&config.nas_fqdn);
    client.login(&config.nas_user, &config.nas_pass).await?;
    info!("Successfully authenticated with Synology NAS");
    let info = client.get_info().await?;
    info!("Connected to NAS: {}", info.hostname);
    // Скачиваем и парсим Excel в памяти
    let workbook = download_and_parse_excel_in_memory(&mut client, config).await?;
    display_workbook_structure(&workbook);
    let submitted = generate_and_submit_jobs(&workbook, config).await?;
    client.logout().await?;
    info!("Session terminated successfully");
    Ok(submitted)
 }
 async fn download_and_parse_excel_in_memory(
    client: &mut SynologyClient,
    config: &Config,
 ) -> Result<ExcelWorkbook> {
    let file_name_full = Path::new(&config.nas_file)
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("unknown");
    let search_name = file_name_full.replace(".osheet", "");
    let expected_path = Path::new(&config.nas_file)
        .parent()
        .and_then(|p| p.to_str())
        .unwrap_or("");
    let api_format_path = expected_path
        .replace("Team Folder", "team-folders")
        .replace(' ', "");
    let full_expected_path_api = format!("{}/{}", api_format_path, file_name_full);
    info!("Searching for file: {}", full_expected_path_api);
    let search_result = client.search_file_by_name(&search_name).await?;
    let items = search_result["data"]["items"]
        .as_array()
        .ok_or_else(|| anyhow!("No items in search result"))?;
    if items.is_empty() {
        return Err(anyhow!("File '{}' not found", file_name_full));
    }
    let exact_match: Vec<&Value> = items
        .iter()
        .filter(|item| {
            item.get("display_path")
                .and_then(|p| p.as_str())
                .unwrap_or("")
                == full_expected_path_api
        })
        .collect();
    if exact_match.is_empty() {
        return Err(anyhow!("File not found at: {}", full_expected_path_api));
    }
    let file = exact_match[0];
    let file_id = file["file_id"]
        .as_str()
        .ok_or_else(|| anyhow!("Missing file_id"))?;
    let actual_file_name = file["name"]
        .as_str()
        .ok_or_else(|| anyhow!("Missing name"))?;
    info!("Found file: {}", actual_file_name);
    info!("Exporting file from Synology Office to Excel format (in-memory)...");
    // Получаем бинарные данные Excel напрямую в память
    let excel_data = client.export_by_file_id(file_id, actual_file_name).await?;
    info!("Exported {} bytes to memory", excel_data.len());
    info!("Parsing Excel workbook from memory...");
    parse_excel_from_bytes(&excel_data)
 }
 fn parse_excel_from_bytes(data: &[u8]) -> Result<ExcelWorkbook> {
    let cursor = Cursor::new(data);
    let mut workbook: Xlsx<_> = calamine::open_workbook_from_rs(cursor)
        .map_err(|e| anyhow!("Failed to open workbook from memory: {}", e))?;
    let sheet_names = workbook.sheet_names().to_vec();
    let mut excel_workbook = ExcelWorkbook::default();
    for sheet_name in sheet_names {
        debug!("Processing sheet: '{}'", sheet_name);
        let range = workbook
            .worksheet_range(&sheet_name)
            .map_err(|e| anyhow!("Failed to read sheet '{}': {}", sheet_name, e))?;
        let sheet_data = parse_sheet_dynamic_optimized(&sheet_name, &range)?;
        excel_workbook.sheets.push(sheet_data);
    }
    Ok(excel_workbook)
 }
 fn parse_sheet_dynamic_optimized(
    sheet_name: &str,
    range: &calamine::Range<Data>,
 ) -> Result<SheetData> {
    let (row_count, col_count) = range.get_size();
    let mut data_matrix: Vec<Vec<String>> = Vec::with_capacity(row_count);
    for row in range.rows() {
        let mut row_data = Vec::with_capacity(col_count);
        for cell in row {
            row_data.push(cell_to_string_optimized(cell));
        }
        data_matrix.push(row_data);
    }
    if data_matrix.is_empty() {
        return Ok(SheetData {
            name: sheet_name.to_string(),
            headers: Vec::new(),
            rows: Vec::new(),
        });
    }
    // Извлекаем заголовки с дедупликацией
    let headers: Vec<String> = data_matrix[0]
        .iter()
        .enumerate()
        .map(|(idx, header)| {
            let h = header.trim().to_string();
            if h.is_empty() {
                format!("Column_{}", idx + 1)
            } else {
                h
            }
        })
        .collect();
    let rows_data: Vec<HashMap<String, String>> = data_matrix
        .iter()
        .skip(1)
        .filter_map(|row_values| {
            let mut row_map = HashMap::with_capacity(headers.len());
            let mut has_data = false;
            for (col_idx, value) in row_values.iter().enumerate() {
                if col_idx < headers.len() && !value.is_empty() {
                    row_map.insert(headers[col_idx].clone(), value.clone());
                    has_data = true;
                }
            }
            if has_data {
                Some(row_map)
            } else {
                None
            }
        })
        .take(10000) // Ограничение для безопасности
        .collect();
    Ok(SheetData {
        name: sheet_name.to_string(),
        headers,
        rows: rows_data,
    })
 }
 #[inline]
 fn cell_to_string_optimized(cell: &Data) -> String {
    match cell {
        Data::Empty => String::new(),
        Data::String(s) => s.clone(),
        Data::Float(f) => {
            if is_excel_date(*f) {
                excel_date_to_string(*f)
            } else if f.fract() == 0.0 {
                format!("{:.0}", f)
            } else {
                f.to_string()
            }
        }
        Data::Int(i) => {
            let f = *i as f64;
            if is_excel_date(f) {
                excel_date_to_string(f)
            } else {
                i.to_string()
            }
        }
        Data::Bool(b) => {
            if *b {
                "TRUE".to_string()
            } else {
                "FALSE".to_string()
            }
        }
        Data::DateTime(dt) => {
            let serial = dt.as_f64();
            if is_excel_date(serial) {
                excel_date_to_string(serial)
            } else {
                dt.to_string()
            }
        }
        Data::DateTimeIso(s) => s.clone(),
        Data::DurationIso(s) => s.clone(),
        Data::Error(e) => format!("{:?}", e),
    }
 }
 #[inline]
 fn is_excel_date(value: f64) -> bool {
    (1.0..100000.0).contains(&value)
 }
 fn excel_date_to_string(serial: f64) -> String {
    let days = serial as i64;
    let base = NaiveDate::from_ymd_opt(1899, 12, 30).unwrap();
    if let Some(date) = base.checked_add_signed(Duration::days(days)) {
        date.format("%d.%m.%Y").to_string()
    } else {
        serial.to_string()
    }
 }
 fn display_workbook_structure(workbook: &ExcelWorkbook) {
    info!("Workbook contains {} sheets", workbook.sheets.len());
    for (idx, sheet) in workbook.sheets.iter().enumerate() {
        debug!(
            "Sheet #{}: '{}' | Headers: {} | Rows: {}",
            idx + 1,
            sheet.name,
            sheet.headers.len(),
            sheet.rows.len()
        );
    }
 }
 async fn generate_and_submit_jobs(
    workbook: &ExcelWorkbook,
    config: &Config,
 ) -> Result<Vec<(String, String)>> {
    info!("Preparing Nexrender jobs...");
    let start_sheet = workbook
        .get_sheet("Start")
        .ok_or_else(|| anyhow!("Sheet 'Start' not found"))?;
    let sport_sheet = workbook
        .get_sheet("SPORT")
        .ok_or_else(|| anyhow!("Sheet 'SPORT' not found"))?;
    let teams_sheet = workbook
        .get_sheet("TEAMS")
        .ok_or_else(|| anyhow!("Sheet 'TEAMS' not found"))?;
    let channel_sheet = workbook
        .get_sheet("CHANELL")
        .ok_or_else(|| anyhow!("Sheet 'CHANELL' not found"))?;
    // Загружаем sport packs
    let packs: HashMap<String, String> = sport_sheet
        .rows
        .iter()
        .filter_map(|row| Some((row.get("SPORT")?.clone(), row.get("LINK")?.clone())))
        .collect();
    info!("Loaded {} sport packs", packs.len());
    // Вспомогательная функция для поиска значения по части ключа
    fn get_cell_fuzzy(row: &HashMap<String, String>, key_part: &str) -> Option<String> {
        // Точное совпадение
        if let Some(val) = row.get(key_part) {
            if !val.is_empty() {
                return Some(val.clone());
            }
        }
        // Поиск по содержанию (без учёта регистра)
        for (k, v) in row.iter() {
            if k.to_lowercase().contains(&key_part.to_lowercase()) && !v.is_empty() {
                return Some(v.clone());
            }
        }
        None
    }
    // Загружаем team logos
    debug!("TEAMS headers: {:?}", teams_sheet.headers);
    for (i, row) in teams_sheet.rows.iter().take(3).enumerate() {
        debug!("TEAMS row {}: {:?}", i, row);
    }
    let mut logos = LogoRegistry::with_capacity(teams_sheet.rows.len());
    for row in &teams_sheet.rows {
        let team = get_cell_fuzzy(row, "TEAM");
        let sport = get_cell_fuzzy(row, "SPORT");
        let link = get_cell_fuzzy(row, "LINK");
        if let (Some(team), Some(sport), Some(link)) = (team, sport, link) {
            logos.insert(team.clone(), sport.clone(), link.clone());
        }
    }
    info!("Loaded {} team logos", teams_sheet.rows.len());
    // Дебаг: выводим статистику по TEAMS
    if log_enabled!(Level::Debug) {
        let sports: HashSet<_> = teams_sheet
            .rows
            .iter()
            .filter_map(|r| r.get("SPORT"))
            .collect();
        debug!("Sports found in TEAMS sheet: {:?}", sports);
        for sport in sports.iter() {
            let examples: Vec<_> = teams_sheet
                .rows
                .iter()
                .filter(|r| r.get("SPORT") == Some(*sport))
                .take(5)
                .filter_map(|r| r.get("TEAM"))
                .collect();
            debug!("  TEAMS examples for '{}': {:?}", sport, examples);
        }
    }
    // Загружаем channel logos
    let channels: HashMap<String, String> = channel_sheet
        .rows
        .iter()
        .filter_map(|row| Some((row.get("CHANELL")?.clone(), row.get("LINK")?.clone())))
        .collect();
    info!("Loaded {} channel logos", channels.len());
    if log_enabled!(Level::Debug) {
        debug!("Channels loaded: {:?}", channels.keys().collect::<Vec<_>>());
    }
    let mut jobs: Vec<JobData> = Vec::with_capacity(start_sheet.rows.len() * 3);
    // Собираем статистику по ненайденным логотипам для дебага
    let mut missing_teams: HashSet<String> = HashSet::new();
    let mut missing_sports: HashSet<String> = HashSet::new();
    for (idx, row) in start_sheet.rows.iter().enumerate() {
        if let Some(state) = row.get("STATE") {
            if state == "FALSE" {
                let team_a = row.get("TEAM A").cloned().unwrap_or_default();
                let team_b = row.get("TEAM B").cloned().unwrap_or_default();
                let sport = row.get("SPORT").cloned().unwrap_or_default();
                if log_enabled!(Level::Debug) {
                    let logo_a = logos.find(&team_a, &sport);
                    let logo_b = logos.find(&team_b, &sport);
                    if !team_a.is_empty() && logo_a.is_none() {
                        missing_teams.insert(team_a.clone());
                        missing_sports.insert(sport.clone());
                    }
                    if !team_b.is_empty() && logo_b.is_none() {
                        missing_teams.insert(team_b.clone());
                        missing_sports.insert(sport.clone());
                    }
                }
                if let Some(job) = JobData::from_row(row, idx, &packs, &logos, &channels) {
                    jobs.extend(job.create_variants());
                }
            }
        }
    }
    // Дебаг: выводим сводку по отсутствующим логотипам
    if log_enabled!(Level::Debug) && !missing_teams.is_empty() {
        debug!("=== MISSING LOGOS SUMMARY ===");
        debug!("Total unique teams missing logos: {}", missing_teams.len());
        debug!("Sports involved: {:?}", missing_sports);
        debug!(
            "Missing teams (first 20): {:?}",
            missing_teams.iter().take(20).collect::<Vec<_>>()
        );
        debug!("==============================");
    }
    info!("Generated {} total jobs (including variants)", jobs.len());
    if jobs.is_empty() {
        info!("No jobs with STATE='FALSE' found");
        return Ok(Vec::new());
    }
    cleanup_finished_jobs(&config.nexrender_api_url).await?;
    let http_client = Client::new();
    let mut submitted_jobs: Vec<(String, String)> = Vec::with_capacity(jobs.len());
    let mut tasks = Vec::with_capacity(jobs.len());
    for job in jobs {
        let client = http_client.clone();
        let api_url = config.nexrender_api_url.clone();
        let config_clone = config.clone();
        tasks.push(tokio::spawn(async move {
            let nexrender_job = job.to_nexrender_job(&config_clone);
            info!("Submitting job: {}", job.outfile_name);
            if log_enabled!(Level::Debug) {
                debug!(
                    "Job details: sport='{}', league='{}', channel='{}', team_a='{}', team_b='{}'",
                    job.sport, job.league, job.channel, job.team_a, job.team_b
                );
            }
            let response = client.post(&api_url).json(&nexrender_job).send().await?;
            if response.status().is_success() {
                let result: Value = response.json().await?;
                if let Some(uid) = result.get("uid").and_then(|u| u.as_str()) {
                    Ok::<_, anyhow::Error>(Some((uid.to_string(), job.outfile_name)))
                } else {
                    Ok(None)
                }
            } else {
                let status = response.status();
                let text = response.text().await.unwrap_or_default();
                error!("Failed to submit job ({}): {}", status, text);
                Ok(None)
            }
        }));
    }
    for task in tasks {
        match task.await {
            Ok(Ok(Some((uid, outfile_name)))) => {
                info!("Job submitted: {}", outfile_name);
                submitted_jobs.push((uid, outfile_name));
            }
            Ok(Ok(None)) => {
                debug!("Job submission returned no UID");
            }
            Ok(Err(e)) => {
                error!("Job submission error: {}", e);
            }
            Err(e) => {
                error!("Task join error: {}", e);
            }
        }
    }
    info!(
        "Successfully submitted {} jobs to Nexrender",
        submitted_jobs.len()
    );
    Ok(submitted_jobs)
 }
 pub async fn cleanup_finished_jobs(api_url: &str) -> Result<()> {
    let client = Client::new();
    let response = client.get(api_url).send().await?;
    if response.status().is_success() {
        let jobs: Vec<Value> = response.json().await?;
        for job in jobs {
            if let (Some(uid), Some(state)) = (
                job.get("uid").and_then(|u| u.as_str()),
                job.get("state").and_then(|s| s.as_str()),
            ) {
                if state == "finished" || state == "error" {
                    let _ = client.delete(&format!("{}/{}", api_url, uid)).send().await;
                    info!("Cleaned up completed job: {}", uid);
                }
            }
        }
    }
    Ok(())
 }
 pub async fn fetch_all_jobs(api_url: &str) -> Result<Vec<Value>> {
    let client = Client::new();
    let response = client.get(api_url).send().await?;
    if response.status().is_success() {
        let jobs: Vec<Value> = response.json().await?;
        Ok(jobs)
    } else {
        Ok(Vec::new())
    }
 }
--- a/src/static/index.html
+++ b/src/static/index.html
@@ -0,0 +1,489 @@
 <!DOCTYPE html>
 <html lang="ru">
 <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AE Anons - Nexrender Job Manager</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="/static/style.css">
 </head>
 <body>
    <div class="container">
        <!-- Header -->
        <div class="header">
            <div class="header-left">
                <div class="logo-container">
                    <img src="/assets/logo.png" alt="AE Anons Logo" class="logo" id="logo"
                        onerror="this.style.display='none'; document.getElementById('logoPlaceholder').style.display='flex';">
                    <div class="logo-placeholder" id="logoPlaceholder" style="display: none;">
                        <i class="fas fa-bolt"></i>
                    </div>
                </div>
                <h1>AE Anons - Nexrender Job Manager</h1>
            </div>
            <div class="header-controls">
                <button class="theme-toggle" onclick="toggleTheme()">
                    <i class="fas fa-circle-half-stroke" id="themeIcon"></i>
                    <span id="themeText">Auto</span>
                </button>
            </div>
        </div>
        <!-- Action Bar -->
        <div class="action-bar">
            <button class="btn btn-primary" onclick="generateJobs()">
                <i class="fas fa-play"></i> Generate New Jobs
            </button>
            <button class="btn btn-warning" onclick="stopAllJobs()">
                <i class="fas fa-stop"></i> Stop All Jobs
            </button>
            <button class="btn btn-danger" onclick="cleanupJobs()">
                <i class="fas fa-trash-alt"></i> Cleanup Finished
            </button>
            <button class="btn btn-outline" onclick="refreshJobs()">
                <i class="fas fa-sync-alt"></i> Refresh
            </button>
            <div class="status-message" id="statusMessage">
                <i class="fas fa-circle" style="color: var(--accent-success); font-size: 8px;"></i>
                <span>Ready</span>
            </div>
        </div>
        <!-- Stats Grid -->
        <div class="stats-grid" id="statsGrid"></div>
        <!-- Filter Bar -->
        <div class="filter-bar">
            <div class="search-wrapper">
                <i class="fas fa-search"></i>
                <input type="text" class="search-input" id="filterInput" placeholder="Filter by filename or UID..."
                    onkeyup="filterTable()">
            </div>
            <div class="auto-refresh-badge">
                <i class="fas fa-clock"></i>
                <span>Auto-refresh: 60s</span>
                <span id="refreshCountdown">60</span>s
            </div>
        </div>
        <!-- Table -->
        <div class="table-container">
            <table id="jobsTable">
                <thead>
                    <tr>
                        <th data-column="filename" onclick="sortTable('filename')">
                            Output File <i class="fas fa-sort"></i>
                        </th>
                        <th data-column="state" onclick="sortTable('state')" class="sorted-asc">
                            State <i class="fas fa-sort-up"></i>
                        </th>
                        <th data-column="created" onclick="sortTable('created')">
                            Created <i class="fas fa-sort"></i>
                        </th>
                        <th data-column="updated" onclick="sortTable('updated')">
                            Updated <i class="fas fa-sort"></i>
                        </th>
                        <th data-column="uid" onclick="sortTable('uid')">
                            UID <i class="fas fa-sort"></i>
                        </th>
                    </tr>
                </thead>
                <tbody id="jobsTableBody">
                    <tr>
                        <td colspan="5">
                            <div class="empty-state">
                                <i class="fas fa-spinner fa-spin"></i>
                                <p>Loading jobs...</p>
                            </div>
                        </td>
                    </tr>
                </tbody>
            </table>
        </div>
    </div>
    <script>
        // State
        let allJobs = [];
        let filteredJobs = [];
        let isLoading = false;
        let autoRefreshTimer = null;
        let countdownTimer = null;
        let countdownValue = 60;
        let currentTheme = 'auto';
        // Sorting state
        let currentSort = { column: 'state', direction: 'asc' };
        const stateOrder = { 'finished': 1, 'started': 2, 'processing': 3, 'queued': 4, 'pending': 5, 'error': 6 };
        // Theme handling
        const darkModeMediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
        function getOSPreference() {
            return darkModeMediaQuery.matches ? 'dark' : 'light';
        }
        function applyTheme(theme) {
            const effectiveTheme = theme === 'auto' ? getOSPreference() : theme;
            document.documentElement.setAttribute('data-theme', effectiveTheme);
            updateThemeButton(theme);
        }
        function updateThemeButton(theme) {
            const icon = document.getElementById('themeIcon');
            const text = document.getElementById('themeText');
            if (theme === 'auto') {
                icon.className = 'fas fa-circle-half-stroke';
                text.textContent = 'Auto';
            } else if (theme === 'dark') {
                icon.className = 'fas fa-moon';
                text.textContent = 'Dark';
            } else {
                icon.className = 'fas fa-sun';
                text.textContent = 'Light';
            }
        }
        function toggleTheme() {
            if (currentTheme === 'auto') {
                currentTheme = 'light';
            } else if (currentTheme === 'light') {
                currentTheme = 'dark';
            } else {
                currentTheme = 'auto';
            }
            localStorage.setItem('theme', currentTheme);
            applyTheme(currentTheme);
        }
        function initTheme() {
            const savedTheme = localStorage.getItem('theme') || 'auto';
            currentTheme = savedTheme;
            applyTheme(currentTheme);
            darkModeMediaQuery.addEventListener('change', (e) => {
                if (currentTheme === 'auto') {
                    applyTheme('auto');
                }
            });
        }
        // Sorting
        function sortTable(column) {
            if (currentSort.column === column) {
                currentSort.direction = currentSort.direction === 'asc' ? 'desc' : 'asc';
            } else {
                currentSort.column = column;
                currentSort.direction = 'asc';
            }
            updateSortIcons();
            sortAndRender();
        }
        function updateSortIcons() {
            document.querySelectorAll('th').forEach(th => {
                const column = th.dataset.column;
                th.classList.remove('sorted-asc', 'sorted-desc');
                const icon = th.querySelector('i');
                if (column === currentSort.column) {
                    th.classList.add(currentSort.direction === 'asc' ? 'sorted-asc' : 'sorted-desc');
                    icon.className = currentSort.direction === 'asc' ? 'fas fa-sort-up' : 'fas fa-sort-down';
                } else {
                    icon.className = 'fas fa-sort';
                }
            });
        }
        function sortJobs(jobs) {
            const { column, direction } = currentSort;
            const multiplier = direction === 'asc' ? 1 : -1;
            return [...jobs].sort((a, b) => {
                let aVal, bVal;
                switch (column) {
                    case 'filename':
                        aVal = a.outfile_name || '';
                        bVal = b.outfile_name || '';
                        return multiplier * aVal.localeCompare(bVal);
                    case 'state':
                        aVal = stateOrder[a.state] || 999;
                        bVal = stateOrder[b.state] || 999;
                        return multiplier * (aVal - bVal);
                    case 'created':
                        aVal = a.created_at ? new Date(a.created_at).getTime() : 0;
                        bVal = b.created_at ? new Date(b.created_at).getTime() : 0;
                        return multiplier * (bVal - aVal);
                    case 'updated':
                        aVal = a.updated_at ? new Date(a.updated_at).getTime() : 0;
                        bVal = b.updated_at ? new Date(b.updated_at).getTime() : 0;
                        return multiplier * (bVal - aVal);
                    case 'uid':
                        aVal = a.uid || '';
                        bVal = b.uid || '';
                        return multiplier * aVal.localeCompare(bVal);
                    default:
                        return 0;
                }
            });
        }
        function sortAndRender() {
            const jobsToRender = filteredJobs.length > 0 || document.getElementById('filterInput').value ?
                filteredJobs : allJobs;
            const sorted = sortJobs(jobsToRender);
            renderJobs(sorted);
        }
        // Data fetching
        async function refreshJobs() {
            if (isLoading) return;
            isLoading = true;
            try {
                setStatus('loading', 'Loading jobs...');
                const response = await fetch('/api/jobs');
                allJobs = await response.json();
                filteredJobs = [];
                document.getElementById('filterInput').value = '';
                sortAndRender();
                updateStats();
                setStatus('success', `Loaded ${allJobs.length} jobs`);
            } catch (err) {
                console.error(err);
                setStatus('error', 'Failed to load jobs');
            } finally {
                isLoading = false;
            }
        }
        function renderJobs(jobs) {
            const tbody = document.getElementById('jobsTableBody');
            if (jobs.length === 0) {
                tbody.innerHTML = `
                    <tr>
                        <td colspan="5">
                            <div class="empty-state">
                                <i class="fas fa-inbox"></i>
                                <p>No jobs found</p>
                            </div>
                        </td>
                    </tr>
                `;
                return;
            }
            tbody.innerHTML = jobs.map(job => {
                const stateClass = getStateClass(job.state);
                const created = formatDateTime(job.created_at);
                const updated = formatDateTime(job.updated_at);
                return `
                    <tr>
                        <td>
                            <div class="job-filename" title="${escapeHtml(job.outfile_name)}">${escapeHtml(job.outfile_name)}</div>
                        </td>
                        <td><span class="badge ${stateClass}">${escapeHtml(job.state)}</span></td>
                        <td class="datetime">${created}</td>
                        <td class="datetime">${updated}</td>
                        <td class="uid" title="${escapeHtml(job.uid)}">${job.uid.substring(0, 10)}...</td>
                    </tr>
                `;
            }).join('');
        }
        function escapeHtml(text) {
            if (!text) return '';
            const div = document.createElement('div');
            div.textContent = text;
            return div.innerHTML;
        }
        function getStateClass(state) {
            const classes = {
                'finished': 'badge-finished',
                'started': 'badge-started',
                'processing': 'badge-processing',
                'queued': 'badge-queued',
                'error': 'badge-error',
                'pending': 'badge-pending'
            };
            return classes[state] || 'badge-pending';
        }
        function formatDateTime(dateStr) {
            if (!dateStr) return '-';
            try {
                const date = new Date(dateStr);
                const time = date.toLocaleTimeString('ru-RU', { hour: '2-digit', minute: '2-digit' });
                const dayMonth = date.toLocaleDateString('ru-RU', { day: '2-digit', month: '2-digit' });
                return `${time}, ${dayMonth}`;
            } catch {
                return dateStr;
            }
        }
        function updateStats() {
            const stats = {
                total: allJobs.length,
                finished: 0,
                started: 0,
                queued: 0,
                error: 0,
                other: 0
            };
            allJobs.forEach(job => {
                switch (job.state) {
                    case 'finished': stats.finished++; break;
                    case 'started':
                    case 'processing': stats.started++; break;
                    case 'queued': stats.queued++; break;
                    case 'error': stats.error++; break;
                    default: stats.other++; break;
                }
            });
            const grid = document.getElementById('statsGrid');
            grid.innerHTML = `
                <div class="stat-card">
                    <h3><i class="fas fa-tasks"></i> Total Jobs</h3>
                    <div class="value">${stats.total}</div>
                </div>
                <div class="stat-card">
                    <h3><i class="fas fa-check-circle"></i> Completed</h3>
                    <div class="value">${stats.finished}</div>
                </div>
                <div class="stat-card">
                    <h3><i class="fas fa-play-circle"></i> Active</h3>
                    <div class="value">${stats.started + stats.queued}</div>
                </div>
                <div class="stat-card">
                    <h3><i class="fas fa-exclamation-circle"></i> Errors</h3>
                    <div class="value">${stats.error}</div>
                </div>
            `;
        }
        function filterTable() {
            const filter = document.getElementById('filterInput').value.toLowerCase();
            filteredJobs = allJobs.filter(job =>
                job.outfile_name.toLowerCase().includes(filter) ||
                job.uid.toLowerCase().includes(filter)
            );
            sortAndRender();
        }
        // Actions
        async function generateJobs() {
            setStatus('loading', 'Generating jobs...');
            try {
                const response = await fetch('/api/generate', { method: 'POST' });
                if (response.ok) {
                    setStatus('success', 'Job generation started');
                    setTimeout(() => refreshJobs(), 5000);
                } else {
                    const text = await response.text();
                    setStatus('error', `Error: ${text}`);
                }
            } catch (err) {
                setStatus('error', `Error: ${err}`);
            }
        }
        async function stopAllJobs() {
            if (!confirm('Are you sure you want to stop all active jobs?')) return;
            setStatus('loading', 'Stopping all jobs...');
            try {
                const response = await fetch('/api/jobs/stop-all', { method: 'POST' });
                if (response.ok) {
                    setStatus('success', 'All jobs stopped');
                    refreshJobs();
                } else {
                    const text = await response.text();
                    setStatus('error', `Error: ${text}`);
                }
            } catch (err) {
                setStatus('error', `Error: ${err}`);
            }
        }
        async function cleanupJobs() {
            setStatus('loading', 'Cleaning up finished jobs...');
            try {
                const response = await fetch('/api/cleanup', { method: 'POST' });
                if (response.ok) {
                    setStatus('success', 'Cleanup completed');
                    await refreshJobs();
                } else {
                    const text = await response.text();
                    setStatus('error', `Error: ${text}`);
                }
            } catch (err) {
                setStatus('error', `Error: ${err}`);
            }
        }
        function setStatus(type, message) {
            const el = document.getElementById('statusMessage');
            const icons = {
                loading: '<span class="spinner"></span>',
                success: '<i class="fas fa-check-circle" style="color: var(--accent-success);"></i>',
                error: '<i class="fas fa-times-circle" style="color: var(--accent-danger);"></i>'
            };
            el.innerHTML = `${icons[type] || ''} <span>${message}</span>`;
        }
        // Auto-refresh
        function startAutoRefresh() {
            stopAutoRefresh();
            autoRefreshTimer = setInterval(() => {
                refreshJobs();
                resetCountdown();
            }, 60000);
            countdownTimer = setInterval(() => {
                countdownValue--;
                document.getElementById('refreshCountdown').textContent = countdownValue;
                if (countdownValue <= 0) {
                    countdownValue = 60;
                }
            }, 1000);
        }
        function stopAutoRefresh() {
            if (autoRefreshTimer) clearInterval(autoRefreshTimer);
            if (countdownTimer) clearInterval(countdownTimer);
        }
        function resetCountdown() {
            countdownValue = 60;
            document.getElementById('refreshCountdown').textContent = countdownValue;
        }
        // Initialize
        initTheme();
        refreshJobs();
        startAutoRefresh();
        updateSortIcons();
        window.addEventListener('beforeunload', () => {
            stopAutoRefresh();
        });
    </script>
 </body>
 </html>
--- a/src/static/style.css
+++ b/src/static/style.css
@@ -0,0 +1,555 @@
 /* ========================================
   AE Anons - Nexrender Job Manager Styles
   ======================================== */
 /* CSS Variables - Light Theme (default) */
 :root {
    --bg-primary: #ffffff;
    --bg-secondary: #fafafa;
    --bg-tertiary: #f3f0f7;
    --text-primary: #1a1a1a;
    --text-secondary: #6b4f7c;
    --border-color: #e0d4e8;
    --accent-primary: #7c3aed;
    --accent-secondary: #c2410c;
    --accent-success: #10b981;
    --accent-warning: #ea580c;
    --accent-danger: #ef4444;
    --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
    --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1);
    --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1);
    --header-bg: #7c3aed;
    --header-text: #ffffff;
 }
 /* Dark Theme */
 [data-theme="dark"] {
    --bg-primary: #1a1025;
    --bg-secondary: #251a30;
    --bg-tertiary: #352545;
    --text-primary: #f0e6ff;
    --text-secondary: #c4a6d9;
    --border-color: #4a3560;
    --accent-primary: #a78bfa;
    --accent-secondary: #f59e0b;
    --accent-success: #34d399;
    --accent-warning: #fbbf24;
    --accent-danger: #f87171;
    --header-bg: #a78bfa;
    --header-text: #1a1025;
 }
 /* Reset & Base */
 * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
    transition: background-color 0.3s ease, border-color 0.3s ease, color 0.3s ease;
 }
 body {
    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
    background: var(--bg-primary);
    color: var(--text-primary);
    line-height: 1.6;
    min-height: 100vh;
 }
 .container {
    max-width: 100%;
    margin: 0 auto;
    padding: 24px;
 }
 /* Header */
 .header {
    display: flex;
    align-items: center;
    justify-content: space-between;
    margin-bottom: 24px;
    flex-wrap: wrap;
    gap: 16px;
 }
 .header-left {
    display: flex;
    align-items: center;
    gap: 16px;
 }
 .logo-container {
    width: 48px;
    height: 48px;
    border-radius: 12px;
    background: var(--accent-primary);
    display: flex;
    align-items: center;
    justify-content: center;
    overflow: hidden;
    box-shadow: var(--shadow-md);
 }
 .logo {
    width: 100%;
    height: 100%;
    object-fit: cover;
 }
 .logo-placeholder {
    width: 100%;
    height: 100%;
    display: flex;
    align-items: center;
    justify-content: center;
    color: white;
    font-size: 24px;
    font-weight: bold;
 }
 .header h1 {
    font-size: 28px;
    font-weight: 600;
    color: var(--accent-primary);
    letter-spacing: -0.5px;
 }
 .header-controls {
    display: flex;
    align-items: center;
    gap: 12px;
 }
 .theme-toggle {
    background: var(--bg-secondary);
    border: 2px solid var(--accent-primary);
    border-radius: 24px;
    padding: 8px 16px;
    display: flex;
    align-items: center;
    gap: 8px;
    cursor: pointer;
    color: var(--text-primary);
    font-size: 14px;
    box-shadow: var(--shadow-sm);
 }
 .theme-toggle:hover {
    box-shadow: var(--shadow-md);
 }
 /* Action Bar */
 .action-bar {
    background: var(--bg-secondary);
    border-radius: 12px;
    padding: 20px;
    margin-bottom: 24px;
    box-shadow: var(--shadow-md);
    display: flex;
    align-items: center;
    gap: 12px;
    flex-wrap: wrap;
    border: 1px solid var(--border-color);
 }
 /* Buttons */
 .btn {
    padding: 10px 20px;
    border: none;
    border-radius: 8px;
    font-size: 14px;
    font-weight: 500;
    cursor: pointer;
    display: inline-flex;
    align-items: center;
    gap: 8px;
    transition: all 0.2s ease;
    background: var(--bg-tertiary);
    color: var(--text-primary);
    border: 1px solid var(--border-color);
    position: relative;
    overflow: hidden;
 }
 .btn::before {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: rgba(255, 255, 255, 0.1);
    opacity: 0;
    transition: opacity 0.2s;
 }
 .btn:hover::before {
    opacity: 1;
 }
 .btn:hover {
    transform: translateY(-2px);
    box-shadow: var(--shadow-md);
 }
 .btn i {
    font-size: 14px;
 }
 /* Generate - Purple */
 .btn-primary {
    background: linear-gradient(135deg, #7c3aed 0%, #8b5cf6 100%);
    color: white;
    border: none;
    box-shadow: 0 2px 8px rgba(124, 58, 237, 0.3);
 }
 [data-theme="dark"] .btn-primary {
    background: linear-gradient(135deg, #8b5cf6 0%, #a78bfa 100%);
    color: #1a1025;
    box-shadow: 0 2px 8px rgba(139, 92, 246, 0.4);
 }
 .btn-primary:hover {
    box-shadow: 0 4px 12px rgba(124, 58, 237, 0.4);
 }
 /* Stop - Orange */
 .btn-warning {
    background: linear-gradient(135deg, #ea580c 0%, #f97316 100%);
    color: white;
    border: none;
    box-shadow: 0 2px 8px rgba(234, 88, 12, 0.3);
 }
 [data-theme="dark"] .btn-warning {
    background: linear-gradient(135deg, #f97316 0%, #fb923c 100%);
    color: #1a1025;
    box-shadow: 0 2px 8px rgba(249, 115, 22, 0.4);
 }
 .btn-warning:hover {
    box-shadow: 0 4px 12px rgba(234, 88, 12, 0.4);
 }
 /* Cleanup - Plum */
 .btn-danger {
    background: linear-gradient(135deg, #9d174d 0%, #be185d 100%);
    color: white;
    border: none;
    box-shadow: 0 2px 8px rgba(157, 23, 77, 0.3);
 }
 [data-theme="dark"] .btn-danger {
    background: linear-gradient(135deg, #be185d 0%, #db2777 100%);
    color: #f0e6ff;
    box-shadow: 0 2px 8px rgba(190, 24, 93, 0.4);
 }
 .btn-danger:hover {
    box-shadow: 0 4px 12px rgba(157, 23, 77, 0.4);
 }
 /* Refresh - Outline */
 .btn-outline {
    background: transparent;
    border: 2px solid #7c3aed;
    color: #7c3aed;
    box-shadow: none;
 }
 [data-theme="dark"] .btn-outline {
    border-color: #a78bfa;
    color: #a78bfa;
 }
 .btn-outline:hover {
    background: #7c3aed;
    color: white;
    border-color: #7c3aed;
 }
 [data-theme="dark"] .btn-outline:hover {
    background: #a78bfa;
    color: #1a1025;
    border-color: #a78bfa;
 }
 /* Status Message */
 .status-message {
    margin-left: auto;
    padding: 8px 16px;
    background: var(--bg-tertiary);
    border-radius: 20px;
    font-size: 14px;
    color: var(--text-secondary);
    display: flex;
    align-items: center;
    gap: 8px;
 }
 /* Stats Cards */
 .stats-grid {
    display: grid;
    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
    gap: 16px;
    margin-bottom: 24px;
 }
 .stat-card {
    background: var(--bg-secondary);
    border-radius: 12px;
    padding: 20px;
    box-shadow: var(--shadow-sm);
    border: 1px solid var(--border-color);
 }
 .stat-card h3 {
    font-size: 14px;
    color: var(--text-secondary);
    margin-bottom: 8px;
    font-weight: 500;
 }
 .stat-card .value {
    font-size: 32px;
    font-weight: 700;
    color: var(--accent-primary);
 }
 /* Filter Bar */
 .filter-bar {
    margin-bottom: 20px;
    display: flex;
    gap: 12px;
    align-items: center;
 }
 .search-wrapper {
    flex: 1;
    position: relative;
 }
 .search-wrapper i {
    position: absolute;
    left: 16px;
    top: 50%;
    transform: translateY(-50%);
    color: var(--text-secondary);
 }
 .search-input {
    width: 100%;
    padding: 12px 16px 12px 44px;
    background: var(--bg-secondary);
    border: 2px solid var(--border-color);
    border-radius: 24px;
    color: var(--text-primary);
    font-size: 14px;
 }
 .search-input:focus {
    outline: none;
    border-color: var(--accent-primary);
    box-shadow: 0 0 0 3px rgba(124, 58, 237, 0.1);
 }
 .auto-refresh-badge {
    display: flex;
    align-items: center;
    gap: 8px;
    padding: 8px 16px;
    background: var(--bg-tertiary);
    border-radius: 20px;
    font-size: 13px;
    color: var(--text-secondary);
    border: 1px solid var(--border-color);
 }
 /* Table */
 .table-container {
    background: var(--bg-secondary);
    border-radius: 12px;
    box-shadow: var(--shadow-lg);
    overflow-x: auto;
    border: 1px solid var(--border-color);
 }
 table {
    width: 100%;
    border-collapse: collapse;
    table-layout: auto;
    min-width: 800px;
 }
 th {
    text-align: left;
    padding: 16px;
    background: var(--header-bg);
    color: var(--header-text);
    font-weight: 600;
    font-size: 13px;
    text-transform: uppercase;
    letter-spacing: 0.5px;
    white-space: nowrap;
    cursor: pointer;
    user-select: none;
    position: relative;
 }
 th:hover {
    opacity: 0.9;
 }
 th i {
    margin-left: 8px;
    font-size: 12px;
    opacity: 0.7;
 }
 th.sorted-asc i,
 th.sorted-desc i {
    opacity: 1;
 }
 td {
    padding: 12px 16px;
    border-bottom: 1px solid var(--border-color);
    color: var(--text-primary);
    vertical-align: middle;
 }
 tr:last-child td {
    border-bottom: none;
 }
 tr:hover {
    background: var(--bg-tertiary);
 }
 /* Job Filename */
 .job-filename {
    font-family: 'Monaco', 'Menlo', 'Cascadia Code', 'Consolas', monospace;
    font-size: 13px;
    font-weight: 500;
    line-height: 1.5;
    word-break: break-word;
    white-space: normal;
    max-width: 100%;
    color: var(--text-primary);
 }
 /* Badges */
 .badge {
    padding: 4px 12px;
    border-radius: 20px;
    font-size: 12px;
    font-weight: 600;
    display: inline-block;
    white-space: nowrap;
 }
 .badge-finished {
    background: rgba(16, 185, 129, 0.15);
    color: var(--accent-success);
    border: 1px solid rgba(16, 185, 129, 0.3);
 }
 .badge-started,
 .badge-processing {
    background: rgba(124, 58, 237, 0.15);
    color: var(--accent-primary);
    border: 1px solid rgba(124, 58, 237, 0.3);
 }
 .badge-queued {
    background: rgba(234, 88, 12, 0.15);
    color: var(--accent-warning);
    border: 1px solid rgba(234, 88, 12, 0.3);
 }
 .badge-error {
    background: rgba(239, 68, 68, 0.15);
    color: var(--accent-danger);
    border: 1px solid rgba(239, 68, 68, 0.3);
 }
 .badge-pending {
    background: rgba(245, 158, 11, 0.15);
    color: var(--accent-secondary);
    border: 1px solid rgba(245, 158, 11, 0.3);
 }
 /* Date & Time */
 .datetime {
    font-family: 'Monaco', 'Menlo', monospace;
    font-size: 12px;
    color: var(--text-secondary);
    white-space: nowrap;
 }
 .uid {
    font-family: 'Monaco', 'Menlo', monospace;
    font-size: 11px;
    color: var(--text-secondary);
    white-space: nowrap;
 }
 /* Empty State */
 .empty-state {
    text-align: center;
    padding: 60px 20px;
    color: var(--text-secondary);
 }
 .empty-state i {
    font-size: 48px;
    margin-bottom: 16px;
    opacity: 0.5;
    color: var(--accent-primary);
 }
 /* Loading Spinner */
 .spinner {
    width: 20px;
    height: 20px;
    border: 3px solid var(--border-color);
    border-top-color: var(--accent-primary);
    border-radius: 50%;
    animation: spin 1s linear infinite;
    display: inline-block;
 }
@keyframes spin {
    to {
        transform: rotate(360deg);
    }
 }
 /* Responsive */
@media (max-width: 768px) {
    .container {
        padding: 16px;
    }
    .header {
        flex-direction: column;
        align-items: flex-start;
    }
    .header-left {
        flex-wrap: wrap;
    }
    .header h1 {
        font-size: 20px;
    }
    .action-bar {
        flex-direction: column;
        align-items: stretch;
    }
    .status-message {
        margin-left: 0;
    }
 }
--- a/src/synology.rs
+++ b/src/synology.rs
@@ -1,3 +1,4 @@
 #![allow(dead_code)]
 use log;
 use reqwest::{
    multipart::{Form, Part},
--- a/src/web.rs
+++ b/src/web.rs
@@ -0,0 +1,219 @@
 use crate::config::Config;
 use crate::processor::{cleanup_finished_jobs, fetch_all_jobs, process_spreadsheet};
 use axum::{
    extract::State,
    http::StatusCode,
    response::{Html, IntoResponse, Json},
    routing::{get, post},
    Router,
 };
 use serde::Serialize;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tower_http::services::ServeDir;
 use tower_http::trace::TraceLayer;
 #[derive(Clone)]
 pub struct AppState {
    pub config: Config,
    pub last_generation: Arc<Mutex<Option<chrono::DateTime<chrono::Local>>>>,
 }
 #[derive(Serialize)]
 pub struct JobInfo {
    pub uid: String,
    pub outfile_name: String,
    pub state: String,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
 }
 impl JobInfo {
    fn from_nexrender_json(job: &serde_json::Value) -> Option<Self> {
        let uid = job.get("uid")?.as_str()?.to_string();
        let state = job.get("state")?.as_str()?.to_string();
        // Извлекаем имя выходного файла из postrender actions
        let outfile_name = job
            .get("actions")
            .and_then(|a| a.get("postrender"))
            .and_then(|p| p.as_array())
            .and_then(|arr| {
                // Ищем действие copy (в нём финальный путь)
                arr.iter()
                    .find_map(|action| {
                        // Проверяем, что это действие copy
                        action
                            .get("module")
                            .and_then(|m| m.as_str())
                            .filter(|&m| m == "@nexrender/action-copy")
                            .and_then(|_| {
                                // Извлекаем output из copy
                                action.get("output").and_then(|o| o.as_str())
                            })
                    })
                    // Если copy не найдено, пробуем encode
                    .or_else(|| {
                        arr.iter()
                            .find_map(|action| action.get("output").and_then(|o| o.as_str()))
                    })
            })
            .map(|path| {
                // Извлекаем только имя файла из полного пути
                std::path::Path::new(path)
                    .file_name()
                    .and_then(|n| n.to_str())
                    .unwrap_or(path)
                    .to_string()
            })
            .unwrap_or_else(|| {
                // Если не удалось извлечь, используем UID
                format!("job_{}", uid)
            });
        Some(JobInfo {
            uid,
            outfile_name,
            state,
            created_at: job
                .get("createdAt")
                .and_then(|v| v.as_str())
                .map(|s| s.to_string()),
            updated_at: job
                .get("updatedAt")
                .and_then(|v| v.as_str())
                .map(|s| s.to_string()),
        })
    }
 }
 // web.rs - функция run_web_server
 pub async fn run_web_server(config: Config) -> anyhow::Result<()> {
    let web_port = config.web_port; // Берём порт из конфига
    let state = AppState {
        config,
        last_generation: Arc::new(Mutex::new(None)),
    };
    let app = Router::new()
        .route("/", get(index_page))
        .route("/api/jobs", get(list_jobs))
        .route("/api/generate", post(generate_jobs))
        .route("/api/cleanup", post(cleanup_jobs))
        .route("/api/status", get(get_status))
        .route("/api/jobs/stop-all", post(stop_all_jobs))
        .nest_service("/static", ServeDir::new("src/static"))
        .nest_service("/assets", ServeDir::new("assets"))
        .layer(TraceLayer::new_for_http())
        .with_state(state);
    let addr: SocketAddr = format!("0.0.0.0:{}", web_port).parse()?;
    log::info!("Web server listening on http://{}", addr);
    let listener = tokio::net::TcpListener::bind(addr).await?;
    axum::serve(listener, app).await?;
    Ok(())
 }
 async fn index_page() -> Html<&'static str> {
    Html(include_str!("static/index.html"))
 }
 async fn list_jobs(State(state): State<AppState>) -> Result<Json<Vec<JobInfo>>, AppError> {
    let jobs_json = fetch_all_jobs(&state.config.nexrender_api_url)
        .await
        .map_err(|e| AppError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    let jobs: Vec<JobInfo> = jobs_json
        .iter()
        .filter_map(JobInfo::from_nexrender_json)
        .collect();
    Ok(Json(jobs))
 }
 async fn generate_jobs(State(state): State<AppState>) -> Result<impl IntoResponse, AppError> {
    let mut last_gen = state.last_generation.lock().await;
    if let Some(last) = *last_gen {
        let elapsed = chrono::Local::now().signed_duration_since(last);
        if elapsed.num_seconds() < 5 {
            return Err(AppError(
                StatusCode::TOO_MANY_REQUESTS,
                "Generation already in progress or too recent".to_string(),
            ));
        }
    }
    *last_gen = Some(chrono::Local::now());
    drop(last_gen);
    let config = state.config.clone();
    let last_gen_clone = state.last_generation.clone();
    tokio::spawn(async move {
        match process_spreadsheet(&config).await {
            Ok(submitted) => {
                log::info!("Generation completed, {} jobs submitted", submitted.len());
            }
            Err(e) => {
                log::error!("Generation failed: {}", e);
            }
        }
        *last_gen_clone.lock().await = None;
    });
    Ok((StatusCode::ACCEPTED, "Job generation started"))
 }
 async fn cleanup_jobs(State(state): State<AppState>) -> Result<impl IntoResponse, AppError> {
    cleanup_finished_jobs(&state.config.nexrender_api_url)
        .await
        .map_err(|e| AppError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    Ok((StatusCode::OK, "Cleanup completed"))
 }
 async fn get_status(State(state): State<AppState>) -> Result<Json<serde_json::Value>, AppError> {
    let last_gen = *state.last_generation.lock().await;
    let status = serde_json::json!({
        "last_generation": last_gen.map(|dt| dt.to_rfc3339()),
        "nexrender_api": state.config.nexrender_api_url,
    });
    Ok(Json(status))
 }
 async fn stop_all_jobs(State(state): State<AppState>) -> Result<impl IntoResponse, AppError> {
    use reqwest::Client;
    let client = Client::new();
    let api_url = &state.config.nexrender_api_url;
    // Получаем все задания
    let jobs = fetch_all_jobs(api_url)
        .await
        .map_err(|e| AppError(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    let mut stopped = 0;
    for job in jobs {
        let state = job.get("state").and_then(|s| s.as_str()).unwrap_or("");
        if state == "queued" || state == "started" || state == "processing" {
            if let Some(uid) = job.get("uid").and_then(|u| u.as_str()) {
                // Отправляем DELETE запрос для остановки задания
                let _ = client.delete(&format!("{}/{}", api_url, uid)).send().await;
                stopped += 1;
                log::info!("Stopped job: {}", uid);
            }
        }
    }
    log::info!("Stopped {} active jobs", stopped);
    Ok((StatusCode::OK, format!("Stopped {} jobs", stopped)))
 }
 // Error handling
 struct AppError(StatusCode, String);
 impl IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        (self.0, self.1).into_response()
    }
 }
Author	SHA1	Message	Date
Алексей Барабанов	0f2fe50eab	chore: bump version to 0.2.3	2026-04-17 16:29:03 +03:00
Алексей Барабанов	fbcb619544	улучшено debug-логирование и обработка путей - Добавлен детальный вывод при парсинге листа TEAMS - Добавлен вывод поиска логотипов и сводка по отсутствующим - Исправлен порядок инициализации RUST_LOG - Добавлена поддержка smb:// путей в unc_to_uri	2026-04-17 16:00:46 +03:00
Алексей Барабанов	0b2091b1e6	Release v0.2.2 - Web Interface	2026-04-17 14:39:27 +03:00
Алексей Барабанов	48f32e63c2	feat: release v0.2.2 - web interface with configurable port	2026-04-17 14:38:38 +03:00
Алексей Барабанов	fe13a5e3a7	add WEB_PORT	2026-04-17 14:20:43 +03:00
Алексей Барабанов	bb371e1b71	v0.2.2	2026-04-17 12:54:43 +03:00
Алексей Барабанов	8721353b8d	v0.2.0	2026-04-17 11:58:16 +03:00
Алексей Барабанов	4f1c6d1ab7	v 0.1.1	2026-04-17 10:34:25 +03:00
Алексей Барабанов	23ca2dc7d1	V 0.1.1	2026-04-17 06:22:55 +00:00
Алексей Барабанов	df26e4b1db	V 0.1.1 Убрана секция про `.json`	2026-04-17 06:01:18 +00:00
Алексей Барабанов	91de200b91	v0.1.1	2026-04-16 19:34:45 +03:00
Алексей Барабанов	1e1d9a9935	Убранны коментарии	2026-04-16 17:57:15 +03:00
Алексей Барабанов	3cdd8395b3	markdownlint-disable MD033	2026-04-16 17:55:21 +03:00
Алексей Барабанов	b3d33f4d35	Поправлена "Структура кода"	2026-04-16 17:49:59 +03:00
Алексей Барабанов	a9b8fc799a	Move logo	2026-04-16 14:46:01 +00:00
Алексей Барабанов	48de7d11ac	add logo	2026-04-16 17:44:10 +03:00
Алексей Барабанов	b4f358b12f	Оптимизация для косплатформенной компиляции	2026-04-16 17:17:28 +03:00
Алексей Барабанов	8ec326cd21	add .env.example	2026-04-16 16:17:29 +03:00
Алексей Барабанов	0d4b81a34a	Правки в оформлении	2026-04-16 15:39:08 +03:00
Алексей Барабанов	4f00554147	Причёсинг	2026-04-16 15:30:19 +03:00