Files

T

manoraga ffb0e18635 поправлено взаимодействие функционала работы с db_cli.py через диалоговую строку.

2026-08-11 16:20:15 +03:00

194 KiB

Raw Blame History

File: ./.gitignore

# --- 1. Python и виртуальное окружение ---
__pycache__/
*.py[cod]
*$py.class
venv/
.venv/
env/
.env

# --- 2. Настройки IDE и редакторов ---
.vscode/
.idea/
*.swp
*.swo

# --- 3. Логи скриптов и выгрузок ---
logs/
*.log

# --- 4. Временные и выходные файлы отчетов ---
output/
*.tmp
~$*.xlsx

# --- 5. Рабочие данные СКУД и 1С (Выгрузки) ---
data/scud/*
data/1c/*
!data/scud/.gitkeep
!data/1c/.gitkeep

# Исключаем сырые Excel-файлы в корне и папке data
*.xlsx
*.xls
*.csv

# Разрешаем отслеживать только статический справочник причин, если он нужен
!data/static_reason_workers.csv
!data/knowledge_base.json

# --- 6. Системные файлы ОС ---
.DS_Store
Thumbs.db

File: ./PROJECT_SNAPSHOT_03.08.2026.md

# 🔄 ПАСПОРТ АЛГОРИТМА И ETL-КОНВЕЙЕРА: `scud_orion_ai_v2`

> **Архитектурный паттерн:** Гибридный ETL (Extract, Transform, Load) с хранением аналитического следа  
> **Хранилище данных:** SQLite (режим WAL)  
> **Интеграционный стек:** `MS SQL Server` ⟷ `1С:ЗУП (SMB/Share)` ⟷ `Ollama (Qwen 2.5)` ⟷ `SQLite`

---

## 📐 Сквозной цикл работы проекта (`main.py`)

```plaintext
 [БД MS SQL 'Орион Pro']      [Сетевая шара \storage\...]
           │                                │
     (0. run_export)             (0.5 share_copier)
           ▼                                ▼
   [data/scud/*.xlsx]              [data/1c/*.xlsx]
           │                                │
           └────────────────┬───────────────┘
                            ▼
                (1. data_validator)  ──(Проверка фатальных ошибок)
                            │
                            ▼
                 (2. data_loader)    ──(Фоллбэки по датам)
                            │
                            ▼
              (3. ai_verifier + Qwen 2.5) ──(Исправление опечаток)
                            │
                            ▼
                   (4. Сведение данных)
                 ┌──────────┴──────────┐
                 ▼                     ▼
          [Данные за ВЧЕРА]    [Данные за СЕГОДНЯ]
                 │                     │
                 ▼                     ▼
        (Detailed Excel)       (Summary Excel + Markdown)
                 │                     │
                 └──────────┬──────────┘
                            ▼
                 (5. feedback_loop)   ──(Обучение ИИ)
                            │
                            ▼
            (database.py / SQLite WAL) ──(Сохранение фактов)

📋 Пошаговый алгоритм по этапам

Этап 0: Извлечение сырых данных (Extract)

1. БД СКУД «Орион Pro» $

ightarrow$ Excel (scud_export.py)

Скрипт подключается напрямую к MS SQL Server системы «Орион Pro».
Формирует агрегированные файлы Сотрудники_DD.MM.YYYY.xlsx в папку data/scud/ отдельно за Сегодня и за Вчера.

2. Сетевая шара $

ightarrow$ Папка data/1c/ (share_copier.py)

Заходит по UNC-пути \storage\SCUD\Обмен\Штат.
Ищет и забирает свежие выгрузки 1С:ЗУП: Штат_DD_MM_YYYY.xlsx и Отсутствия_DD_MM_YYYY.xlsx за Сегодня и Вчера.

Этап 1: Валидация и защита от сбоев (`data_validator.py`)

Проверяет наличие файлов за Вчера (они критически важны для формирования ежедневного табеля).
Если файлы за Сегодня ещё не выложены кадровой службой на сетевую шару:
- Выдаёт мягкое предупреждение.
- Отменяет генерацию сегодняшней сводки (чтобы не плодить ложные аномалии по понедельникам/утрам).
- Не останавливает работу системы, мягко переходя к формированию вчерашнего отчёта.

Этап 2: Нормализация и загрузка (`data_loader.py`)

Очищает и применительно нормализует ФИО через normalize_fio: удаление лишних пробелов, точек, приведение к единому регистру.
Выделяет факты физического присутствия по СКУД (наличие первого входа / последнего выхода).
Исключает из анализа подрядчиков, охрану и служебные карты (по реестру исключений).

Этап 3: ИИ-аудит опечаток и сопоставление ФИО (`ai_verifier.py`)

Неопознанные проходы СКУД отправляются в локальную нейросеть Qwen 2.5 (через Ollama).
ИИ сверяет опечатки в СКУД с 100% эталонным реестром Штатного расписания 1С.
Сопоставленные опечатки автоматически исправляются в датасете перед сведением.

Этап 4: Бизнес-логика, сведение и детекция аномалий

Система разделяет контекст на два независимых потока:

1. Поток ВЧЕРА (Детальный отчёт)

Объединяет СКУД (Вчера) + 1С:Отсутствия (Вчера).
Считает реальные часы нахождения в здании, обед (30 мин) и отклонение от 8-часовой нормы.
Формирует Excel output/[Дата] отчет.xlsx.

2. Поток СЕГОДНЯ (Ежедневная сводка)

Объединяет СКУД (Сегодня) + 1С:Отсутствия (Сегодня) + Реестр удалёнщиков.
🔴 Детекция аномалий: Физический приход по СКУД при наличии любого документа отсутствия в 1С (отпуск, больничный и т.д., кроме командировок) помечается как Истинная Аномалия.
🟢 Удалёнщики: Удалёнщики, пришедшие в офис, не считаются аномалией (правило компании).
Формирует Excel output/[Дата] сводка.xlsx (со свернутыми группами без номеров строк) и текстовую Markdown-сводку.

Этап 5: Обучение Human-in-the-Loop (`feedback_loop.py`)

Если ИИ находит спорные случаи, он запрашивает подтверждение оператора в консоли.
Новые правила, введённые пользователем, мгновенно сохраняются и в knowledge_base.json, и в таблицу ai_knowledge_base в БД SQLite.

Этап 6: Сохранение аналитического следа в БД (`database.py`)

Вся история сохраняется в локальную SQLite БД (data/scud_orion_ai.db) в режиме высокой производительности (WAL / executemany):

Таблица	Содержимое
`scud_logs`	История всех проходов по дням
`zup_staff`	Срезы штатного расписания
`zup_absences`	Оформленные документы из 1С
`anomalies_history`	Найденные и подтверждённые нарушения
`ai_knowledge_base`	Обучающие правила для нейросети


# File: ./ROADMAP.md

🗺 Реестр задач проекта: SCUD Orion AI (v2)

🟢 Выполненные задачи (Completed Tasks)

[TASK-01] services/data_loader — Исправление KeyError по ФИО в Excel экспорте 1С (переход на .iloc) (03.08.2026) — ГОТОВО
[TASK-02] services/zup_extractor — Перевод подключения 1С:ЗУП на продакшн MS SQL сервер ACCOUNT-01 + гибридный фоллбэк (04.08.2026) — ГОТОВО
[TASK-03] services/scud_export — Инцидент Равина В.Э.: Фиксация 100% приоритета сырых логов pLogData СКУД над расчетом УРВ Ориона (04.08.2026) — ГОТОВО
[TASK-04] core/database — Реализация схемы SQLite WAL, сохранение снапшотов и маппинг колонок (department/position) (05.08.2026) — ГОТОВО
[TASK-05] core/database — Исправление бага дублирования номеров снапшотов (переход на вычисление MAX() по суффиксу) (05.08.2026) — ГОТОВО
[TASK-06] scripts/fix_snapshots — Создание и выполнение скрипта сквозной переиндексации снапшотов с префиксом Y (05.08.2026) — ГОТОВО
[TASK-07] scripts/db_cli — Реализация CLI-инспектора БД и выравнивание номеров срезов для идеальной верстки в терминале (05.08.2026) — ГОТОВО
[TASK-08] main.py / logic — Двойная проверка исключений по department_scud и 1С, удержание 100% приоритета кадровых документов (05.08.2026) — ГОТОВО
[TASK-09] services/text_reporter — Лаконичный вывод неразмеченных сотрудников с короткими аббревиатурами отделов СКУД (РУК, ОИЗ, ПУ и др.) (05.08.2026) — ГОТОВО

🟡 Ближайшие планы и бэклог (In Progress & Backlog v2.1)

[TASK-10] services/scud_export — Внутридневной контроль: Извлечение полных цепочек проходов pLogData (входы/выходы за смену) — В ПЛАНАХ [High]
[TASK-11] services/data_loader — Внутридневной контроль: Расчет количества и суммарной длительности отлучек/перекуров сверх обеда — В ПЛАНАХ [High]
[TASK-12] services/text_reporter — Внутридневной контроль: Вывод списка системных нарушителей внутреннего распорядка в Markdown-отчет — В ПЛАНАХ [Medium]
[TASK-13] automation — Автоматизация сбора срезов по расписанию (Cron / Systemd Timers на 12:00, 17:00, 19:00) — В ПЛАНАХ [High]
[TASK-14] services/notifications — Интеграция Telegram-бота для алертов Администратору при массовых сбоях турникетов (>5%) — В ПЛАНАХ [Medium]

🔵 Дорожная карта Веб-релиза (Roadmap v3.0)

[TASK-15] api / fastapi — Создание REST API на FastAPI (/api/v1/snapshots, /api/v1/scud/logs, /api/v1/anomalies) — В ПЛАНАХ [High]
[TASK-16] frontend / chat — Веб-интерфейс с ИИ-чатом на базе Ollama (Qwen 2.5 14B) с поддержкой Function Calling к REST API — В ПЛАНАХ [High]
[TASK-17] core/memory — Создание модуля персистентной памяти проекта в SQLite и CLI-инструмента для фиксации архитектурных решений — В ПЛАНАХ [High]


# File: ./config.py

import os import re from datetime import datetime, timedelta

BASE_DIR = os.path.dirname(os.path.abspath(file)) DATA_DIR = os.path.join(BASE_DIR, "data")

SCUD_DIR = os.path.join(DATA_DIR, "scud") ZUP_1C_DIR = os.path.join(DATA_DIR, "1c") OUTPUT_DIR = os.path.join(BASE_DIR, "output")

Путь к намонтированной сетевой шаре 1С в Linux (вместо \storage\SCUD\Обмен\Штат)

SHARE_1C_DIR = "/mnt/scud_share"

for folder in [DATA_DIR, SCUD_DIR, ZUP_1C_DIR, OUTPUT_DIR]: os.makedirs(folder, exist_ok=True)

NOW = datetime.now() DATE_TODAY = NOW.strftime("%d.%m.%Y")

if NOW.weekday() == 0: DATE_YESTERDAY = (NOW - timedelta(days=3)).strftime("%d.%m.%Y") else: DATE_YESTERDAY = (NOW - timedelta(days=1)).strftime("%d.%m.%Y")

--- Настройки LLM / Ollama ---

OLLAMA_URL = "http://192.168.11.3:11434/api/generate" OLLAMA_MODEL = "qwen2.5:14b" MODEL_NAME = OLLAMA_MODEL

KNOWLEDGE_BASE_PATH = os.path.join(DATA_DIR, "knowledge_base.json") EXCEPTIONS_PATH = os.path.join(BASE_DIR, "exceptions.json")

--- Настройки подключения к MS SQL Server (1С:ЗУП 3.1) ---

ZUP_SQL_CONFIG = { "driver": "{ODBC Driver 18 for SQL Server}", # или "{ODBC Driver 17 for SQL Server}" "server": os.getenv("ZUP_SQL_SERVER", "ACCOUNT-01"), "database": os.getenv("ZUP_SQL_DB", "ZUP30"), # Замените на точное имя базы ЗУП на ACCOUNT-01 "user": os.getenv("ZUP_SQL_USER", "scud_reader"), # Логин SQL Server "password": os.getenv("ZUP_SQL_PASS", "Rhfcysq90"), # Пароль SQL Server "trust_server_certificate": "yes", # Доверять сертификату сервера "encrypt": "no" # "yes", если на MS SQL включено обязательное SSL-шифрование }

def find_dated_file(prefix, date_str, search_dirs=[ZUP_1C_DIR, SCUD_DIR, DATA_DIR, "."]): """ Ищет файлы по префиксу и дате (поддерживает и 30.07.2026, и 30_07_2026). """ date_dots = date_str date_underscores = date_str.replace('.', '_')

for d in search_dirs:
    if not os.path.exists(d):
        continue
    for f in os.listdir(d):
        if f.endswith('.xlsx') or f.endswith('.csv'):
            if f.lower().startswith(prefix.lower()):
                if date_dots in f or date_underscores in f:
                    return os.path.join(d, f)
return None

def normalize_fio(fio): if not fio or not isinstance(fio, str): return "" fio_clean = re.sub(r'(.*?)', '', fio) fio_clean = fio_clean.replace('\xa0', ' ') parts = fio_clean.strip().split() return " ".join(parts).title()

def clean_scud_fio_light(fio_str): return normalize_fio(fio_str)

def load_exceptions(): import json if os.path.exists(EXCEPTIONS_PATH): try: with open(EXCEPTIONS_PATH, "r", encoding="utf-8") as f: return json.load(f) except Exception: pass return {"fio": [], "departments": [], "positions": [], "position_keywords": []}


# File: ./exceptions.json

{ "departments": [ "ОВК" ], "positions": [ "Уборщик производственных помещений", "Уборщик служебных помещений" ], "fio": [ "Таткало Валерий Валерьевич", "Петренюк Андрей Германович", "Чуркина Елена Геннадьевна", "Михалев Сергей Геннадьевич" ], "position_keywords": [ "уборщик", "клинер", "дворник", "гардероб", "рабочий по обслуживанию" ] }


# File: ./main.py

import os import sys import json import argparse import pandas as pd from datetime import datetime

sys.path.append(os.path.dirname(os.path.abspath(file)))

from config import DATE_TODAY, DATE_YESTERDAY, OUTPUT_DIR, DATA_DIR, normalize_fio from services.scud_export import run_export from services.share_copier import copy_1c_files_from_share from services.data_validator import check_file_freshness from services.data_loader import load_all_data, load_scud_data from services.excel_exporter import generate_summary_excel, generate_detailed_excel from services.ai_verifier import ai_verify_scud_against_staff, analyze_scud_mass_failure_ai from services.text_reporter import generate_markdown_report from services.feedback_loop import review_ai_decisions from services.knowledge_base import load_knowledge_base from core.database import ( init_db, save_scud_to_db, save_staff_to_db, save_absences_to_db, save_anomalies_to_db, load_scud_from_db_by_snapshot, get_latest_snapshot_time, has_scud_logs_for_date )

from services.ai_verifier import resolve_department_exception_ai

def apply_exceptions_from_json(df, exceptions_cfg): """ Размечает флаг is_excluded=True на основе правил из exceptions.json и БД SQLite. Сверяет одновременно 1С, СКУД и использует интеллектуальный поиск отделов. """ if df is None or df.empty or not exceptions_cfg: if df is not None: df['is_excluded'] = False return df

deps = exceptions_cfg.get("departments", [])
exact_pos = [p.lower() for p in exceptions_cfg.get("positions", [])]
pos_kw = [k.lower() for k in exceptions_cfg.get("position_keywords", [])]
exc_fios = [normalize_fio(f) for f in exceptions_cfg.get("fio", [])]

df['is_excluded'] = False

for idx, row in df.iterrows():
    fio_clean = row.get('fio_clean', '')
    dep_1c = row.get('Подразделение', '')
    dep_scud = row.get('department_scud', row.get('department', ''))
    pos = str(row.get('Должность', '')).lower()

    is_fio_exc = fio_clean in exc_fios
    is_pos_exc = (pos in exact_pos) or any(k in pos for k in pos_kw) if pos else False
    
    # Двухуровневая интеллектуальная проверка отделов (1С + СКУД + ИИ-Кеш БД)
    is_dep_exc = resolve_department_exception_ai(dep_1c, dep_scud, deps)

    if is_fio_exc or is_dep_exc or is_pos_exc:
        df.at[idx, 'is_excluded'] = True

return df

def load_exceptions_config(): """Загружает файл exceptions.json из корня проекта.""" root_dir = os.path.dirname(os.path.abspath(file)) json_path = os.path.join(root_dir, "exceptions.json") if not os.path.exists(json_path): return {} try: with open(json_path, 'r', encoding='utf-8') as f: return json.load(f) except Exception as e: print(f"[⚠️] Ошибка чтения exceptions.json: {e}") return {}

def apply_exceptions_from_json(df, exceptions_cfg): """ Размечает флаг is_excluded=True на основе правил из exceptions.json. Сверяет отдел одновременно по полному имени из 1С и по короткой аббревиатуре из СКУД. """ if df is None or df.empty or not exceptions_cfg: if df is not None: df['is_excluded'] = False return df

deps = [d.lower() for d in exceptions_cfg.get("departments", [])]
exact_pos = [p.lower() for p in exceptions_cfg.get("positions", [])]
pos_kw = [k.lower() for k in exceptions_cfg.get("position_keywords", [])]
exc_fios = [normalize_fio(f) for f in exceptions_cfg.get("fio", [])]

df['is_excluded'] = False

for idx, row in df.iterrows():
    fio_clean = row.get('fio_clean', '')
    dep_1c = str(row.get('Подразделение', '')).lower()
    dep_scud = str(row.get('department_scud', row.get('department', ''))).lower()
    pos = str(row.get('Должность', '')).lower()

    is_fio_exc = fio_clean in exc_fios
    is_dep_exc = any(d in dep_1c or d == dep_scud for d in deps) if (dep_1c or dep_scud) else False
    is_pos_exc = (pos in exact_pos) or any(k in pos for k in pos_kw) if pos else False

    if is_fio_exc or is_dep_exc or is_pos_exc:
        df.at[idx, 'is_excluded'] = True

return df

def filter_report_dataframe(merged_df): """ Исключает сотрудников из списка исключений и сотрудников без пропуска из детального отчета, ЕСЛИ у них нет официального документа отсутствия из 1С:ЗУП. """ if merged_df is None or merged_df.empty: return merged_df

has_1c_reason = (
    merged_df['Вид_отсутствия'].notna() & 
    (merged_df['Вид_отсутствия'].astype(str).str.strip() != '') & 
    (~merged_df['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
)
is_not_excluded = merged_df.get('is_excluded', False) == False
is_not_no_pass = merged_df.get('no_scud_pass', False) == False

# В отчет попадают ТОЛЬКО офисные сотрудники с пропусками ИЛИ имеющие документ из 1С
filtered_df = merged_df[(is_not_excluded & is_not_no_pass) | has_1c_reason].copy()
return filtered_df

def load_static_reason_workers(): """Загружает реестр удалёнщиков и статических причин из CSV.""" static_path = os.path.join(DATA_DIR, "static_reason_workers.csv") if not os.path.exists(static_path): return {} try: df_static = pd.read_csv(static_path, encoding='utf-8') if 'fio' in df_static.columns and 'reason' in df_static.columns: df_static['fio_clean'] = df_static['fio'].apply(normalize_fio) return dict(zip(df_static['fio_clean'], df_static['reason'])) except Exception as e: print(f"[⚠️] Ошибка чтения static_reason_workers.csv: {e}") return {}

def detect_all_anomalies(merged_df, static_reasons_dict, kb_rules, scud_fios_set=None): """ Автоматически выявляет истинные аномалии СКУД ⟷ 1С. Исключения (ОВК/Клининг/Охрана) НЕ попадают в аномалии СКУД, если на них нет документа из 1С. """ anomalies = [] kb_rules_text = " ".join(kb_rules).lower() if kb_rules else ""

ALLOWED_WORK_TRIP_KEYWORDS = ['командировк', 'разъездн', 'поездк']

for idx, row in merged_df.iterrows():
    fio = row.get('Сотрудник', row.get('fio_clean', ''))
    fio_clean = row.get('fio_clean', '')
    is_present = row.get('Пришел', False)
    is_exc = row.get('is_excluded', False)
    reason_1c = str(row.get('Вид_отсутствия', '')).strip()
    has_1c_reason = pd.notna(row.get('Вид_отсутствия')) and reason_1c != '' and not reason_1c.startswith('Исключение')
    anom_flag = row.get('anomaly_flag', 'NONE')

    is_fio_whitelisted_in_kb = fio_clean.lower() in kb_rules_text

    # 🚨 АНОМАЛИЯ 1: Физическое присутствие при документе отсутствия 1С
    if is_present and has_1c_reason:
        reason_lower = reason_1c.lower()
        is_allowed_trip = any(kw in reason_lower for kw in ALLOWED_WORK_TRIP_KEYWORDS)

        if not is_allowed_trip and not is_fio_whitelisted_in_kb:
            anomalies.append({
                "type": "ФИЗИЧЕСКОЕ ПРИСУТСТВИЕ ПРИ ОФИЦИАЛЬНОМ ОТСУТСТВИИ",
                "fio": fio,
                "details": f"Сотрудник пришел по СКУД, но в 1С оформлен документ: '{reason_1c}'"
            })

    # ИСКЛЮЧЕНИЯ без документов 1С НЕ пропускаются дальше к аномалиям СКУД
    if is_exc and not has_1c_reason:
        continue

    # 🚨 АНОМАЛИЯ 2: Перемещение внутри здания без отметки утреннего входа
    if anom_flag == 'ANOMALY_NO_IN_HAS_ACTIVITY':
        first_act = row.get('Первая_активность', '—')
        anomalies.append({
            "type": "АНОМАЛИЯ СКУД: ПЕРЕМЕЩЕНИЕ БЕЗ ВХОДА",
            "fio": fio,
            "details": f"Отсутствует регистрация входа на КПП при зафиксированной первой активности в {first_act}"
        })

    # 🚨 АНОМАЛИЯ 3: Сотрудник есть в Штате 1С, но ПОЛНОСТЬЮ ОТСУТСТВУЕТ в базе СКУД Орион Pro
    if scud_fios_set is not None:
        if fio_clean not in scud_fios_set and not has_1c_reason:
            anomalies.append({
                "type": "АНОМАЛИЯ УЧЕТА: СОТРУДНИК ОТСУТСТВУЕТ В СКУД ОРИОН PRO",
                "fio": fio,
                "details": f"Сотрудник числится в Штатном расписании 1С ({row.get('Подразделение', '—')}), но полностью отсутствует в базе СКУД Орион Pro (профиль не создан или карта не выдана)"
            })

return anomalies

def aggregate_scud_by_employee(df, debug=False): """Агрегирует проходы СКУД по уникальным сотрудникам.""" if df is None or df.empty or 'fio_clean' not in df.columns: return df

aggregated = []
for fio_clean, group in df.groupby('fio_clean', sort=False):
    is_present = group['Пришел'].any() if 'Пришел' in group.columns else False
    
    if is_present and 'Пришел' in group.columns:
        present_rows = group[group['Пришел'] == True]
        best_row = present_rows.iloc[0].to_dict() if not present_rows.empty else group.iloc[0].to_dict()
    else:
        best_row = group.iloc[0].to_dict()

    best_row['Пришел'] = is_present
    aggregated.append(best_row)

return pd.DataFrame(aggregated)

def main(): help_text = """ Система автоматизированного контроллинга СКУД ⟷ 1С:ЗУП (scud_orion_ai_v2)

ПРИМЕРЫ ЗАПУСКА: python main.py -- Обычный дневной запуск python main.py --skip-export -- Расчет отчета по ПОСЛЕДНЕМУ имеющемуся снапшоту из SQLite python main.py --snapshot 20260805-001 -- Расчет отчета строго по ID снапшота python main.py -d -- Запуск в режиме расширенной отладки (DEBUG) """ parser = argparse.ArgumentParser( description=help_text, formatter_class=argparse.RawDescriptionHelpFormatter ) parser.add_argument('-d', '--debug', action='store_true', help="Запуск в режиме отладки с выводом подробных логов") parser.add_argument('--skip-export', action='store_true', help="Пропустить выгрузку СКУД из MS SQL и построить отчет по последнему снапшоту") parser.add_argument('--snapshot', type=str, default=None, help="Составной ID снапшота или время создания")

args = parser.parse_args()
DEBUG = args.debug

print("=" * 60)
print(f"ЗАПУСК СИСТЕМЫ МОДУЛЬНОГО КОНТРОЛЛИНГА СКУД ⟷ 1С {'[DEBUG MODE]' if DEBUG else ''}")
print("=" * 60)

init_db()
kb_data = load_knowledge_base()
kb_rules = kb_data.get("rules", [])
exceptions_cfg = load_exceptions_config()

if args.snapshot:
    snapshot_param = args.snapshot
    print(f"[📸] РЕЖИМ СНАПШОТА: Расчет отчета строго по срезу '{snapshot_param}'")
elif args.skip_export:
    snapshot_param = get_latest_snapshot_time()
    print(f"[📸] РЕЖИМ --skip-export: Используем последний снапшот из SQLite ('{snapshot_param}')")
else:
    snapshot_param = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print(f"[📸] СФОРМИРОВАН НОВЫЙ СНАПШОТ: '{snapshot_param}'")

if not args.skip_export and not args.snapshot:
    try:
        run_export(save_xlsx=True, debug=DEBUG)
    except Exception as e:
        print(f"[⚠️] Ошибка автоэкспорта из БД: {e}. Переходим к записям в SQLite.")
else:
    print("[0/5] Пропуск прямого экспорта из MS SQL (чтение из базы SQLite)...")

copy_1c_files_from_share()

print("[1/5] Проверка актуальности и свежести входных данных...")
is_valid, warnings, errors, has_today_1c = check_file_freshness()

if warnings:
    print("\n--- ⚠️ ПРЕДУПРЕЖДЕНИЯ ОБ АКТУАЛЬНОСТИ ---")
    for w in warnings:
        print(f"  • {w}")
    print("-" * 45)

if not is_valid:
    print("\n" + "!" * 60)
    print("🛑 ОСТАНОВКА ВЫПОЛНЕНИЯ: Отсутствуют критически важные файлы за вчерашний день!")
    for e in errors:
        print(f"  {e}")
    print("!" * 60)
    sys.exit(1)

print("[✓] Проверка доступности данных успешно пройдена!\n")

print("[2/5] Загрузка данных из СКУД, 1С:ЗУП, реестра причин и исключений...")

if args.snapshot or args.skip_export:
    raw_scud_today_df = load_scud_from_db_by_snapshot(DATE_TODAY, snapshot_param)
    raw_scud_yesterday_df = load_scud_from_db_by_snapshot(DATE_YESTERDAY, snapshot_param)
    
    if raw_scud_yesterday_df.empty:
        raw_scud_yesterday_df = load_scud_from_db_by_snapshot(DATE_YESTERDAY)

    (
        _, _,
        df_staff_today, df_absent_today,
        df_staff_yesterday, df_absent_yesterday
    ) = load_all_data()
else:
    (
        raw_scud_today_df, raw_scud_yesterday_df,
        df_staff_today, df_absent_today,
        df_staff_yesterday, df_absent_yesterday
    ) = load_all_data()

if df_staff_yesterday is not None:
    save_staff_to_db(df_staff_yesterday, DATE_YESTERDAY)
if df_absent_yesterday is not None:
    save_absences_to_db(df_absent_yesterday, DATE_YESTERDAY)

if df_staff_today is not None:
    save_staff_to_db(df_staff_today, DATE_TODAY)
if df_absent_today is not None:
    save_absences_to_db(df_absent_today, DATE_TODAY)

staff_fios_yesterday_clean = df_staff_yesterday['fio_clean'].dropna().tolist() if df_staff_yesterday is not None else []
static_reasons_dict = load_static_reason_workers()

# ============================================================
# 🎯 ЧАСТЬ 1: ДЕТАЛЬНЫЙ ОТЧЕТ ЗА ВЧЕРА (ГАРАНТИРОВАННЫЙ РАСЧЕТ)
# ============================================================
print(f"\n[3/5] Обработка и построение детального отчета за ВЧЕРА ({DATE_YESTERDAY})...")

if not raw_scud_yesterday_df.empty and 'Пришел' not in raw_scud_yesterday_df.columns:
    raw_scud_yesterday_df['Пришел'] = raw_scud_yesterday_df['is_present'].astype(int) == 1 if 'is_present' in raw_scud_yesterday_df.columns else False

scud_yesterday_unrecognized = raw_scud_yesterday_df[~raw_scud_yesterday_df['fio_clean'].isin(staff_fios_yesterday_clean)]['fio_clean'].tolist() if not raw_scud_yesterday_df.empty else []

fio_mapping_scud_y = ai_verify_scud_against_staff(scud_yesterday_unrecognized, staff_fios_yesterday_clean)
if fio_mapping_scud_y:
    raw_scud_yesterday_df['fio_clean'] = raw_scud_yesterday_df['fio_clean'].apply(
        lambda x: fio_mapping_scud_y[x]['staff_fio'] if x in fio_mapping_scud_y else x
    )

if df_absent_yesterday is not None and not df_absent_yesterday.empty:
    absent_unrecognized_yesterday = df_absent_yesterday[~df_absent_yesterday['fio_clean'].isin(staff_fios_yesterday_clean)]['fio_clean'].tolist()
    if absent_unrecognized_yesterday:
        fio_mapping_absent_y = ai_verify_scud_against_staff(absent_unrecognized_yesterday, staff_fios_yesterday_clean)
        if fio_mapping_absent_y:
            df_absent_yesterday['fio_clean'] = df_absent_yesterday['fio_clean'].apply(
                lambda x: fio_mapping_absent_y[x]['staff_fio'] if x in fio_mapping_absent_y else x
            )

raw_scud_yesterday_df = aggregate_scud_by_employee(raw_scud_yesterday_df, debug=DEBUG)

merged_yesterday = df_staff_yesterday.copy() if df_staff_yesterday is not None else pd.DataFrame()
if not merged_yesterday.empty:
    if not raw_scud_yesterday_df.empty:
        if 'Подразделение' in raw_scud_yesterday_df.columns:
            raw_scud_yesterday_df['department_scud'] = raw_scud_yesterday_df['Подразделение']
        elif 'department' in raw_scud_yesterday_df.columns:
            raw_scud_yesterday_df['department_scud'] = raw_scud_yesterday_df['department']
        else:
            raw_scud_yesterday_df['department_scud'] = ''

        merged_yesterday = merged_yesterday.merge(
            raw_scud_yesterday_df[['fio_clean', 'Пришел', 'Начало_дня', 'Первая_активность', 'Конец_дня', 'Находился_в_здании', 'anomaly_flag', 'department_scud']], 
            on='fio_clean', how='left'
        )
    
    if df_absent_yesterday is not None and not df_absent_yesterday.empty:
        merged_yesterday = merged_yesterday.merge(df_absent_yesterday[['fio_clean', 'Вид_отсутствия']], on='fio_clean', how='left')

if 'Пришел' not in merged_yesterday.columns:
    merged_yesterday['Пришел'] = False
else:
    merged_yesterday['Пришел'] = merged_yesterday['Пришел'].fillna(False)

if 'Сотрудник' not in merged_yesterday.columns:
    merged_yesterday['Сотрудник'] = merged_yesterday.get('ФИО', merged_yesterday['fio_clean'])

if static_reasons_dict:
    for fio_clean, reason_val in static_reasons_dict.items():
        mask_yesterday = (
            (merged_yesterday['Пришел'] == False) & 
            (merged_yesterday['Вид_отсутствия'].isna() | (merged_yesterday['Вид_отсутствия'].astype(str).str.strip() == '')) & 
            (merged_yesterday['fio_clean'] == fio_clean)
        )
        merged_yesterday.loc[mask_yesterday, 'Вид_отсутствия'] = reason_val

merged_yesterday = apply_exceptions_from_json(merged_yesterday, exceptions_cfg)
mask_exc_yesterday = (
    (merged_yesterday['Пришел'] == False) & 
    (merged_yesterday['Вид_отсутствия'].isna() | (merged_yesterday['Вид_отсутствия'].astype(str).str.strip() == '')) & 
    (merged_yesterday.get('is_excluded', False) == True)
)
merged_yesterday.loc[mask_exc_yesterday, 'Вид_отсутствия'] = 'Исключение (ОВК/Подрядчики)'

# Расчет флага no_scud_pass для вчера
scud_fios_yesterday_set = set(raw_scud_yesterday_df['fio_clean'].dropna().tolist()) if not raw_scud_yesterday_df.empty else set()
merged_yesterday['no_scud_pass'] = (
    (~merged_yesterday['fio_clean'].isin(scud_fios_yesterday_set)) & 
    (merged_yesterday['Вид_отсутствия'].isna() | (merged_yesterday['Вид_отсутствия'].astype(str).str.strip() == '')) & 
    (merged_yesterday.get('is_excluded', False) == False)
)

# 🚨 Рассчитываем аномалии за ВЧЕРА
anomalies_yesterday_list = detect_all_anomalies(merged_yesterday, static_reasons_dict, kb_rules, scud_fios_set=scud_fios_yesterday_set)
save_anomalies_to_db(anomalies_yesterday_list, DATE_YESTERDAY)

# ⚡️ Фильтрация: исключения НЕ попадают в вчерашний отчет (если нет отпуска из 1С)
filtered_yesterday = filter_report_dataframe(merged_yesterday)
generate_detailed_excel(merged_df=filtered_yesterday, date_str=DATE_YESTERDAY)

# Фиксируем вчерашний снапшот строго на 22:00:00
yesterday_dt_obj = datetime.strptime(DATE_YESTERDAY, "%d.%m.%Y")
yesterday_22_str = yesterday_dt_obj.strftime("%Y-%m-%d 22:00:00")
save_scud_to_db(merged_yesterday, DATE_YESTERDAY, snapshot_time=yesterday_22_str, is_yesterday=True)
print(f"[✓] Детальный отчет за вчера сформирован и зафиксирован в SQLite со снапшотом на {yesterday_22_str}")

# ============================================================
# 🎯 ЧАСТЬ 2: ЕЖЕДНЕВНАЯ СВОДКА ЗА СЕГОДНЯ
# ============================================================
if not args.snapshot and not args.skip_export:
    save_scud_to_db(raw_scud_today_df, DATE_TODAY, snapshot_time=snapshot_param, is_yesterday=False)

if has_today_1c and df_staff_today is not None and df_absent_today is not None:
    print("\n[4/5] Обработка данных за СЕГОДНЯ...")
    staff_fios_today_clean = df_staff_today['fio_clean'].dropna().tolist()

    if not raw_scud_today_df.empty and 'Пришел' not in raw_scud_today_df.columns:
        raw_scud_today_df['Пришел'] = raw_scud_today_df['is_present'].astype(int) == 1 if 'is_present' in raw_scud_today_df.columns else False

    scud_unrecognized = raw_scud_today_df[~raw_scud_today_df['fio_clean'].isin(staff_fios_today_clean)]['fio_clean'].tolist() if not raw_scud_today_df.empty else []
    fio_mapping_scud = ai_verify_scud_against_staff(scud_unrecognized, staff_fios_today_clean)
    if fio_mapping_scud:
        raw_scud_today_df['fio_clean'] = raw_scud_today_df['fio_clean'].apply(
            lambda x: fio_mapping_scud[x]['staff_fio'] if x in fio_mapping_scud else x
        )

    absent_unrecognized_today = df_absent_today[~df_absent_today['fio_clean'].isin(staff_fios_today_clean)]['fio_clean'].tolist()
    if absent_unrecognized_today:
        fio_mapping_absent = ai_verify_scud_against_staff(absent_unrecognized_today, staff_fios_today_clean)
        if fio_mapping_absent:
            df_absent_today['fio_clean'] = df_absent_today['fio_clean'].apply(
                lambda x: fio_mapping_absent[x]['staff_fio'] if x in fio_mapping_absent else x
            )

    raw_scud_today_df = aggregate_scud_by_employee(raw_scud_today_df, debug=DEBUG)

    merged_today = df_staff_today.copy()
    if not raw_scud_today_df.empty:
        if 'Подразделение' in raw_scud_today_df.columns:
            raw_scud_today_df['department_scud'] = raw_scud_today_df['Подразделение']
        elif 'department' in raw_scud_today_df.columns:
            raw_scud_today_df['department_scud'] = raw_scud_today_df['department']
        else:
            raw_scud_today_df['department_scud'] = ''

        merged_today = merged_today.merge(
            raw_scud_today_df[['fio_clean', 'Пришел', 'Начало_дня', 'Первая_активность', 'Конец_дня', 'Находился_в_здании', 'anomaly_flag', 'department_scud']], 
            on='fio_clean', how='left'
        )
    
    if df_absent_today is not None and not df_absent_today.empty:
        merged_today = merged_today.merge(df_absent_today[['fio_clean', 'Вид_отсутствия']], on='fio_clean', how='left')

    if 'Пришел' not in merged_today.columns:
        merged_today['Пришел'] = False
    else:
        merged_today['Пришел'] = merged_today['Пришел'].fillna(False)

    if 'Сотрудник' not in merged_today.columns:
        merged_today['Сотрудник'] = merged_today.get('ФИО', merged_today['fio_clean'])

    if static_reasons_dict:
        for fio_clean, reason_val in static_reasons_dict.items():
            mask_today = (
                (merged_today['Пришел'] == False) & 
                (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
                (merged_today['fio_clean'] == fio_clean)
            )
            merged_today.loc[mask_today, 'Вид_отсутствия'] = reason_val

    merged_today = apply_exceptions_from_json(merged_today, exceptions_cfg)
    mask_exc_today = (
        (merged_today['Пришел'] == False) & 
        (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
        (merged_today.get('is_excluded', False) == True)
    )
    merged_today.loc[mask_exc_today, 'Вид_отсутствия'] = 'Исключение (ОВК/Подрядчики)'

    # Расчет флага no_scud_pass для сегодня
    scud_fios_today_set = set(raw_scud_today_df['fio_clean'].dropna().tolist()) if not raw_scud_today_df.empty else set()
    merged_today['no_scud_pass'] = (
        (~merged_today['fio_clean'].isin(scud_fios_today_set)) & 
        (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
        (merged_today.get('is_excluded', False) == False)
    )

    scud_fios_set = set(raw_scud_today_df['fio_clean'].dropna().tolist()) if not raw_scud_today_df.empty else set()
    anomalies_list = detect_all_anomalies(merged_today, static_reasons_dict, kb_rules, scud_fios_set=scud_fios_set)

    # 🚨 ОПЕРАТИВНЫЙ МОНИТОРИНГ ОБОРУДОВАНИЯ СКУД ЗА СЕГОДНЯ:
    mass_failure_today = analyze_scud_mass_failure_ai(raw_scud_today_df)
    if mass_failure_today and mass_failure_today.get("is_mass_failure"):
        print("\n" + "!" * 60)
        print(f"🚨 ВНИМАНИЕ! ИИ ОБНАРУЖИЛ ОПЕРАТИВНЫЙ СБОЙ ТУРНИКЕТОВ ВХОДА СЕГОДНЯ ({mass_failure_today['anomaly_percent']}% СМЕНЫ)")
        print(mass_failure_today["alert_text"])
        print("!" * 60 + "\n")

    save_anomalies_to_db(anomalies_list, DATE_TODAY)

    # Флаги фильтрации для ИИ-репортера
    is_no_pass_today = merged_today['no_scud_pass'] == True if 'no_scud_pass' in merged_today.columns else False
    is_exc_today = merged_today.get('is_excluded', False) == True

    absent_explained = merged_today[
        (merged_today['Пришел'] == False) & 
        (merged_today['Вид_отсутствия'].notna()) & 
        (~merged_today['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
    ]

    # Истинно неизвестные случаи (исключаем тех, у кого нет пропуска, и спецотделы ОВК/Охрана)
    absent_unexplained = merged_today[
        (merged_today['Пришел'] == False) & 
        (merged_today['Вид_отсутствия'].isna() | (merged_today['Вид_отсутствия'].astype(str).str.strip() == '')) & 
        (~is_no_pass_today) & 
        (~is_exc_today)
    ]

    scud_present_but_absent_in_1c = merged_today[
        (~is_exc_today) & 
        (merged_today['Пришел'] == True) & 
        (merged_today['Вид_отсутствия'].notna()) & 
        (~merged_today['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
    ]

    print("[5/5] Запуск ИИ-аудитора и построение Ежедневной сводки...")
    # Фильтруем аномалии СКУД для текстового отчета (убираем аномалии "ОТСУТСТВУЕТ В СКУД", т.к. они ушли в раздел "Нет пропуска")
    filtered_anomalies_list = [
        a for a in anomalies_list 
        if "ОТСУТСТВУЕТ В СКУД" not in a.get('type', '')
    ]

    report_text = generate_markdown_report(
        merged_df=merged_today,
        absent_explained=absent_explained,
        absent_unexplained=absent_unexplained,
        scud_present_but_absent_in_1c=scud_present_but_absent_in_1c,
        anomalies_list=filtered_anomalies_list,
        raw_scud_df=raw_scud_today_df,
        raw_absent_df=df_absent_today,
        date_str=DATE_TODAY
    )

    generate_summary_excel(merged_df=merged_today, date_str=DATE_TODAY)

    md_report_path = os.path.join(OUTPUT_DIR, f"Сводка_контроллинга_{DATE_TODAY}.md")
    with open(md_report_path, "w", encoding="utf-8") as f:
        f.write(report_text)
    print(f"\n[✓] Текстовый отчет сохранен в: {md_report_path}")

    suspicious_cases = []
    for a in anomalies_list:
        if "ОФИЦИАЛЬНОМ ОТСУТСТВИИ" not in a.get('type', ''):
            suspicious_cases.append({
                'fio_target': a['fio'],
                'reason': f"{a['type']}: {a['details']}"
            })
            
    if suspicious_cases:
        review_ai_decisions(report_text, suspicious_cases)

    print("\n" + "=" * 60)
    print("ГОТОВАЯ ТЕКСТОВАЯ СВОДКА ИИ-АУДИТОРА:")
    print("=" * 60)
    print(report_text)
else:
    print(f"\n[ℹ️] Формирование Ежедневной сводки за {DATE_TODAY} ПРОПУЩЕНО.")

if name == "main": main()


# File: ./project_snapshot_scud_orion_ai_v2.md

О’кей хорошо! Ниже представлена полностью объединенная и систематизированная история развития проекта scud_orion_ai_v2. В нее вошел весь путь: от стартовых инцидентов с файлами 1С и отладкой MS SQL Ориона до текущей архитектуры со снапшотами, двойной фильтрацией исключений и SQLite-базой знаний.

🚀 ПОЛНАЯ ИСТОРИЯ РАЗВИТИЯ И СНАПШОТ ПРОЕКТА: SCUD ORION AI (v2)

Дата актуализации: 05.08.2026
Статус проекта: Производственный релиз (Production-Ready) с поддержкой снапшотов, двойной фильтрацией исключений, лаконичным форматированием и синхронизацией SQLite.
Общий объем кода: ~2 620 строк Python (17 модулей + CLI-инструментарий)

📌 1. НАЗНАЧЕНИЕ И АРХИТЕКТУРА СИСТЕМЫ

Проект scud_orion_ai_v2 — это система автоматизированного кадрового контроллинга и аудита трудовой дисциплины. Система сопоставляет логи физических проходов СКУД «Орион Pro» (MS SQL Server) с кадровыми данными и документами отсутствия из 1С:ЗУП 3.1 (MS SQL Server / Сетевая шара), а также выполняет квалификацию отклонений с помощью локальной LLM (Ollama / Qwen 2.5 14B).

💻 Ключевой стек технологий:

Язык разработки: Python 3.12 (в изолированном venv).
СУБД СКУД (Источник): MS SQL Server (Orion-14.01.21-1 на хосте 172.16.31.221\SQL).
СУБД 1С (Источник): MS SQL Server (ACCOUNT-01, БД zup_db).
Фоллбэк/Обмен: Сетевая Linux-шара (/mnt/scud_share).
Локальная СУБД (Проект): SQLite (data/scud_orion_ai.db с поддержкой WAL-режима и истории снапшотов).
AI Engine: Ollama API (http://192.168.11.3:11434/api/generate, модель qwen2.5:14b).
CLI & Репорты: pandas, openpyxl, pyodbc, sqlite3.

📜 2. ПОЛНАЯ ХРОНОЛОГИЯ ИНЦИДЕНТОВ И РЕШЕНИЙ

🔹 Инцидент 1: Ошибка распарсивания Excel-файлов Штатного расписания 1С

Симптом: KeyError: 'ФИО' при запуске main.py на этапе загрузки штата из /data/1c/Штат_DD_MM_YYYY.xlsx.
Причина: Файлы экспорта 1С выгружаются со служебным заголовком. При skiprows=7 датафрейм воспринимал строку с именами колонок как данные, присваивая столбцам имена Unnamed: 0, Unnamed: 1.
Решение: Перешли от обращения по текстовым именам колонок к позиционному связыванию через .iloc[:, [1, 5, 12]] (индексы: 1 — ФИО, 5 — Подразделение, 12 — Должность) со сдвигом skiprows=8.

🔹 Инцидент 2: Падение сетевого подключения к MS SQL Server 1С (`Login timeout expired`)

Симптом: Соединение к MS SQL падало по таймауту (HYT00), приводя к отсутствию таблицы zup_absences в памяти и KeyError: 'Вид_отсутствия'.
Причина: В модуле zup_extractor.py находились дефолтные тестовые параметры подключения (192.168.1.10) вместо продакшн-конфигурации.
Решение:
- Перевели zup_extractor.py на прямой импорт параметров из config.py (сервер ACCOUNT-01).
- В services/data_loader.py реализован гибридный фоллбэк: при недоступности MS SQL 1С система автоматически считывает локальные файлы Отсутствия_DD_MM_YYYY.xlsx из папки data/1c/ (копируемые с шары /mnt/scud_share).

🔹 Инцидент 3: Аномалия УРВ «Орион Pro» (Случай сотрудника Равина В.Э.)

Симптом: В выгрузке scud_export.py сотрудник числился присутствовавшим (вход в 14:11:06), а в отчете УРВ «Орион Pro» стоял статус «Нет входа» / 0:00 отработанных часов.
Расследование в SSMS: Был установлен истинный системный ключ в базе Ориона: pList.ID = 2107 (pList.TabNumber = 13058, а связка логов идет по pLogData.HozOrgan = pList.ID). Прямой запрос к сырым логам pLogData вернул события: 13:51:15 — Выход (Event 28/32), 14:11:06 — Вход (Event 28/32).
Причина расхождения: День сотрудника начался с фиксации Выхода в 13:51 (приход утром без прикладывания карты). Модуль УРВ «Ориона» не смог корректно сопоставить смену, начинающуюся с выхода, и обнулил табель.
Вывод для системы: Первичные физические логи pLogData (события 28/32) обладают 100% приоритетом над расчетным модулем УРВ Ориона.

🔹 Инцидент 4: Ошибка нулевых показателей при `--skip-export`

Причина: В запросе к SQLite использовалось жесткое равенство по метке времени snapshot_time. Если секунды среза отличались, запрос возвращал 0 строк.
Решение: Введены составные ID снапшотов (20260805-001, Y20260805-001) и ступенчатый fallback-механизм в core/database.py: если точного времени нет, подтягивается самый свежий имеющийся срез за указанную дату.

🔹 Инцидент 5: Потеря названий отделов и должностей (`—`, `—`)

Причина: Колонки в базе SQLite назывались department и position, а отчет требовал Подразделение и Должность.
Решение: В core/database.py добавлен автоматический маппинг колонок при считывании из SQLite, а в main.py — подтягивание метаданных из 1С:Штат.

🔹 Инцидент 6: Раздутый список «Неизвестных случаев» (21 чел `\rightarrow` 11 чел)

Причина: В 1С отделы записаны полными именами («Отдел внутреннего контроля»), а в exceptions.json — аббревиатурами («ОВК»). Из-за этого контролеры ОВК, клининг и подрядчики не находились алгоритмом и попадали в неизвестные.
Решение: Реализована двойная проверка в main.py: при объединении данных сохраняется родная аббревиатура из MS SQL СКУД (department_scud). Функция apply_exceptions_from_json проводит поиск и по имени 1С, и по короткой аббревиатуре СКУД.

🛡️ 3. АРХИТЕКТУРА БЕЗОПАСНОСТИ И ПРИОРИТЕТОВ

👥 Защита от «Полных Тёзок» (Full Name Collision)

Уровень 1 (БД & SQL): Использование строго уникальных идентификаторов (pList.ID в СКУД, GUID/Табельный номер в 1С).
Уровень 2 (Составные ключи): При мёрдже без прямых ID применяется контекстный ключ: ext{Composite Key} = ext{fio\_clean} + ext{"\_"} + ext{department} + ext{"\_"} + ext{position}
Уровень 3 (AI-Валидатор): Системный промпт LLM запрещает объединять записи полных тёзок при разнице в отделе или должности.

⚙️ Иерархия приоритетов статуса сотрудника:

Status =  Пришел (по СКУД), если есть вход или активность
 Документ 1С:ЗУП (Отпуск, Больничный...), высший приоритет над исключениями
 Причина из static_reason_workers.csv, если указан удаленщик
 Исключение (ОВК/Подрядчики), если подпадает под exceptions.json и в 1С ПУСТО
 Неизвестно (Истинно неотмеченный), если офисный сотрудник без проходов и без 1С

📁 4. СТРУКТУРА КАТАЛОГОВ И ИСПРАВЛЕННЫХ МОДУЛЕЙ

scud_orion_ai_v2/
├── config.py                   # Глобальная конфигурация, пути, параметры SQL и LLM (Ollama)
├── main.py                     # Главный оркестратор пайплайна (СКУД ⟷ 1С, ИИ-аудит, Excel/MD)
├── exceptions.json             # Исключения (подрядчики, ОВК, клининг, списки ФИО)
├── core/
│   ├── __init__.py
│   └── database.py             # Схема SQLite, таблицы scud_logs, zup_staff, ai_knowledge_base
├── services/
│   ├── __init__.py
│   ├── scud_export.py          # Выгрузка СКУД из MS SQL Орион Pro + расчет первой активности
│   ├── zup_extractor.py        # Выгрузка отсутствий из MS SQL 1С:ЗУП 3.1
│   ├── share_copier.py         # Копирование XLSX файлов с шары /mnt/scud_share
│   ├── data_loader.py          # Загрузка, очистка и маркировка аномалий СКУД/1С
│   ├── data_validator.py       # Проверка свежести входных файлов
│   ├── excel_exporter.py       # Формирование Excel-сводок и детальных отчетов (.xlsx)
│   ├── ai_verifier.py          # Взаимодействие с Ollama (Qwen 2.5): сверка ФИО и сбои
│   ├── text_reporter.py        # Генерация итогового Markdown-отчета (.md)
│   ├── feedback_loop.py        # Контур обучения ИИ (Human-in-the-Loop)
│   └── knowledge_base.py       # Загрузка и пополнение Базы Знаний ИИ через SQLite
├── scripts/
│   ├── __init__.py
│   ├── migrate_db.py           # Мигратор схемы SQLite БД
│   └── db_cli.py               # CLI утилита управления БД, снапшотами и экспорта в Excel
├── data/                       # Локальная SQLite БД, выгрузки 1С, СКУД
│   ├── scud_orion_ai.db
│   └── static_reason_workers.csv
└── output/                     # Готовые сводки и отчеты (.xlsx, .md)

🛠 5. СПРАВОЧНИК КОМАНД И ЗАПУСКА

1. Главный скрипт (`main.py`)

python main.py [ФЛАГИ]

Команда / Флаг	Описание
`python main.py`	Обычный полный дневной запуск
`python main.py --skip-export`	Расчет по последнему имеющемуся снапшоту из SQLite
`python main.py --snapshot 20260805-001`	Расчет строго по ID конкретного снапшота
`python main.py -d`	Режим расширенной отладки (DEBUG)

2. CLI-утилита инспекции БД (`scripts/db_cli.py`)

Прототип Сервисного Слоя для будущего REST API.

python scripts/db_cli.py <КОМАНДА> [ПАРАМЕТР] [ФЛАГИ]

Команда	Описание
`python scripts/db_cli.py scud`	Просмотр логов СКУД за сегодня
`python scripts/db_cli.py scud --snapshot 20260805-001`	Просмотр логов конкретного снапшота
`python scripts/db_cli.py scud --export-xlsx debug_today`	Экспорт среза СКУД в Excel
`python scripts/db_cli.py snapshots`	Список всех снапшотов
`python scripts/db_cli.py anomalies`	История найденных аномалий
`python scripts/db_cli.py rules`	Правила Базы Знаний ИИ из SQLite
`python scripts/db_cli.py dump [output.xlsx]`	Полный дамп всех таблиц БД в Excel

📐 Сквозной цикл работы контроллинга SCUD Orion AI (v2) 🔄 Схема движения данных

           ┌────────────────────────────────────────┐
           │    Входные CLI-параметры main.py       │
           │ (--skip-export / --snapshot / --debug) │
           └───────────────────┬────────────────────┘
                               │
  ┌────────────────────────────┴───────────────────────────┐
  ▼                                                        ▼

┌───────────────────────────────┐ ┌───────────────────────────────────┐ │ 0. MS SQL Орион Pro (СКУД) │ │ 0.5 Сетевая шара /mnt/scud_share │ │ scud_export.py (Первая акт.) │ │ share_copier.py (Штат и Отсут.) │ └──────────────┬────────────────┘ └─────────────────┬─────────────────┘ │ │ ▼ ▼ ┌───────────────────────────────┐ ┌───────────────────────────────────┐ │ SQLite: scud_logs │ │ data/1c/Штат & Отсутствия │ │ (Сохранение snapshot_id) │ │ (Файлы Excel за сегодня/вчера) │ └──────────────┬────────────────┘ └─────────────────┬─────────────────┘ │ │ └───────────────────────┬───────────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ 1. data_validator.py │ │ (Проверка свежести и остановок) │ └─────────────────┬─────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ 2. data_loader.py │ │ (Фоллбэки + Загрузка + Scud Dept) │ └─────────────────┬─────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ 3. ИИ-Арбитраж & SQLite KB │ │ (Qwen 2.5 + ai_knowledge_base) │ └─────────────────┬─────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ 4. Иерархическое сведение │ │ (1С -> CSV -> exceptions.json) │ └─────────────────┬─────────────────┘ │ ┌───────────────────┴───────────────────┐ ▼ ▼ ┌──────────────────────────┐ ┌──────────────────────────┐ │ Данные за ВЧЕРА │ │ Данные за СЕГОДНЯ │ └────────────┬─────────────┘ └────────────┬─────────────┘ │ │ ▼ ▼ ┌──────────────────────────┐ ┌──────────────────────────┐ │ Detailed Excel (.xlsx) │ │ Summary Excel (.xlsx) │ │ Детальный разбор вчера │ │ + Markdown сводка (.md) │ └────────────┬─────────────┘ └────────────┬─────────────┘ │ │ └───────────────────┬───────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ 5. feedback_loop.py │ │ ( Human-in-the-Loop обучение ИИ ) │ └─────────────────┬─────────────────┘ │ ▼ ┌───────────────────────────────────┐ │ SQLite: scud_orion_ai.db │ │ (Фиксация логов, аномалий и KB) │ └───────────────────────────────────┘ 🛠 Подробное описание каждого этапа Этап Модуль Описание и выполняемые задачи 0. СКУД Экспорт services/scud_export.py Запрос к MS SQL «Орион Pro», вычисление утреннего входа и первой активности (first_activity), запись в SQLite с присвоением snapshot_id. 0.5. Копирование 1С services/share_copier.py Забор актуальных Excel-файлов Штатного расписания и Отсутствий из Linux-шары /mnt/scud_share.

Валидация services/data_validator.py Проверка наличия кадровых данных за вчерашний день. При критическом отсутствии файлов блокирует расчет.
Загрузка services/data_loader.py Загрузка датасетов, нормализация ФИО и проброс родных коротких аббревиатур отделов из СКУД (department_scud).
ИИ-Аудит services/ai_verifier.py Запрос к локальной LLM Ollama (Qwen 2.5) с подгрузкой контекста правил из SQLite-таблицы ai_knowledge_base. Исправление опечаток ФИО и отслеживание сбоев турникетов (>5%).
Сведение main.py Применение иерархии приоритетов: 1С:ЗУП → static_csv → exceptions.json (проверка по 1С и department_scud) → Неизвестные.
Отчетность & Обучение excel_exporter.py

text_reporter.py

feedback_loop.py

Формирование Excel-файлов, сборка текста Markdown с аббревиатурами и запись вердиктов кадровика в SQLite.

🔮 6. БУДУЩИЕ ТОЧКИ РОСТА (ДОРОЖНАЯ КАРТА ВЕБ-РЕЛИЗА)

REST API на FastAPI: Перенос функций из db_cli.py в эндпоинты (/api/v1/snapshots, /api/v1/scud/logs, /api/v1/anomalies).
ИИ-Чат с поддержкой Function Calling: Предоставление Ollama (Qwen 2.5) права прямого вызова эндпоинтов API из чата по запросу пользователя («Сформируй срез за 12:00 и экспортируй в Excel»).
Telegram-уведомления: Автоматическая отправка алертов администраторам при выявлении массовых сбоев турникетов (>5%).


# File: ./test.txt

122222222222222222222222222222


# File: ./test_zup_conn.py

import sys import pyodbc from config import ZUP_SQL_CONFIG

def test_connection(): print("=" * 60) print("🧪 ПРОВЕРКА ПОДКЛЮЧЕНИЯ К MS SQL SERVER (1С:ЗУП)") print("=" * 60) print(f" • Сервер: {ZUP_SQL_CONFIG['server']}") print(f" • База: {ZUP_SQL_CONFIG['database']}") print(f" • Логин: {ZUP_SQL_CONFIG['user']}") print(f" • Драйвер: {ZUP_SQL_CONFIG['driver']}") print("-" * 60)

conn_str = (
    f"DRIVER={ZUP_SQL_CONFIG['driver']};"
    f"SERVER={ZUP_SQL_CONFIG['server']};"
    f"DATABASE={ZUP_SQL_CONFIG['database']};"
    f"UID={ZUP_SQL_CONFIG['user']};"
    f"PWD={ZUP_SQL_CONFIG['password']};"
    f"TrustServerCertificate={ZUP_SQL_CONFIG['trust_server_certificate']};"
    f"Encrypt={ZUP_SQL_CONFIG['encrypt']};"
)

try:
    print("⏳ Установка соединения...")
    with pyodbc.connect(conn_str, timeout=10) as conn:
        cursor = conn.cursor()
        
        # 1. Проверка версии SQL Сервера
        cursor.execute("SELECT @@VERSION;")
        db_version = cursor.fetchone()[0]
        print("✅ Подключение успешно установлено!\n")
        print(f"📋 Версия MS SQL Server:\n{db_version.splitlines()[0]}\n")

        # 2. Проверка доступа к таблице физических лиц _Reference299
        cursor.execute("SELECT COUNT(*) FROM dbo._Reference299 WITH (NOLOCK);")
        count_phys = cursor.fetchone()[0]
        print(f"📊 Записей в таблице физлиц (_Reference299): {count_phys} шт.")

        # 3. Проверка доступа к регистру кадровых состояний _InfoRg16921
        cursor.execute("SELECT COUNT(*) FROM dbo._InfoRg16921 WITH (NOLOCK);")
        count_states = cursor.fetchone()[0]
        print(f"📊 Записей в регистре состояний (_InfoRg16921): {count_states} шт.")

        print("\n🎉 Все проверки успешно пройдены!")

except pyodbc.Error as ex:
    sqlstate = ex.args[0] if ex.args else "UNKNOWN"
    print("\n❌ ОШИБКА ПОДКЛЮЧЕНИЯ!")
    print(f"Код ошибки: {sqlstate}")
    print(f"Детали:\n{ex}")
    sys.exit(1)

if name == "main": test_connection()


# File: ./Анализ_аномалии_СКУД_и_техзадание.md

ТЕХНИЧЕСКИЙ РАЗБОР АНОМАЛИИ СКУД И ТЗ НА ФИКС

Проблема скрытого маскирования сбоев турникетов и правила их устранения в проекте scud_orion_ai

📋 Метаданные инцидента

Параметр	Значение
Дата инцидента:	04 августа 2026 г.
Затронуто сотрудников:	~119 человек (из 276)
Система:	СКУД «Орион Pro» (MSSQL) + Python ETL + SQLite
Статус решения:	Требуется фикс валидации данных (В процессе)

1. Суть проблемы («Грабли»)

При утреннем сбое турникетов или контроллеров СКУД (08:00–10:00) события первичного прохода в базу не попадают. В результате у сотрудников в итоговом отчете формируется значение Начало_дня = «Нет входа».

Однако в течение дня сотрудники перемещаются внутри здания, выходят на обед или прикладывают карты к внутренним считывателям, генерируя сырые транзакции в MSSQL (таблица pLogData).

🚨 Главная баг-логика текущего алгоритма: Скрипт перебирает все события за день и, видя любую дневную/вечернюю активность, автоматически присваивает сотруднику флаг is_present = 1 (Статус = «Присутствовал»).

В итоге система «тихо сглаживает» аномалию: вместо того чтобы поднять тревогу о массовом сбое турникетов (70+ человек без утреннего входа), скрипт отправил 30+ человек в «Итого на работе», искусственно уменьшив список проблемных записей до 7 «неизвестных».

2. Разбор механики расхождения отчетов (17:00 vs Конец дня)

Вопреки первоначальной гипотезе, вечерние выходы (17:42 и т.д.) у данных сотрудников не записывались в колонку time_out (там оставалось «Нет выхода»). Расхождение выгрузок было вызвано двумя факторами:

В 17:00 в базе SQL 1С еще отсутствовал полный пакет кадровых документов за день, либо запуск производился без сверки с реестром исключений.
При повторном прогоне (вечером/ночью) скрипт подтянул полную базу 1С, а для оставшихся «безвходных» отработал скрытый флаг is_present = 1, маскируя технический сбой СКУД.

3. Техническое задание на исправление (Правила фикса)

Строгая валидация флага присутствия (Data Sanitization): Если time_in == 'Нет входа' и сотрудник отсутствует в static_reason_workers.csv (статичные удалёнщики/внештатники), код ЗАПРЕЩАЕТ автоматически проставлять is_present = 1, даже если выгрузка/агрегатор передает статус «Присутствовал».
Детектор аномалий и «Красный флаг» (Anomaly Detection): Если у человека time_in == 'Нет входа', но при этом есть дневные проходы в pLogData, система помечает его статусом: 🚨 АНОМАЛИЯ СКУД: Присутствие без утреннего входа (Зафиксирована активность в течение дня).
Группировка массовых сбоев: Если процент людей с подобной аномалией превышает 5% от штата, ИИ/модуль аналитики генерирует системный алерт: «Внимание! Зафиксирован массовый сбой регистраторов входа СКУД».
Параметризация MSSQL СКУД по времени (@CutoffDateTime): Добавить возможность делать срезы базы СКУД на конкретный час (например, 17:00), чтобы видеть честное состояние контроллеров и транзакций на выбранный момент времени:
```
DECLARE @CutoffDateTime DATETIME = '2026-08-04 17:00:00';
SELECT * FROM pLogData WHERE TimeVal <= @CutoffDateTime;

Хранение истории выгрузок (snapshot_time):
```

Запретить перезапись (REPLACE) локальной БД SQLite в рамках одного дня. Каждая выгрузка за день должна сохраняться с меткой времени snapshot_time, чтобы сохранять историю срезов (12:00, 17:00, 19:00).

Документ зафиксирован в рамках проекта scud_orion_ai_v2.


# File: ./scripts/__init__.py


# File: ./scripts/add_rule_ai.py

import sys import os

Добавляем корень проекта в путь поиска модулей Python

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(file))))

from core.database import get_connection

rule_text = ( "Сотрудники, присутствующие в 1С:ЗУП, но отсутствующие в СКУД Орион Pro, " "являются аномалией синхронизации профилей. ИИ должен запрашивать у СБ статус выдачи пропуска." )

with get_connection() as conn: cursor = conn.cursor() cursor.execute("INSERT OR IGNORE INTO ai_knowledge_base (rule_text) VALUES (?)", (rule_text,)) conn.commit()

print("✓ Правило успешно внесено в SQLite БД!")


# File: ./scripts/db_cli.py

import os import sys import argparse import sqlite3 import pandas as pd from datetime import datetime

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(file))))

from config import DATA_DIR, DATE_TODAY, OUTPUT_DIR from core.database import ( get_connection, get_available_snapshots, get_all_rules_from_db, load_scud_from_db_by_snapshot, get_latest_snapshot_time )

DB_PATH = os.path.join(DATA_DIR, "scud_orion_ai.db")

def print_stats(): """Выводит общую статистику по записям в таблицах БД.""" print("\n" + "=" * 60) print("📊 СТАТИСТИКА БАЗЫ ДАННЫХ SQLITE (scud_orion_ai.db):") print("=" * 60) with get_connection() as conn: cursor = conn.cursor() tables = ['scud_logs', 'zup_staff', 'zup_absences', 'anomalies_history', 'ai_knowledge_base'] for t in tables: cursor.execute(f"SELECT COUNT(*) FROM {t}") cnt = cursor.fetchone()[0] print(f" • Таблица [{t:<18}]: {cnt:>6} записей") print("=" * 60 + "\n")

def print_snapshots_list(date_str=None): """Выводит реестр снапшотов с отображением даты и точного времени среза.""" rows = get_available_snapshots(date_str)

print("\n" + "=" * 105)
print(f"📸 РЕЕСТР СОХРАНЕННЫХ СНАПШОТОВ (СВЕРХУ СВЕЖИЕ) {'ЗА ЛОГИ ' + date_str if date_str else ''}:")
print("=" * 105)

header = f"{'ID снапшота':<16} | {'Дата снапшота (создания)':<24} | {'Дата и время среза':<20} | {'Записей':<8}"
print(header)
print("-" * 105)

if not rows:
    print("Снапшотов пока нет.")
    print("=" * 105 + "\n")
    return

def snapshot_sort_key(row):
    snap_id = row[0] or ""
    snap_time = row[2] or ""
    
    seq_num = 0
    if "-" in snap_id:
        parts = snap_id.replace("Y", "").split("-")
        if len(parts) > 1 and parts[1].isdigit():
            seq_num = int(parts[1])
            
    return (snap_time, seq_num)

sorted_rows = sorted(rows, key=snapshot_sort_key, reverse=True)

for r in sorted_rows:
    snap_id = r[0] if r[0] else '----------'
    log_date = r[1] if r[1] else '—'
    snap_time = r[2] if r[2] else '—'
    count = r[3]

    # Извлекаем время (ЧЧ:ММ:СС) из snapshot_time, если оно есть
    time_part = "—"
    if snap_time and " " in snap_time:
        time_part = snap_time.split(" ")[1]

    slice_datetime_str = f"{log_date} {time_part}" if time_part != "—" else log_date

    if not snap_id.startswith("Y"):
        formatted_snap_id = f" {snap_id}"
    else:
        formatted_snap_id = snap_id
    
    print(f"{formatted_snap_id:<16} | {snap_time:<24} | {slice_datetime_str:<20} | {count:<8}")

print("=" * 105 + "\n")

def delete_snapshot_by_id(snapshot_id: str): """Удаляет конкретный снапшот из таблицы scud_logs по его ID.""" with get_connection() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM scud_logs WHERE snapshot_id = ?", (snapshot_id,)) deleted_count = cursor.rowcount conn.commit() print(f"\n[✓] Успешно удален снапшот [{snapshot_id}]. Удалено строк: {deleted_count}\n") return deleted_count

def delete_snapshots_by_date(date_str: str): """Удаляет все снапшоты за указанную дату (например, '04.08.2026').""" with get_connection() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM scud_logs WHERE log_date = ? OR snapshot_id LIKE ?", (date_str, f"%{date_str.replace('.', '')}%")) deleted_count = cursor.rowcount conn.commit() print(f"\n[✓] Успешно удалены все снапшоты за дату [{date_str}]. Удалено строк: {deleted_count}\n") return deleted_count

def inspect_scud(snapshot_id=None, date_str=None, export_xlsx=None): """Инспектирует логи СКУД за выбранный снапшот или дату и опционально сохраняет XLSX.""" target_date = date_str if date_str else DATE_TODAY

print("\n" + "=" * 90)
if snapshot_id:
    print(f"🔍 ИНСПЕКЦИЯ СКУД ПО СНАПШОТУ [{snapshot_id}] (Дата: {target_date}):")
else:
    print(f"🔍 ИНСПЕКЦИЯ СКУД ЗА ТЕКУЩУЮ ДАТУ [{target_date}] (ПОСЛЕДНИЙ СРЕЗ):")
print("=" * 90)

df = load_scud_from_db_by_snapshot(target_date, snapshot_param=snapshot_id)

if df.empty:
    print(f"Записи СКУД не найдены.")
    print("=" * 90 + "\n")
    return

total = len(df)
present_cnt = len(df[df['Пришел'] == True]) if 'Пришел' in df.columns else 0
absent_cnt = total - present_cnt

print(f"Всего записей: {total} | Пришли: {present_cnt} | Не пришли: {absent_cnt}")
print("-" * 90)

cols_to_show = ['fio', 'department', 'position', 'time_in', 'first_activity', 'time_out', 'is_present', 'anomaly_flag', 'snapshot_id']
existing_cols = [c for c in cols_to_show if c in df.columns]

print(df[existing_cols].head(30).to_string(index=False))
if len(df) > 30:
    print(f"\n... и ещё {len(df) - 30} строк.")

if export_xlsx:
    out_path = export_xlsx if export_xlsx.endswith('.xlsx') else f"{export_xlsx}.xlsx"
    if not os.path.isabs(out_path):
        out_path = os.path.join(OUTPUT_DIR, out_path)
    
    df.to_excel(out_path, index=False)
    print("\n" + "*" * 90)
    print(f"[✓] УСПЕШНЫЙ ЭКСПОРТ ДЕБАГ-ФАЙЛА В EXCEL: {out_path}")
    print("*" * 90)

print("=" * 90 + "\n")

def print_anomalies(): """Выводит список аномалий СКУД из БД.""" print("\n" + "=" * 80) print("🚨 ИСТОРИЯ НАЙДЕННЫХ АНОМАЛИЙ СКУД ⟷ 1С:") print("=" * 80) with get_connection() as conn: df = pd.read_sql_query("SELECT anomaly_date, fio, anomaly_type, details FROM anomalies_history ORDER BY id DESC LIMIT 50", conn) if df.empty: print("Аномалии не найдены.") else: print(df.to_string(index=False)) print("=" * 80 + "\n")

def print_rules(): """Выводит правила базы знаний ИИ.""" rules = get_all_rules_from_db() print("\n" + "=" * 80) print("🧠 ПРАВИЛА БАЗЫ ЗНАНИЙ ИИ:") print("=" * 80) if not rules: print("База знаний пуста.") else: for idx, r in enumerate(rules, 1): print(f" {idx}. {r}") print("=" * 80 + "\n")

def dump_all_to_excel(out_filename="db_dump_full.xlsx"): """Дампит всю базу SQLite во многостраничный Excel.""" out_path = os.path.join(OUTPUT_DIR, out_filename) print(f"\n[🔄] Создание полного дампа БД в файл: {out_path} ...") with get_connection() as conn, pd.ExcelWriter(out_path, engine='openpyxl') as writer: for table in ['scud_logs', 'zup_staff', 'zup_absences', 'anomalies_history', 'ai_knowledge_base']: df = pd.read_sql_query(f"SELECT * FROM {table}", conn) df.to_excel(writer, sheet_name=table[:31], index=False) print(f"[✓] Дамп успешно сохранен: {out_path}\n")

def print_system_prompts(): """Выводит все системные промпты из базы данных.""" print("\n" + "=" * 80) print("📝 СИСТЕМНЫЕ ПРОМПТЫ (system_prompts):") print("=" * 80) with get_connection() as conn: cursor = conn.cursor() cursor.execute("SELECT id, name, is_active, updated_at, prompt_text FROM system_prompts ORDER BY id DESC") rows = cursor.fetchall() if not rows: print("Таблица system_prompts пуста.") else: for r in rows: print(f"ID: {r[0]} | Name: {r[1]} | Active: {r[2]} | Updated: {r[3]}") print("-" * 80) print(f"{r[4]}\n") print("=" * 80 + "\n")

def print_session_states(): """Выводит текущие активные сессии и превью (session_states).""" print("\n" + "=" * 80) print("🔄 АКТИВНЫЕ СЕССИИ И ПРЕВЬЮ (session_states):") print("=" * 80) with get_connection() as conn: cursor = conn.cursor() cursor.execute("SELECT session_id, state_type, updated_at, pending_data FROM session_states") rows = cursor.fetchall() if not rows: print("Таблица session_states пуста (нет активных превью).") else: for r in rows: print(f"Session: {r[0]} | Type: {r[1]} | Updated: {r[2]}") print("-" * 80) print(f"Pending Data:\n{r[3]}\n") print("=" * 80 + "\n")

def main(): help_text = """ CLI-утилита инспекции и управления SQLite базой данных СКУД (scud_orion_ai.db)

ДОСТУПНЫЕ КОМАНДЫ: stats -- Общая статистика строк по всем таблицам БД snapshots [ДД.ММ.ГГГГ] -- Посмотреть список всех снапшотов (опционально за дату) scud [--snapshot ID] [--export-xlsx NAME] -- Инспекция логов СКУД и опциональный экспорт в Excel anomalies -- Посмотреть все найденные аномалии СКУД ⟷ 1С rules -- Посмотреть правила Базы Знаний ИИ из SQLite prompts -- Посмотреть системные промпты (system_prompts) sessions -- Посмотреть активные сессии и превью (session_states) dump [output.xlsx] -- Полный дамп всех таблиц БД в многостраничный Excel snapshot del [ID] или [--day ДД.ММ.ГГГГ] -- Удаление снапшотов по ID или за весь день

ПРИМЕРЫ ЗАПУСКА: python scripts/db_cli.py stats python scripts/db_cli.py prompts python scripts/db_cli.py sessions python scripts/db_cli.py snapshots 04.08.2026 python scripts/db_cli.py scud --snapshot Y20260805-007 --export-xlsx вчера_1 python scripts/db_cli.py snapshot del Y20260805-007 python scripts/db_cli.py snapshot del --day 04.08.2026 """ parser = argparse.ArgumentParser( description=help_text, formatter_class=argparse.RawDescriptionHelpFormatter, add_help=True ) parser.add_argument('command', nargs='?', default=None, choices=['stats', 'snapshots', 'scud', 'anomalies', 'rules', 'prompts', 'sessions', 'dump', 'snapshot'], help="Основная команда") parser.add_argument('action', nargs='?', default=None, help="Дополнительное действие (например, 'del')") parser.add_argument('param', nargs='?', default=None, help="Параметр (дата, ID снапшота или имя файла)") parser.add_argument('--snapshot', type=str, default=None, help="ID конкретного снапшота для инспекции") parser.add_argument('--export-xlsx', type=str, default=None, help="Экспорт среза СКУД в Excel-файл") parser.add_argument('--day', type=str, default=None, help="Удалить снапшоты за конкретный день (ДД.ММ.ГГГГ)")

# Если аргументы вообще не переданы, выводим статистику по умолчанию (или справку)
if len(sys.argv) == 1:
    print_stats()
    return

args = parser.parse_args()

# Валидация команд
if args.command == 'stats':
    print_stats()
elif args.command == 'snapshots':
    print_snapshots_list(date_str=args.param)
elif args.command == 'scud':
    inspect_scud(snapshot_id=args.snapshot, date_str=args.param, export_xlsx=args.export_xlsx)
elif args.command == 'anomalies':
    print_anomalies()
elif args.command == 'rules':
    print_rules()
elif args.command == 'prompts':
    print_system_prompts()
elif args.command == 'sessions':
    print_session_states()
elif args.command == 'dump':
    filename = args.param if args.param else "db_dump_full.xlsx"
    dump_all_to_excel(filename)
elif args.command == 'snapshot':
    if args.action == 'del':
        if args.day:
            delete_snapshots_by_date(args.day)
        elif args.param:
            delete_snapshot_by_id(args.param)
        else:
            print("\n[❌] Ошибка: Не указан ID снапшота или параметр --day для удаления.")
            print("Пример: python scripts/db_cli.py snapshot del Y20260805-007\n")
    else:
        print(f"\n[❌] Ошибка: Неизвестное действие '{args.action}' для команды snapshot.")
        print("Используйте: python scripts/db_cli.py snapshot del [ID или --day 'ДД.ММ.ГГГГ']\n")
else:
    print(f"\n[❌] Ошибка: Неизвестная команда.")
    parser.print_help()

if name == "main": main()


# File: ./scripts/fix_snapshots.py

import sqlite3 import os from datetime import datetime

DB_PATH = 'data/scud_orion_ai.db'

def parse_to_date(date_str): """Надежное преобразование даты логов и времени снапшота в объект date.""" if not date_str: return None date_str = str(date_str).split(" ")[0].strip() if "." in date_str: try: return datetime.strptime(date_str, "%d.%m.%Y").date() except ValueError: return None elif "-" in date_str: try: return datetime.strptime(date_str, "%Y-%m-%d").date() except ValueError: return None return None

def fix_snapshots(): """ Переиндексирует снапшоты в таблице scud_logs. Нумерация веников (001, 002, 003...) сквозная внутри каждого ДНЯ СОЗДАНИЯ. Префикс Y выставляется только если дата логов < даты создания. """ if not os.path.exists(DB_PATH): print(f"База данных {DB_PATH} не найдена.") return

conn = sqlite3.connect(DB_PATH)
cursor = conn.cursor()

# Группируем по уникальным выгрузкам
cursor.execute("""
    SELECT snapshot_time, log_date 
    FROM scud_logs 
    WHERE snapshot_time IS NOT NULL 
    GROUP BY snapshot_time, log_date 
    ORDER BY snapshot_time ASC, log_date ASC
""")
rows = cursor.fetchall()

if not rows:
    print("Снапшоты не найдены.")
    conn.close()
    return

print("=== ИСПРАВЛЕНИЕ СКВОЗНОЙ НУМЕРАЦИИ ВНУТРИ ДНЯ СОЗДАНИЯ ===")

# Счетчик текущего порядкового номера strictly за ДЕНЬ СОЗДАНИЯ (YYYYMMDD)
seq_counters = {}

for snap_time_raw, log_date_raw in rows:
    d_snap = parse_to_date(snap_time_raw)
    d_log = parse_to_date(log_date_raw)

    if not d_snap or not d_log:
        continue

    date_prefix = d_snap.strftime("%Y%m%d")

    # Если дата логов строго раньше даты создания снапшота — ставим Y
    is_yesterday = (d_log < d_snap)
    prefix = "Y" if is_yesterday else ""

    # Приращиваем сквозной счетчик за ЭТОТ ДЕНЬ СОЗДАНИЯ
    seq_counters[date_prefix] = seq_counters.get(date_prefix, 0) + 1
    seq_num = seq_counters[date_prefix]

    new_id = f"{prefix}{date_prefix}-{seq_num:03d}"

    cursor.execute(
        "UPDATE scud_logs SET snapshot_id = ? WHERE snapshot_time = ? AND log_date = ?",
        (new_id, snap_time_raw, log_date_raw)
    )
    print(f"  • Срез создания: {snap_time_raw} | Логи за: {log_date_raw} ===> Назначен ID: [{new_id}]")

conn.commit()
conn.close()
print("\n[✓] Переиндексация внутри дней создания успешно выполнена!")

if name == "main": fix_snapshots()


# File: ./services/__init__.py


# File: ./services/ai_verifier.py

import json import re import requests import pandas as pd from config import OLLAMA_URL, OLLAMA_MODEL from core.database import get_all_rules_from_db from core.database import get_department_synonyms_dict, add_department_synonym_to_db

def resolve_department_exception_ai(dept_1c, dept_scud, exception_departments): """ Универсальный сопоставитель отделов. Проверяет 1С, СКУД, локальную базу синонимов SQLite и задействует ИИ для сложных случайных аббревиатур. """ if not exception_departments: return False

d_1c = str(dept_1c).strip().lower() if dept_1c else ""
d_scud = str(dept_scud).strip().lower() if dept_scud else ""
exc_list = [d.strip().lower() for d in exception_departments]

# 1. Прямая проверка: если точное имя или подстрока уже совпали в 1С или СКУД
for exc in exc_list:
    if exc and (exc in d_1c or exc in d_scud or d_1c in exc or d_scud in exc):
        return True

# 2. Проверка по сохраненной Базе Знаний синонимов из SQLite
synonyms = get_department_synonyms_dict()
for exc in exc_list:
    # Если в БД зафиксировано: 'овк' -> 'отдел внутреннего контроля'
    full_from_db = synonyms.get(exc, "")
    if full_from_db and (full_from_db in d_1c or full_from_db in d_scud):
        return True

# 3. Умный ИИ-арбитраж (если отдел спорный и еще не сохранен в БД)
if d_1c or d_scud:
    dept_to_check = d_1c if d_1c else d_scud
    prompt = f"""

Ты — кадровый аналитик. Проверь, является ли отдел сотрудника "{dept_to_check}" тем же самым подразделением, что и один из отделов-исключений: {exception_departments}?

Примеры:

"Отдел внутреннего контроля" — это "ОВК" (Да)
"Отдел технического обеспечения" — это "ОТО" (Да)

Ответь СТРОГО в формате JSON: {{ "is_match": true/false, "matched_exception": "Название из списка исключений", "explanation": "краткое объяснение" }} """ try: raw_res = ask_ollama(prompt, system_prompt="Отвечай только валидным JSON.") match = re.search(r'{.*}', raw_res, re.DOTALL) if match: data = json.loads(match.group(0)) if data.get("is_match"): matched_exc = data.get("matched_exception", "").lower() # Запоминаем открытую ИИ связь в SQLite навсегда! add_department_synonym_to_db(matched_exc, dept_to_check) return True except Exception as e: print(f"[⚠️] Ошибка ИИ-арбитража отделов: {e}")

return False

def ask_ollama(prompt, system_prompt=None): """ Универсальная функция отправки запросов к локальной модели Ollama (Qwen 2.5). """ payload = { "model": OLLAMA_MODEL, "prompt": f"{system_prompt}\n\n{prompt}" if system_prompt else prompt, "stream": False }

try:
    response = requests.post(OLLAMA_URL, json=payload, timeout=120)
    if response.status_code == 200:
        data = response.json()
        if "response" in data:
            return data["response"].strip()
        elif "message" in data and "content" in data["message"]:
            return data["message"]["content"].strip()
        else:
            return f"⚠️ Неизвестная структура ответа Ollama: {data}"
    else:
        return f"⚠️ Ошибка Ollama (Код {response.status_code}): {response.text}"
except requests.exceptions.ConnectionError:
    return "⚠️ Не удалось подключиться к Ollama. Проверьте, запущен ли сервис (ollama run qwen2.5:14b)."
except Exception as e:
    return f"⚠️ Ошибка при обращении к Ollama: {e}"

def get_system_rules_context(): """ Загружает динамические системные правила компании напрямую из Базы Данных SQLite. """ rules = get_all_rules_from_db() if not rules: return "" rules_text = "\n".join([f"- {r}" for r in rules]) return f"\nОБЯЗАТЕЛЬНЫЕ ГЛОБАЛЬНЫЕ ПРАВИЛА И ПРИОРИТЕТЫ КОМПАНИИ (ИЗ SQLITE БД):\n{rules_text}\n"

def analyze_scud_mass_failure_ai(df_scud): """ Оценивает процент аномалий 'ANOMALY_NO_IN_HAS_ACTIVITY' в выгрузке. Если процент аномалий превышает 5% от смены или 10 человек, вызывает ИИ для генерации критического алерта. """ if df_scud is None or df_scud.empty: return None

total_records = len(df_scud)
anomaly_rows = df_scud[df_scud.get('anomaly_flag', 'NONE') == 'ANOMALY_NO_IN_HAS_ACTIVITY']
anomaly_count = len(anomaly_rows)

if total_records == 0:
    return None

anomaly_percent = round((anomaly_count / total_records) * 100, 1)

if anomaly_percent > 5.0 or anomaly_count >= 10:
    rules_context = get_system_rules_context()
    prompt = f"""

{rules_context} ВНИМАНИЕ! Проведён анализ смены СКУД:

Всего записей за смену: {total_records}
Выявлено сотрудников без утреннего входа, но с зафиксированной дневной активностью: {anomaly_count} ({anomaly_percent}% от смены)

Сформируй понятное предупреждение для Администратора СКУД и Руководителя. Объясни, что это критический массовый сбой турникетов/контроллеров входа на КПП, и порекомендуй действия. """ alert_text = ask_ollama(prompt, system_prompt="Ты — ИИ-аналитик контроллинга СКУД. Отвечай кратко и строго по делу.") return { "is_mass_failure": True, "anomaly_count": anomaly_count, "anomaly_percent": anomaly_percent, "alert_text": alert_text }

return {
    "is_mass_failure": False,
    "anomaly_count": anomaly_count,
    "anomaly_percent": anomaly_percent,
    "alert_text": "Массовых сбоев оборудования не зафиксировано."
}

def ai_verify_scud_against_staff(unrecognized_scud_fios, staff_fios): if not unrecognized_scud_fios or not staff_fios: return {}

# 🛡 Исключаем точные совпадения (чтобы ИИ не совершал ложных замен)
staff_fios_set = set(staff_fios)
real_unrecognized = [f for f in unrecognized_scud_fios if f not in staff_fios_set]

if not real_unrecognized:
    return {}

rules_context = get_system_rules_context()

prompt = f"""

Ты — кадровый аудитор безопасности СКУД. {rules_context} В СКУД записаны неопознанные ФИО: {json.dumps(unrecognized_scud_fios, ensure_ascii=False)} В официальном Штатном расписании 1С записаны ЭТАЛОНЫ: {json.dumps(staff_fios, ensure_ascii=False)}

СТРОГИЕ ПРАВИЛА:

Запись из Штат 1С — это 100% ПРАВИЛЬНЫЙ эталон.
В СКУД допущена опечатка.
Любое присутствие сотрудника по СКУД при наличии в 1С документа отсутствия (кроме командировок) является гарантированной аномалией.
В поле "warning" опиши обнаруженную опечатку.
Запрещено выдумывать опечатки и объединять разных людей/однофамильцев!

ОТВЕЧАЙ ТОЛЬКО ИСКЛЮЧИТЕЛЬНО В ФОРМАТЕ JSON!

Формат ответа: {{ "verified_matches": [ {{ "scud_fio": "ФИО из СКУД", "staff_fio": "эталон ФИО из Штат 1С", "warning": "Описание опечатки в СКУД или 'Точное совпадение (без опечаток)'" }} ] }} """ raw_response = ask_ollama( prompt, system_prompt="Ты — JSON API. Выдавай ТОЛЬКО валидный JSON без markdown-разметки." )

mapping = {}
try:
    match = re.search(r'\{.*\}', raw_response, re.DOTALL)
    if match:
        json_str = match.group(0)
        json_str = re.sub(r'\}\s*[^}\]]*$', '}', json_str)
        data = json.loads(json_str)
        for item in data.get("verified_matches", []):
            scud_f = item.get("scud_fio")
            staff_f = item.get("staff_fio")
            warn = item.get("warning", "Точное совпадение (без опечаток)")
            if scud_f and staff_f:
                mapping[scud_f] = {"staff_fio": staff_f, "warning": warn}
except Exception as e:
    print(f"[!] Ошибка разбора JSON от ИИ при сверке опечаток: {e}")

return mapping

def ai_verify_department_exceptions(unexplained_df, exception_departments): """ Локальный ИИ проверяет, не являются ли неотмеченные отделы синонимами отделов-исключений. """ if unexplained_df.empty or not exception_departments: return []

dept_list = unexplained_df['Подразделение'].dropna().unique().tolist()
rules_context = get_system_rules_context()

prompt = f"""

{rules_context} Ты — кадровый аудитор. Список отделов-исключений компании: {json.dumps(exception_departments, ensure_ascii=False)} Список отделов сотрудников, попавших в неизвестные: {json.dumps(dept_list, ensure_ascii=False)}

Определи, какие из отделов сотрудников являются ПОЛНЫМИ НАЗВАНИЯМИ или СИНУНИМАМИ отделов-исключений (например: 'Отдел внутреннего контроля' — это 'ОВК').

Выдай ответ строго в формате JSON: {{ "matched_departments": ["Название отдела 1", "Название отдела 2"] }} """ raw_response = ask_ollama(prompt, system_prompt="Выдавай только валидный JSON.")

try:
    match = re.search(r'\{.*\}', raw_response, re.DOTALL)
    if match:
        data = json.loads(match.group(0))
        return data.get("matched_departments", [])
except Exception as e:
    print(f"[⚠️] Ошибка ИИ-арбитража отделов: {e}")
    
return []


# File: ./services/data_loader.py

import os import pandas as pd import warnings from config import ( normalize_fio, clean_scud_fio_light, load_exceptions, DATE_TODAY, DATE_YESTERDAY, find_dated_file, ZUP_1C_DIR, SCUD_DIR )

Импортируем прямую SQL-выгрузку отсутствий из 1С

from services.zup_extractor import fetch_zup_absences_from_sql from core.database import load_scud_from_db_by_snapshot

warnings.filterwarnings('ignore', category=UserWarning, module='pandas')

def is_excluded(fio, dept, pos, exceptions): """Проверяет, входит ли сотрудник или должность в список исключений.""" fio_clean = normalize_fio(fio) dept_str = str(dept).strip().upper() if pd.notna(dept) else "" pos_str = str(pos).strip().lower() if pd.notna(pos) else ""

if fio_clean in exceptions["fio"] or dept_str in exceptions["departments"] or pos_str in exceptions["positions"]:
    return True
if any(keyword in pos_str for keyword in exceptions["position_keywords"]):
    return True
return False

def load_staff_data(date_str): """ Загружает файл Штатного расписания 1С за конкретную дату из папки 1c. """ filepath = find_dated_file("Штат", date_str) if not filepath: fallback_path = os.path.join(ZUP_1C_DIR, "штат.xlsx") if os.path.exists(fallback_path): filepath = fallback_path else: return None

try:
    df_raw = pd.read_excel(filepath, skiprows=8)
    
    # Индексы столбцов в файле 1С: 1 — ФИО, 5 — Подразделение, 12 — Должность
    df_staff = df_raw.iloc[:, [1, 5, 12]].copy()
    df_staff.columns = ['ФИО', 'Подразделение', 'Должность']
    
    df_staff = df_staff.dropna(subset=['ФИО']).reset_index(drop=True)
    df_staff = df_staff[~df_staff['ФИО'].astype(str).str.contains('Всего|Организация|Сотрудник|ФИО', case=False, na=False)]
    df_staff['fio_clean'] = df_staff['ФИО'].apply(normalize_fio)
    return df_staff
except Exception as e:
    print(f"[❌] Ошибка загрузки штата из {filepath}: {e}")
    return None

def load_absent_data(date_str): """ Загружает документально подтвержденные отсутствия сотрудников НАПРЯМУЮ из базы MS SQL 1С:ЗУП за указанную дату. """ try: df_absent = fetch_zup_absences_from_sql(date_str)

    if df_absent is not None and not df_absent.empty:
        df_absent = df_absent.dropna(subset=['ФИО', 'Вид_отсутствия'])
        df_absent = df_absent[~df_absent['ФИО'].astype(str).str.contains('АО "ЛЕНМОРНИИПРОЕКТ"|Сотрудник', case=False, na=False)]
        df_absent['fio_clean'] = df_absent['ФИО'].apply(normalize_fio)
        return df_absent[['fio_clean', 'Вид_отсутствия']].dropna(subset=['fio_clean'])
    else:
        return None
except Exception as e:
    print(f"[⚠️] Ошибка SQL-выгрузки отсутствий за {date_str}: {e}")
    return None

def process_scud_anomalies(df_scud, exceptions=None): """ Вычисляет 'Первую активность' и маркирует аномалии СКУД. Если 'Начало дня' == 'Нет входа', но есть любая физическая активность — записывает первейшее время в 'Первая_активность', сбрасывает 'Пришел' в False и выставляет флаг аномалии. """ if exceptions is None: exceptions = load_exceptions()

start_col = 'Начало_дня' if 'Начало_дня' in df_scud.columns else ('Начало дня' if 'Начало дня' in df_scud.columns else None)
end_col = 'Конец_дня' if 'Конец_дня' in df_scud.columns else ('Конец дня' if 'Конец дня' in df_scud.columns else None)
status_col = 'Статус' if 'Статус' in df_scud.columns else None

first_activities = []
anomaly_flags = []
is_present_flags = []

for _, row in df_scud.iterrows():
    fio = str(row.get('Сотрудник', row.get('fio_raw', ''))).strip()
    fio_clean = normalize_fio(fio)
    dept = str(row.get('Подразделение', '')).strip()
    pos = str(row.get('Должность', '')).strip()

    val_start = str(row.get(start_col, '')).strip() if start_col else ''
    val_end = str(row.get(end_col, '')).strip() if end_col else ''
    val_status = str(row.get(status_col, '')).strip().lower() if status_col else ''

    # Извлечение первого зафиксированного события из сырых логов (pLogData), если передавалось
    raw_first_event = row.get('raw_first_event', None)
    if pd.isna(raw_first_event) or str(raw_first_event).strip() in ['', 'None', 'nan', '00:00:00']:
        raw_first_event = None

    has_no_in = (val_start in ['нет входа', 'none', 'nan', '', '00:00:00', '00:00'])
    has_no_out = (val_end in ['нет выхода', 'none', 'nan', '', '00:00:00', '00:00'])

    first_act = '—'
    anom_flag = 'NONE'
    
    # Стандартная проверка присутствия
    is_present = not ('отсутствовал' in val_status or has_no_in)

    # ЛОГИКА ВЫЧИСЛЕНИЯ ПЕРВОЙ АКТИВНОСТИ И ДЕТЕКТИРОВАНИЯ АНОМАЛИИ
    if has_no_in:
        # Если нет входа, но есть проход внутри или зафиксирован выход
        if raw_first_event is not None or not has_no_out:
            first_act = str(raw_first_event) if raw_first_event else val_end
            anom_flag = 'ANOMALY_NO_IN_HAS_ACTIVITY'

            # ЖЕСТКАЯ ВАЛИДАЦИЯ: Если человек не исключен официально — сбрасываем фейковый Пришел = True
            if not is_excluded(fio, dept, pos, exceptions):
                is_present = False
        else:
            first_act = '—'
            is_present = False

    first_activities.append(first_act)
    anomaly_flags.append(anom_flag)
    is_present_flags.append(is_present)

df_scud['Первая_активность'] = first_activities
df_scud['anomaly_flag'] = anomaly_flags
df_scud['Пришел'] = is_present_flags

return df_scud

def load_scud_data(target_date_type="today", snapshot_param=None): """ Загружает логи СКУД за 'today' или 'yesterday' НАПРЯМУЮ из локальной базы SQLite. """ target_date = DATE_TODAY if target_date_type == "today" else DATE_YESTERDAY

# Загружаем данные строго из SQLite БД
df_scud = load_scud_from_db_by_snapshot(target_date, snapshot_param=snapshot_param)

if df_scud is None or df_scud.empty:
    # Fallback на случай отсутствия записей за вчера — пробуем взять за сегодня
    df_scud = load_scud_from_db_by_snapshot(DATE_TODAY, snapshot_param=snapshot_param)
    if df_scud is None or df_scud.empty:
        raise FileNotFoundError(f"В базе SQLite не найдены логи СКУД за {target_date}!")

exceptions = load_exceptions()

if 'fio_clean' not in df_scud.columns:
    fio_raw_col = 'fio' if 'fio' in df_scud.columns else ('Сотрудник' if 'Сотрудник' in df_scud.columns else df_scud.columns[0])
    df_scud['fio_raw'] = df_scud[fio_raw_col].astype(str)
    df_scud['fio_clean'] = df_scud['fio_raw'].apply(clean_scud_fio_light)

# Нормализация колонок под единый стандарт отчета
if 'Начало_дня' not in df_scud.columns and 'time_in' in df_scud.columns:
    df_scud['Начало_дня'] = df_scud['time_in']
if 'Конец_дня' not in df_scud.columns and 'time_out' in df_scud.columns:
    df_scud['Конец_дня'] = df_scud['time_out']
if 'Первая_активность' not in df_scud.columns and 'first_activity' in df_scud.columns:
    df_scud['Первая_активность'] = df_scud['first_activity']
if 'Пришел' not in df_scud.columns and 'is_present' in df_scud.columns:
    df_scud['Пришел'] = df_scud['is_present'].astype(bool)

df_scud['is_excluded'] = df_scud.apply(
    lambda r: is_excluded(r.get('fio', r.get('Сотрудник', '')), r.get('department', r.get('Подразделение', '')), r.get('position', r.get('Должность', '')), exceptions),
    axis=1
)
return df_scud

def load_all_data(): """ Загружает слитные датасеты за Сегодня и за Вчера напрямую из базы SQLite и 1С. """ df_scud_today = load_scud_data(target_date_type="today") try: df_scud_yesterday = load_scud_data(target_date_type="yesterday") except FileNotFoundError: df_scud_yesterday = df_scud_today.copy()

df_staff_today = load_staff_data(DATE_TODAY)
df_absent_today = load_absent_data(DATE_TODAY)

df_staff_yesterday = load_staff_data(DATE_YESTERDAY)
df_absent_yesterday = load_absent_data(DATE_YESTERDAY)

return (
    df_scud_today,
    df_scud_yesterday,
    df_staff_today,
    df_absent_today,
    df_staff_yesterday,
    df_absent_yesterday
)


# File: ./services/data_validator.py

import os import time from datetime import datetime from config import DATE_TODAY, DATE_YESTERDAY, find_dated_file, ZUP_1C_DIR, SCUD_DIR

def check_file_freshness(max_age_hours=24): """ Проверяет существование входных файлов 1С и СКУД. Возвращает флаги доступности файлов за Сегодня и Вчера. """ warnings = [] errors = []

# 1. Проверка файлов 1С за СЕГОДНЯ
staff_today = find_dated_file("Штат", DATE_TODAY)
absent_today = find_dated_file("Отсутствия", DATE_TODAY)
has_today_1c = bool(staff_today and absent_today)

if not has_today_1c:
    warnings.append(
        f"Файлы 1С за СЕГОДНЯ ({DATE_TODAY}) еще не выложены на сетевую шару. "
        f"Формирование Ежедневной сводки за сегодня будет временно пропущено."
    )

# 2. Проверка файлов 1С за ВЧЕРА (критически важны для детального отчета)
staff_yesterday = find_dated_file("Штат", DATE_YESTERDAY)
absent_yesterday = find_dated_file("Отсутствия", DATE_YESTERDAY)

if not staff_yesterday or not absent_yesterday:
    errors.append(
        f"Отсутствуют файлы 1С за ВЧЕРА ({DATE_YESTERDAY}) в папке {ZUP_1C_DIR}. "
        f"Невозможно построить детальный отчет за прошлую смену."
    )

# 3. Проверка файлов СКУД
scud_today = find_dated_file("Сотрудники", DATE_TODAY, search_dirs=[SCUD_DIR])
if not scud_today:
    warnings.append(f"Сегодняшний файл СКУД за {DATE_TODAY} еще не сформирован в {SCUD_DIR}")

is_valid = len(errors) == 0
return is_valid, warnings, errors, has_today_1c


# File: ./services/excel_exporter.py

import math import os import time import openpyxl import pandas as pd from datetime import datetime from openpyxl import Workbook from openpyxl.styles import Font, Alignment, PatternFill, Border, Side from openpyxl.utils import get_column_letter from config import OUTPUT_DIR

Словарь месяцев для текстового формата в названиях файлов

MONTHS_RU = { 1: "января", 2: "февраля", 3: "марта", 4: "апреля", 5: "мая", 6: "июня", 7: "июля", 8: "августа", 9: "сентября", 10: "октября", 11: "ноября", 12: "декабря" }

def format_date_ru(date_str): """Преобразует дату формата '27.07.2026' в '27 июля 2026'""" try: dt = datetime.strptime(date_str, "%d.%m.%Y") return f"{dt.day} {MONTHS_RU[dt.month]} {dt.year}" except Exception: return date_str

Границы ячеек

THIN_SIDE = Side(border_style="thin", color="D3D3D3") THIN_BORDER = Border(left=THIN_SIDE, right=THIN_SIDE, top=THIN_SIDE, bottom=THIN_SIDE)

Палитра заливки для Сводки

FILL_HEADER = PatternFill(start_color="D9E1F2", end_color="D9E1F2", fill_type="solid") FILL_TOTAL_LIST = PatternFill(start_color="F2F2F2", end_color="F2F2F2", fill_type="solid") FILL_UNEXPLAINED = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid") FILL_PRESENT = PatternFill(start_color="E2EFDA", end_color="E2EFDA", fill_type="solid") FILL_ANOMALY = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid") FILL_NO_PASS = PatternFill(start_color="E1F5FE", end_color="E1F5FE", fill_type="solid") # Мягкий пастельно-голубой для "Нет пропуска"

CATEGORY_PASTEL_COLORS = ["FFF2CC", "E1D5E7", "E1F5FE", "FFF0F5", "E8F8F5", "FCF3CF"]

Палитра для Детального отчета

YELLOW_FILL = PatternFill(start_color="FFF2CC", end_color="FFF2CC", fill_type="solid") # Обычные отсутствия LIGHT_RED_FILL = PatternFill(start_color="FCE4D6", end_color="FCE4D6", fill_type="solid") # Потенциальные прогулы GREEN_FILL = PatternFill(start_color="E2EFDA", end_color="E2EFDA", fill_type="solid") # Аномалии (пришел в отпуске) LIGHT_BLUE_FILL = PatternFill(start_color="E1F5FE", end_color="E1F5FE", fill_type="solid") # Бледно-голубой для "Нет пропуска"

def calculate_deviation(time_in_building_str, reason="", norm_hours=8, lunch_minutes=30): """Рассчитывает точное отклонение от нормы с учетом обеда 30 мин и уважительных причин""" if pd.notna(reason) and isinstance(reason, str) and reason.strip() != "": return "0:00"

if not isinstance(time_in_building_str, str) or time_in_building_str in ['00:00', '0', '', 'None', 'nan', 'NaN']:
    return f"-{norm_hours}:00"

try:
    parts = time_in_building_str.strip().split(':')
    hh = int(parts[0])
    mm = int(parts[1]) if len(parts) > 1 else 0
    total_in_building_minutes = hh * 60 + mm

    if total_in_building_minutes == 0:
        return f"-{norm_hours}:00"

    work_minutes = max(0, total_in_building_minutes - lunch_minutes)
    norm_minutes = norm_hours * 60
    diff = work_minutes - norm_minutes

    if diff == 0:
        return "0:00"

    sign = "-" if diff < 0 else ""
    abs_diff = abs(diff)
    res_hh = abs_diff // 60
    res_mm = abs_diff % 60

    return f"{sign}{res_hh}:{res_mm:02d}"
except Exception:
    return f"-{norm_hours}:00"

def apply_borders_to_cell(cell, border=THIN_BORDER): cell.border = border

def format_row_cells(ws, r_num, fill_obj, is_bold=False, align_b="right", bold_font=None, wrap_b=False): cell_a = ws.cell(row=r_num, column=1) cell_b = ws.cell(row=r_num, column=2) if fill_obj: cell_a.fill = fill_obj cell_b.fill = fill_obj apply_borders_to_cell(cell_a) apply_borders_to_cell(cell_b) if is_bold and bold_font: cell_a.font = bold_font cell_b.font = bold_font if align_b: cell_b.alignment = Alignment(horizontal=align_b, vertical="center", wrap_text=wrap_b)

--- 1. СВОДКА НА СЕГОДНЯ ---

def generate_summary_excel(merged_df, date_str="27.07.2026", filename=None): if not filename: filename = f"{format_date_ru(date_str)} сводка.xlsx"

output_path = os.path.join(OUTPUT_DIR, filename)
wb = Workbook()
ws = wb.active
ws.title = "Лист_1"

ws.sheet_properties.outlinePr.summaryBelow = False
ws.sheet_properties.outlinePr.summaryRight = False
ws.sheet_properties.outlinePr.showOutlineSymbols = True
ws.sheet_view.showOutlineSymbols = True

bold_font = Font(name="Calibri", size=11, bold=True)

# 1. Шапка
ws.cell(row=1, column=1, value="Сводка на")
ws.cell(row=1, column=2, value=date_str)
format_row_cells(ws, 1, FILL_HEADER, is_bold=True, bold_font=bold_font)

apply_borders_to_cell(ws.cell(row=2, column=1))
apply_borders_to_cell(ws.cell(row=2, column=2))

# 2. По списку
ws.cell(row=3, column=1, value="По списку")
ws.cell(row=3, column=2, value=len(merged_df))
format_row_cells(ws, 3, FILL_TOTAL_LIST, is_bold=True, bold_font=bold_font)

current_row = 4

# Подготовка флагов для точной фильтрации
is_no_pass = merged_df['no_scud_pass'] == True if 'no_scud_pass' in merged_df.columns else False
is_exc = merged_df.get('is_excluded', False) == True

# 3. НЕИЗВЕСТНО (Исключаем категорию "Нет пропуска" и "Исключения ОВК/Охрана")
unexplained = merged_df[
    (merged_df['Пришел'] == False) & 
    (merged_df['Вид_отсутствия'].isna() | (merged_df['Вид_отсутствия'].astype(str).str.strip() == '')) & 
    (~is_no_pass) & 
    (~is_exc)
]
ws.cell(row=current_row, column=1, value="неизвестно")
ws.cell(row=current_row, column=2, value=len(unexplained))
format_row_cells(ws, current_row, FILL_UNEXPLAINED, is_bold=True, bold_font=bold_font)
current_row += 1

for fio in sorted(unexplained['Сотрудник'].dropna().unique()):
    ws.cell(row=current_row, column=1, value=fio)
    format_row_cells(ws, current_row, FILL_UNEXPLAINED, is_bold=False)
    ws.row_dimensions[current_row].outlineLevel = 1
    ws.row_dimensions[current_row].hidden = False
    current_row += 1

# 4. РАЗДЕЛ: НЕТ ПРОПУСКА (Строго один независимый блок)
no_pass_df = merged_df[is_no_pass] if 'no_scud_pass' in merged_df.columns else pd.DataFrame()

ws.cell(row=current_row, column=1, value="Нет пропуска")
ws.cell(row=current_row, column=2, value=len(no_pass_df))
format_row_cells(ws, current_row, FILL_NO_PASS, is_bold=True, bold_font=bold_font)
current_row += 1

if not no_pass_df.empty:
    for fio in sorted(no_pass_df['Сотрудник'].dropna().unique()):
        ws.cell(row=current_row, column=1, value=fio)
        format_row_cells(ws, current_row, FILL_NO_PASS, is_bold=False)
        ws.row_dimensions[current_row].outlineLevel = 1
        ws.row_dimensions[current_row].hidden = False
        current_row += 1

# 5. КАТЕГОРИИ ОТСУТСТВИЙ (Свернуты hidden=True)
absent_only = merged_df[
    (merged_df['Пришел'] == False) & 
    (merged_df['Вид_отсутствия'].notna()) & 
    (~merged_df['Вид_отсутствия'].astype(str).str.startswith('Исключение'))
]
absent_groups = absent_only.groupby('Вид_отсутствия')

for idx_cat, (cat_name, group) in enumerate(absent_groups):
    hex_color = CATEGORY_PASTEL_COLORS[idx_cat % len(CATEGORY_PASTEL_COLORS)]
    cat_fill = PatternFill(start_color=hex_color, end_color=hex_color, fill_type="solid")

    ws.cell(row=current_row, column=1, value=cat_name)
    ws.cell(row=current_row, column=2, value=len(group))
    format_row_cells(ws, current_row, cat_fill, is_bold=True, bold_font=bold_font)
    current_row += 1

    for fio in sorted(group['Сотрудник'].dropna().unique()):
        ws.cell(row=current_row, column=1, value=fio)
        format_row_cells(ws, current_row, cat_fill, is_bold=False)
        ws.row_dimensions[current_row].outlineLevel = 1
        ws.row_dimensions[current_row].hidden = True
        current_row += 1

# 6. ИТОГО НА РАБОТЕ (Свернут hidden=True)
is_working_mask = (merged_df['Пришел'] == True) | (
    merged_df['Вид_отсутствия'].astype(str).str.lower().str.contains('командировк|удален|дистанцион|разъездн', regex=True, na=False)
)
present = merged_df[is_working_mask]

ws.cell(row=current_row, column=1, value="Итого на работе")
ws.cell(row=current_row, column=2, value=len(present))
format_row_cells(ws, current_row, FILL_PRESENT, is_bold=True, bold_font=bold_font)
current_row += 1

if not present.empty:
    for fio in sorted(present['Сотрудник'].dropna().unique()):
        ws.cell(row=current_row, column=1, value=fio)
        format_row_cells(ws, current_row, FILL_PRESENT, is_bold=False)
        ws.row_dimensions[current_row].outlineLevel = 1
        ws.row_dimensions[current_row].hidden = True
        current_row += 1

# 7. АНОМАЛИИ СКУД И 1С (ОВК и Подрядчики из исключений СУДА НЕ ПОПАДАЮТ)
anomalies = merged_df[
    (~is_exc) & (
        ((merged_df['Пришел'] == True) & (merged_df['Вид_отсутствия'].notna()) & (~merged_df['Вид_отсутствия'].astype(str).str.startswith('Исключение'))) |
        (merged_df.get('anomaly_flag', 'NONE') == 'ANOMALY_NO_IN_HAS_ACTIVITY')
    )
]

ws.cell(row=current_row, column=1, value="Аномалии СКУД и 1С")
ws.cell(row=current_row, column=2, value=len(anomalies))
format_row_cells(ws, current_row, FILL_ANOMALY, is_bold=True, bold_font=bold_font)
current_row += 1

chars_per_line_b = 30

if not anomalies.empty:
    for _, row in anomalies.iterrows():
        fio = row.get('Сотрудник', '')
        reason = row.get('Вид_отсутствия', '')
        anom_flag = row.get('anomaly_flag', 'NONE')

        if anom_flag == 'ANOMALY_NO_IN_HAS_ACTIVITY':
            first_act = row.get('Первая_активность', '—')
            reason_text = f"🚨 АНОМАЛИЯ СКУД: Нет входа (первая активность: {first_act})"
        else:
            reason_text = f"В 1С: {reason}"
        
        cell_a = ws.cell(row=current_row, column=1, value=f"{fio}")
        cell_b = ws.cell(row=current_row, column=2, value=reason_text)
        
        cell_a.fill = FILL_ANOMALY
        cell_b.fill = FILL_ANOMALY
        apply_borders_to_cell(cell_a)
        apply_borders_to_cell(cell_b)
        
        cell_b.alignment = Alignment(horizontal="left", vertical="center", wrap_text=True)
        cell_a.alignment = Alignment(horizontal="left", vertical="center")
        
        if len(reason_text) > chars_per_line_b:
            lines_count = math.ceil(len(reason_text) / chars_per_line_b)
            ws.row_dimensions[current_row].height = max(lines_count * 18, 22)
        else:
            ws.row_dimensions[current_row].height = 20

        ws.row_dimensions[current_row].outlineLevel = 1
        ws.row_dimensions[current_row].hidden = True
        current_row += 1

ws.column_dimensions['A'].width = 45.0
ws.column_dimensions['B'].width = 38.0

try:
    wb.save(output_path)
    print(f"[✓] Ежедневная сводка сохранена: {output_path}")
except PermissionError:
    alt_filename = filename.replace(".xlsx", f"_{int(time.time())}.xlsx")
    alt_path = os.path.join(OUTPUT_DIR, alt_filename)
    wb.save(alt_path)
    print(f"[⚠️] Файл открыт в Excel! Сохранено как: {alt_path}")

--- 2. ДЕТАЛЬНЫЙ ОТЧЕТ ЗА ВЧЕРА ---

def generate_detailed_excel(merged_df, date_str="26.07.2026", filename=None): if not filename: filename = f"{format_date_ru(date_str)} отчет.xlsx"

output_path = os.path.join(OUTPUT_DIR, filename)
wb = Workbook()
ws = wb.active
ws.title = "Детальный_отчет"

ws["B2"] = "Дата:"
ws["D2"] = date_str
ws["B2"].font = Font(name="Arial", size=10, bold=True)
ws["D2"].font = Font(name="Arial", size=10, bold=True)

headers = [
    "№", "ФИО", "Подразделение", "время входа", "первая активность", "время выхода",
    "находился в здании", "причина отсутствия", "норма", "отклонение от нормы"
]
ws.append([])
ws.append(headers)

header_fill = PatternFill(start_color="D9E1F2", end_color="D9E1F2", fill_type="solid")
for col_idx in range(1, len(headers) + 1):
    cell = ws.cell(row=4, column=col_idx)
    cell.fill = header_fill
    cell.font = Font(name="Arial", size=10, bold=True)
    cell.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
    apply_borders_to_cell(cell)

start_col = 'Начало дня' if 'Начало дня' in merged_df.columns else 'Начало_дня'
end_col = 'Конец дня' if 'Конец дня' in merged_df.columns else 'Конец_дня'
hours_col = 'Часы' if 'Часы' in merged_df.columns else 'Находился_в_здании'

chars_per_line_h = 24

for idx, row in merged_df.reset_index(drop=True).iterrows():
    is_present = row.get('Пришел', False)
    absence_reason = row.get('Вид_отсутствия', '')
    has_reason = pd.notna(absence_reason) and str(absence_reason).strip() != ''
    anom_flag = row.get('anomaly_flag', 'NONE')

    in_building_str = str(row.get(hours_col, '00:00'))
    first_act_val = str(row.get('Первая_активность', '—')).strip()
    has_first_act = first_act_val not in ['—', '', 'None', 'nan']

    dept_scud_val = row.get('department_scud', row.get('department', row.get('Подразделение', '')))
    deviation_val = calculate_deviation(in_building_str, reason=absence_reason if has_reason else "", norm_hours=8, lunch_minutes=30)

    ws.append([
        idx + 1,
        row.get('Сотрудник', ''),
        dept_scud_val,
        row.get(start_col, 'Нет входа'),
        first_act_val,
        row.get(end_col, 'Нет выхода'),
        in_building_str,
        absence_reason if has_reason else '',
        8,
        deviation_val
    ])
    
    row_num = 5 + idx
    
    # ЗАЛИВКА СТРОК:
    if is_present and has_reason:
        row_fill = GREEN_FILL
    elif not is_present and has_reason:
        row_fill = YELLOW_FILL
    elif not is_present and not has_reason and not has_first_act:
        # Розово-красный подсвечивает исключительно неизвестные случаи (потенциальные прогулы)
        row_fill = LIGHT_RED_FILL
    else:
        row_fill = None

    val_h_str = str(absence_reason) if has_reason else ""
    if len(val_h_str) > chars_per_line_h:
        needed_lines = math.ceil(len(val_h_str) / chars_per_line_h)
        ws.row_dimensions[row_num].height = max(needed_lines * 18, 22)
    else:
        ws.row_dimensions[row_num].height = 20

    for col_idx in range(1, len(headers) + 1):
        cell = ws.cell(row=row_num, column=col_idx)
        apply_borders_to_cell(cell)
        if row_fill:
            cell.fill = row_fill
        
        if col_idx == 8:
            cell.alignment = Alignment(horizontal="left", vertical="center", wrap_text=True)
        elif col_idx in [1, 4, 5, 6, 7, 9, 10]:
            cell.alignment = Alignment(horizontal="center", vertical="center")
        else:
            cell.alignment = Alignment(horizontal="left", vertical="center")

# Динамический компактный автоподгон ширины колонок
for col in ws.columns:
    col_letter = get_column_letter(col[0].column)
    max_len = 0
    for cell in col:
        if cell.value is not None:
            cell_lines = str(cell.value).split("\n")
            line_max = max(len(line) for line in cell_lines)
            if line_max > max_len:
                max_len = line_max

    optimal_width = max(max_len + 2, 8)
    if optimal_width > 35:
        optimal_width = 35
    ws.column_dimensions[col_letter].width = optimal_width

try:
    wb.save(output_path)
    print(f"[✓] Детальный отчет сохранен: {output_path}")
except PermissionError:
    alt_filename = filename.replace(".xlsx", f"_{int(time.time())}.xlsx")
    alt_path = os.path.join(OUTPUT_DIR, alt_filename)
    wb.save(alt_path)
    print(f"[⚠️] Файл открыт в Excel! Сохранено как: {alt_path}")

def export_raw_scud(df_scud, filename="СКУД_Сырые_данные.xlsx"): output_path = os.path.join(OUTPUT_DIR, filename) df_scud.to_excel(output_path, index=False)


# File: ./services/feedback_loop.py

import os import json from core.database import add_rule_to_db

try: from services.knowledge_base import save_rule except ImportError: try: from services.knowledge_base import add_rule as save_rule except ImportError: save_rule = None

def review_ai_decisions(report_text, suspicious_cases): """ Интерактивный консольный модуль обучения (Human-in-the-Loop). Запрашивает подтверждение оператора ТОЛЬКО по нетипичным/сложным случаям. """ if not suspicious_cases: print("\n[✓] Все аномалии валидированы автоматически. Спорных вопросов для оператора нет.") return

print("\n" + "=" * 60)
print("РЕЖИМ ОБУЧЕНИЯ И ПРОВЕРКИ РЕШЕНИЙ ИИ (HUMAN-IN-THE-LOOP)")
print("=" * 60)

for idx, case in enumerate(suspicious_cases, 1):
    fio_target = case.get('fio_target', 'Неизвестно')
    reason = case.get('reason', 'Нет описания')

    print(f"\n[?] Спорный случай {idx}/{len(suspicious_cases)}: {fio_target}")
    print(f"    Детали: {reason}")
    
    user_input = input("Подтверждаете аномалию? (д / да / н / нет / или введите текст правила): ").strip()
    user_input_clean = user_input.lower()

    # Расширенный список вариантов "ДА"
    if user_input_clean in ['д', 'да', 'da', 'yes', 'y', 'ок', 'ага', '+']:
        print("  [✓] Решение подтверждено оператором.")
    elif user_input_clean in ['н', 'нет', 'no', 'n', '-']:
        print("  [ℹ️] Решение отклонено оператором.")
    elif user_input:
        # Если оператор обучает систему синониму отделов
        if "отдел" in user_input_clean or "овк" in user_input_clean:
            from core.database import add_department_synonym_to_db
            add_department_synonym_to_db(user_input.strip(), "отдел внутреннего контроля")

        new_rule = f"Правило: {user_input}"
        add_rule_to_db(new_rule, added_by="Human_Admin")
        print(f"  [✓] Новое правило записано в Базу Знаний SQLite: {new_rule}")
    else:
        print("  [ℹ️] Запись пропущена.")

print("\n[✓] ЭТАП ОБУЧЕНИЯ ЗАВЕРШЕН.")


# File: ./services/knowledge_base.py

import os from core.database import get_all_rules_from_db, add_rule_to_db

def load_knowledge_base(): """ Загружает актуальные правила Базы Знаний компании напрямую из базы данных SQLite. """ rules = get_all_rules_from_db() return { "rules": rules if rules else [], "fio_corrections": {} }

def add_rule_to_kb(new_rule): """ Добавляет новое принятое человеком правило в SQLite таблицу ai_knowledge_base. """ if not new_rule or not new_rule.strip(): return add_rule_to_db(new_rule.strip(), added_by="Human") print(f"[✓] База знаний SQLite успешно обновлена! Новое правило: {new_rule.strip()}")


# File: ./services/scud_export.py

""" Модуль автоматического экспорта данных СКУД (Orion) из MS SQL Server в SQLite и Excel. Добавлена фиксация Первой Активности (без учета направления) и среза по времени. """

import argparse import logging import os import sys import warnings from datetime import datetime, timedelta

import pandas as pd import pyodbc from openpyxl.utils import get_column_letter

from config import SCUD_DIR, clean_scud_fio_light, load_exceptions from core.database import save_scud_to_db, has_scud_logs_for_date, has_yesterday_final_snapshot

warnings.filterwarnings("ignore", message="pandas only supports SQLAlchemy connectable")

SCRIPT_DIR = os.path.dirname(os.path.abspath(file)) LOG_DIR = os.path.join(SCRIPT_DIR, "..", "logs") os.makedirs(LOG_DIR, exist_ok=True)

TODAY_DATE_STR = datetime.now().strftime("%d.%m.%Y") LOG_FILE = os.path.join(LOG_DIR, f"export_{TODAY_DATE_STR}.log")

logger = logging.getLogger("scud_export") logger.setLevel(logging.INFO)

if not logger.handlers: _file_handler = logging.FileHandler(LOG_FILE, encoding="utf-8") _console_handler = logging.StreamHandler(sys.stdout) _formatter = logging.Formatter("[%(asctime)s] [%(levelname)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S") _file_handler.setFormatter(_formatter) _console_handler.setFormatter(_formatter) logger.addHandler(_file_handler) logger.addHandler(_console_handler)

def log(message: str, level: str = "INFO"): level_map = { "INFO": logging.INFO, "ERROR": logging.ERROR, "WARNING": logging.WARNING, "SUCCESS": logging.INFO, } if level == "SUCCESS": logger.info(f"[SUCCESS] {message}") else: logger.log(level_map.get(level, logging.INFO), message)

SERVER_NAME = r"172.16.31.221\SQL" DATABASE_NAME = "Orion-14.01.21-1" SQL_USER = "sa" SQL_PASSWORD = "123456" ODBC_DRIVER = "ODBC Driver 18 for SQL Server"

SQL_QUERY_TEMPLATE = r""" DECLARE @InputDate DATE = '{target_date}'; DECLARE @TargetDate DATE = @InputDate;

DECLARE @StartDate DATETIME = CAST(@TargetDate AS DATETIME); DECLARE @EndDate DATETIME = DATEADD(SECOND, -1, DATEADD(DAY, 1, @StartDate));

WITH DailyLogs AS ( SELECT log.HozOrgan AS EmployeeID, log.TimeVal, log.Event, log.Mode, CASE WHEN log.Mode = 2 OR log.Event IN (29, 27, 33) THEN 'OUT' WHEN log.Mode = 1 OR log.Event IN (28, 26, 32) THEN 'IN' ELSE 'OTHER' END AS Direction, ROW_NUMBER() OVER (PARTITION BY log.HozOrgan ORDER BY log.TimeVal DESC) AS RowNumDesc FROM pLogData log WITH (NOLOCK) WHERE log.TimeVal BETWEEN @StartDate AND @EndDate AND log.HozOrgan IS NOT NULL AND log.HozOrgan > 0 ), Passages AS ( SELECT EmployeeID, MIN(TimeVal) AS FirstRawEvent, MIN(CASE WHEN Direction = 'IN' THEN TimeVal END) AS FirstIn, MAX(CASE WHEN Direction = 'OUT' THEN TimeVal END) AS LastOut, MAX(CASE WHEN RowNumDesc = 1 THEN Direction END) AS LastEventType FROM DailyLogs GROUP BY EmployeeID ) SELECT N'ЛЕНМОРНИИПРОЕКТ' AS [Фирма], ISNULL(CAST(div.Name AS NVARCHAR(255)), N'Без подразделения') AS [Подразделение], LTRIM(RTRIM( ISNULL(CAST(p.Name AS NVARCHAR(255)), N'') + CASE WHEN p.FirstName IS NOT NULL AND CAST(p.FirstName AS NVARCHAR(255)) <> '' THEN N' ' + CAST(p.FirstName AS NVARCHAR(255)) ELSE N'' END + CASE WHEN p.MidName IS NOT NULL AND CAST(p.MidName AS NVARCHAR(255)) <> '' THEN N' ' + CAST(p.MidName AS NVARCHAR(255)) ELSE N'' END )) AS [Сотрудник], ISNULL(CAST(post.Name AS NVARCHAR(255)), N'—') AS [Должность], ISNULL(CAST(p.TabNumber AS NVARCHAR(50)), N'—') AS [Таб_№], CONVERT(VARCHAR(10), @TargetDate, 104) AS [Дата], ISNULL(CAST(CONVERT(VARCHAR(8), pass.FirstIn, 108) AS NVARCHAR(20)), N'Нет входа') AS [Начало_дня], CASE WHEN pass.FirstIn IS NULL AND pass.FirstRawEvent IS NOT NULL THEN CAST(CONVERT(VARCHAR(8), pass.FirstRawEvent, 108) AS NVARCHAR(20)) ELSE N'—' END AS [Первая_активность], CASE WHEN @TargetDate = CAST(GETDATE() AS DATE) AND (pass.LastEventType = 'IN' OR pass.LastOut IS NULL OR pass.LastOut <= pass.FirstIn) THEN N'Нет выхода' WHEN pass.LastOut IS NOT NULL AND pass.LastOut > pass.FirstIn THEN CAST(CONVERT(VARCHAR(8), pass.LastOut, 108) AS NVARCHAR(20)) ELSE N'Нет выхода' END AS [Конец_дня], CASE WHEN pass.EmployeeID IS NOT NULL AND pass.FirstIn IS NOT NULL THEN RIGHT('0' + CAST(DATEDIFF(MINUTE, pass.FirstIn, CASE WHEN @TargetDate = CAST(GETDATE() AS DATE) AND (pass.LastEventType = 'IN' OR pass.LastOut IS NULL OR pass.LastOut <= pass.FirstIn) THEN GETDATE() ELSE ISNULL(pass.LastOut, pass.FirstIn) END) / 60 AS VARCHAR), 2) + ':' + RIGHT('0' + CAST(DATEDIFF(MINUTE, pass.FirstIn, CASE WHEN @TargetDate = CAST(GETDATE() AS DATE) AND (pass.LastEventType = 'IN' OR pass.LastOut IS NULL OR pass.LastOut <= pass.FirstIn) THEN GETDATE() ELSE ISNULL(pass.LastOut, pass.FirstIn) END) % 60 AS VARCHAR), 2) ELSE N'00:00' END AS [Находился_в_здании], CASE WHEN pass.EmployeeID IS NOT NULL THEN N'Присутствовал' ELSE N'Отсутствовал (Нет событий)' END AS [Статус] FROM pList p WITH (NOLOCK) LEFT JOIN PDivision div WITH (NOLOCK) ON p.Section = div.ID LEFT JOIN PPost post WITH (NOLOCK) ON p.Post = post.ID LEFT JOIN Passages pass ON p.ID = pass.EmployeeID WHERE ISNULL(p.StatusRecord, 0) = 0 AND p.DateTimeInArchive IS NULL AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT LIKE N'Аренд%' AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT IN (N'Без подразделения', N'') AND p.Name NOT LIKE N'бр.%' AND p.Name NOT LIKE N'Гость%' AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT IN (N'БГИ', N'КНР') AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT LIKE N'Рабоч%' AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT LIKE N'Врем%' AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT LIKE N'Практика%' AND ISNULL(CAST(div.Name AS NVARCHAR(255)), N'') NOT LIKE N'тест%' AND ISNULL(CAST(post.Name AS NVARCHAR(255)), N'') NOT LIKE N'Практикант%' ORDER BY p.Name ASC; """

def auto_fit_columns(file_path: str, sheet_name: str, padding: float = 2.0, min_width: float = 8.0, max_width: float = 60.0): from openpyxl import load_workbook

wb = load_workbook(file_path)
ws = wb[sheet_name]

for col_cells in ws.columns:
    max_len = 0
    col_letter = get_column_letter(col_cells[0].column)
    for cell in col_cells:
        if cell.value is not None:
            cell_len = len(str(cell.value))
            if cell_len > max_len:
                max_len = cell_len
    width = max(min_width, min(max_len + padding, max_width))
    ws.column_dimensions[col_letter].width = width

wb.save(file_path)

def get_targets(input_date: str | None): targets = [] if input_date: try: parsed = datetime.strptime(input_date, "%d.%m.%Y").date() targets.append({"name": "Указанная дата", "date": parsed}) except ValueError: log(f"ОШИБКА: Неверный формат даты '{input_date}'. Используйте ДД.ММ.ГГГГ", "ERROR") sys.exit(1) else: now = datetime.now() yesterday = (now - timedelta(days=3 if now.weekday() == 0 else 1)).date() today = now.date()

    targets.append({"name": "Вчера", "date": yesterday})
    targets.append({"name": "Сегодня", "date": today})

return targets

def run_export(input_date: str | None = None, save_xlsx: bool = True, debug: bool = False): if debug: logger.setLevel(logging.DEBUG) log("=== ВКЛЮЧЕН РЕЖИМ ОТЛАДКИ (DEBUG MODE) ===", "WARNING")

log("=== [ЭТАП 0] Выгрузка свежих данных СКУД напрямую из БД Орион ===")
os.makedirs(SCUD_DIR, exist_ok=True)

targets = get_targets(input_date)
conn_str = (
    f"DRIVER={{{ODBC_DRIVER}}};"
    f"SERVER={SERVER_NAME};"
    f"DATABASE={DATABASE_NAME};"
    f"UID={SQL_USER};"
    f"PWD={SQL_PASSWORD};"
    f"TrustServerCertificate=yes;"
    f"Encrypt=no;"
)

success = True
for target in targets:
    processing_date = target["date"]
    processing_date_str = processing_date.strftime("%d.%m.%Y")
    period_label = target["name"]
    is_yesterday = (period_label == "Вчера")

    # ⚡️ ПРОВЕРКА НАЛИЧИЯ ВЧЕРАШНЕГО ДНЯ В SQLITE:
    # Если это вчерашний день и его снапшот уже зафиксирован в SQLite — пропускаем тяжелый запрос к MS SQL
    if is_yesterday and has_yesterday_final_snapshot(processing_date_str):
        log(f"[ℹ️] Вчерашний день ({processing_date_str}) уже зафиксирован финишным снапшотом Y. Пропускаем запрос к MS SQL.")
        continue

    if is_yesterday:
        snapshot_time = f"{processing_date.strftime('%Y-%m-%d')} 22:00:00"
    else:
        snapshot_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    log(f"--- Обработка периода: {period_label} ({processing_date_str}) --- [Снапшот: {snapshot_time}]")
    sql_query = SQL_QUERY_TEMPLATE.format(target_date=processing_date.strftime("%Y-%m-%d"))

    connection = None
    try:
        connection = pyodbc.connect(conn_str, timeout=120)
        df = pd.read_sql(sql_query, connection)

        log(f"База вернула {len(df)} строк за {processing_date_str}")

        if len(df) > 0:
            df['fio_clean'] = df['Сотрудник'].apply(clean_scud_fio_light)
            
            df['anomaly_flag'] = 'NONE'
            mask_anomaly = (df['Начало_дня'] == 'Нет входа') & (df['Первая_активность'] != '—')
            df.loc[mask_anomaly, 'anomaly_flag'] = 'ANOMALY_NO_IN_HAS_ACTIVITY'

            df['Пришел'] = df['Статус'].str.contains('Присутствовал', case=False, na=False) & (~mask_anomaly)

            save_scud_to_db(df, processing_date_str, snapshot_time=snapshot_time, is_yesterday=is_yesterday)
            log(f"[✓] Записи за {processing_date_str} успешно сохранены в SQLite!", "SUCCESS")

            if save_xlsx:
                file_name = f"Сотрудники_{processing_date_str}.xlsx"
                file_path = os.path.join(SCUD_DIR, file_name)

                if os.path.exists(file_path):
                    try:
                        os.remove(file_path)
                    except OSError as e:
                        log(f"ОШИБКА при удалении старого файла {file_name}: {e}", "ERROR")

                df.to_excel(file_path, sheet_name="Отчет", index=False, engine="openpyxl")
                auto_fit_columns(file_path, sheet_name="Отчет")
                log(f"[✓] Успешно экспортирован файл: data/scud/{file_name}", "SUCCESS")
        else:
            log(f"Запрос за {processing_date_str} вернул 0 строк.", "WARNING")

    except Exception as e:
        log(f"🛑 ОШИБКА выгрузки СКУД за {processing_date_str}: {e}", "ERROR")
        success = False
    finally:
        if connection is not None:
            connection.close()

log("=== Выгрузка СКУД завершена ===\n")
return success

if name == "main": help_text = """ Модуль прямого экспорта данных СКУД Орион Pro (MS SQL Server) в SQLite и Excel.

ПРИМЕРЫ ЗАПУСКА: python services/scud_export.py -- Автоматическая выгрузка за Сегодня и Вчера python services/scud_export.py --date 05.08.2026 -- Точечная выгрузка СКУД за конкретную дату python services/scud_export.py --no-xlsx -- Сохранение логов СКУД ТОЛЬКО в SQLite без дублирования в XLSX python services/scud_export.py -d -- Запуск в режиме отладки MS SQL запросов (DEBUG) """ parser = argparse.ArgumentParser( description=help_text, formatter_class=argparse.RawDescriptionHelpFormatter ) parser.add_argument("--date", dest="input_date", default=None, help="Дата выгрузки в формате ДД.ММ.ГГГГ (по умолчанию выгружаются Вчера и Сегодня)") parser.add_argument("-d", "--debug", action="store_true", help="Включить подробные логи отладки подключения и запросов к MS SQL") parser.add_argument("--no-xlsx", dest="save_xlsx", action="store_false", default=True, help="Отключить генерирование промежуточных XLSX-файлов в папке data/scud/") args = parser.parse_args()

run_export(args.input_date, save_xlsx=args.save_xlsx, debug=args.debug)


# File: ./services/share_copier.py

import os import shutil from config import DATE_TODAY, DATE_YESTERDAY, ZUP_1C_DIR, SHARE_1C_DIR

def find_file_strictly_on_share(prefix, date_str): """ Ищет файл со строгой привязкой ТОЛЬКО к сетевой шаре SHARE_1C_DIR, не обращаясь к локальным папкам. """ if not os.path.exists(SHARE_1C_DIR): return None

date_dots = date_str
date_underscores = date_str.replace('.', '_')

try:
    for f in os.listdir(SHARE_1C_DIR):
        if f.endswith('.xlsx') or f.endswith('.csv'):
            if f.lower().startswith(prefix.lower()):
                if date_dots in f or date_underscores in f:
                    return os.path.join(SHARE_1C_DIR, f)
except Exception as e:
    print(f"  [⚠️] Ошибка чтения сетевой шары: {e}")
return None

def copy_1c_files_from_share(): r""" Копирует свежие файлы 1С (Штат и Отсутствия) за Сегодня и Вчера из сетевой шары \storage\SCUD\Обмен\Штат в локальную папку data/1c/ """ print(f"[0.5/5] Проверка и копирование файлов 1С с шары: {SHARE_1C_DIR}...")

if not os.path.exists(SHARE_1C_DIR):
    print(f"[⚠️] Сетевой шар недоступен или путь не найден: {SHARE_1C_DIR}")
    print("     Используем ранее сохраненные локальные файлы из data/1c/\n")
    return False

dates_to_copy = [DATE_TODAY, DATE_YESTERDAY]
prefixes = ["Штат", "Отсутствия"]
copied_count = 0

os.makedirs(ZUP_1C_DIR, exist_ok=True)

for d_str in dates_to_copy:
    for prefix in prefixes:
        remote_file = find_file_strictly_on_share(prefix, d_str)

        if remote_file and os.path.exists(remote_file):
            filename = os.path.basename(remote_file)
            local_target_path = os.path.join(ZUP_1C_DIR, filename)

            try:
                shutil.copy2(remote_file, local_target_path)
                print(f"  [✓] Успешно скопирован с шары: {filename} -> data/1c/")
                copied_count += 1
            except Exception as e:
                print(f"  [⚠️] Ошибка копирования {filename}: {e}")
        else:
            d_fmt = d_str.replace('.', '_')
            print(f"  [ℹ️] На сетевой шаре отсутствует {prefix} за {d_str} ({prefix}_{d_fmt}.xlsx)")

if copied_count > 0:
    print(f"[✓] Успешно скопировано файлов с сетевой шары: {copied_count} шт.\n")
else:
    print("[ℹ️] Новых файлов за указанные даты на сетевой шаре не обнаружено.\n")

return True


# File: ./services/text_reporter.py

import json import difflib import re from services.ai_verifier import ask_ollama from services.knowledge_base import load_knowledge_base

def find_python_fuzzy_matches(unexplained_df, raw_absent_df): """ Точный поиск совпадений ФИО силами Python (без галлюцинаций ИИ). Сравнивает фамилию и полное имя с порогом сходства >= 0.75. """ if unexplained_df.empty or raw_absent_df is None or raw_absent_df.empty: return []

absent_dict = {}
for idx, r in raw_absent_df.iterrows():
    raw_fio = str(r.get('ФИО', ''))
    clean_fio = str(r.get('fio_clean', ''))
    reason = str(r.get('Вид_отсутствия', ''))
    if clean_fio and clean_fio not in ['Ао "Ленморниипроект"', 'Сотрудник', 'Nan', 'None']:
        absent_dict[clean_fio] = {'raw_fio': raw_fio, 'reason': reason}

matches = []
unexplained_fios = unexplained_df['fio_clean'].unique() if 'fio_clean' in unexplained_df.columns else []

for fio in unexplained_fios:
    fio_parts = fio.split()
    if not fio_parts:
        continue
    surname = fio_parts[0].lower()

    for abs_clean, abs_info in absent_dict.items():
        abs_parts = abs_clean.split()
        if not abs_parts:
            continue
        abs_surname = abs_parts[0].lower()

        if surname == abs_surname:
            ratio = difflib.SequenceMatcher(None, fio.lower(), abs_clean.lower()).ratio()
            if ratio >= 0.75:
                matches.append({
                    "target_fio": fio,
                    "found_in_1c_raw": abs_info['raw_fio'],
                    "reason_1c": abs_info['reason']
                })
                break

return matches

def generate_markdown_report(merged_df, absent_explained, absent_unexplained, scud_present_but_absent_in_1c, anomalies_list=None, raw_scud_df=None, raw_staff_df=None, raw_absent_df=None, date_str="05.08.2026"): # 1. Загрузка Базы Знаний kb = load_knowledge_base() custom_rules = kb.get("rules", []) custom_rules_str = "\n".join([f"- {r}" for r in custom_rules]) if custom_rules else "Специфических правил компании пока нет."

# 2. Предварительный расчет ключевых метрик (РЕШАЕТ NameError: total_staff)
total_staff = len(merged_df)
is_working_mask = (merged_df['Пришел'] == True) | (
    merged_df['Вид_отсутствия'].astype(str).str.lower().str.contains('командировк|удален|дистанцион|разъездн', regex=True, na=False)
)
present_cnt = len(merged_df[is_working_mask])
explained_cnt = len(absent_explained)
unexplained_cnt = len(absent_unexplained)
anomalies_cnt = len(anomalies_list) if anomalies_list else 0

# 3. Точный расчет неточных совпадений через Python
fio_mismatches_python = find_python_fuzzy_matches(absent_unexplained, raw_absent_df)

# 4. Формирование списка неизвестных с приоритетом аббревиатуры СКУД
unexplained_list = []
if not absent_unexplained.empty:
    for idx, r in absent_unexplained.iterrows():
        fio = r.get('Сотрудник', r.get('fio_clean', ''))
        
        dept_scud = str(r.get('department_scud', '')).strip()
        dept_1c = str(r.get('Подразделение', '')).strip()
        dept = dept_scud if (dept_scud and dept_scud.lower() != 'nan' and dept_scud != '—') else dept_1c
        if not dept:
            dept = '—'

        pos = r.get('Должность', '—')
        unexplained_list.append(f"{fio} — {dept}, {pos}")

# 5. Сборка промпта для Ollama
prompt = f"""

Ты — старший аудитор кадровой безопасности и контроллинга СКУД. Сформируй итоговую сводку кадрового контроля на {date_str}.

📌 БАЗА ЗНАНИЙ И ПРАВИЛА ПРЕДПРИЯТИЯ: {custom_rules_str}

🚨 ВХОДНЫЕ МЕТРИКИ:

Всего сотрудников: {total_staff}
Работают (офис / удаленка / командировки): {present_cnt}
Официально отсутствуют: {explained_cnt}
Неизвестно (истинно неотмеченные): {unexplained_cnt}
Выявлено аномалий/конфликтов реестров: {anomalies_cnt}

🚨 ПОДТВЕРЖДЁННЫЕ АНОМАЛИИ ({anomalies_cnt} шт): {json.dumps(anomalies_list, ensure_ascii=False, indent=2)}

⚠️ ПОДТВЕРЖДЁННЫЕ PYTHON ОШИБКИ СОПОСТАВЛЕНИЯ ФИО В 1С ({len(fio_mismatches_python)} шт): {json.dumps(fio_mismatches_python, ensure_ascii=False, indent=2)}

📊 СПИСОК НЕИЗВЕСТНЫХ СЛУЧАЕВ ({unexplained_cnt} чел): {json.dumps(unexplained_list, ensure_ascii=False, indent=2)}

СТРОГИЕ ИНСТРУКЦИИ ДЛЯ ИИ:

КАТЕГОРИЧЕСКИ ЗАПРЕЩЕНО придумывать несуществующие совпадения ФИО или приписывать суффиксы "(осн.)". Используй ТОЛЬКО массив ПОДТВЕРЖДЁННЫЕ PYTHON ОШИБКИ СОПОСТАВЛЕНИЯ ФИО. Если этот массив пуст, напиши в этом разделе: "Ошибок сопоставления ФИО и неточностей в 1С не обнаружено."
В разделе "Неизвестные случаи" выведи НУМЕРОВАННЫЙ СПИСОК всех {unexplained_cnt} человек ровно в том виде, в котором они переданы выше.
В разделе "Рекомендации" дай 2-3 конкретные системные рекомендации для кадровой службы. НЕ ПЕРЕЧИСЛЯЙ конкретные ФИО в тексте рекомендаций.

СТРОГИЙ ШАБЛОН ОТВЕТА:

Сводка контроллинга СКУД и 1С:ЗУП на {date_str}

Всего офисных сотрудников: {total_staff}
Работают (офис / удаленка / командировки): {present_cnt}
Официально отсутствуют: {explained_cnt}
Неизвестно (истинно неотмеченные): {unexplained_cnt} чел.
Выявлено аномалий/конфликтов реестров: {anomalies_cnt} шт.

🚨 Выявленные ИИ аномалии и конфликты источников ({anomalies_cnt}):

(Описание аномалий из anomalies_list. Если их нет — "Аномалий не обнаружено.")

⚠️ Подозрения на ошибки сопоставления ФИО и несоответствия 1С:

(Выведи данные ИСКЛЮЧИТЕЛЬНО из массива fio_mismatches_python. Если он пуст — "Ошибок сопоставления ФИО и неточностей в 1С не обнаружено.")

Неизвестные случаи: {unexplained_cnt}

(Выведи нумерованный список всех {unexplained_cnt} человек)

Точечные рекомендации:

(2-3 системные рекомендации без указания ФИО сотрудников) """

sys_prompt = "Ты — эксперт кадрового аудита. Будь точен, не придумывай непереданные данные."
return ask_ollama(prompt, system_prompt=sys_prompt)


# File: ./services/zup_extractor.py

import os import logging from datetime import date, datetime import pyodbc import pandas as pd from config import DATA_DIR, normalize_fio, ZUP_SQL_CONFIG

logger = logging.getLogger(name)

def get_zup_connection_string() -> str: """Формирует строку подключения pyodbc к MS SQL Server из config.py.""" return ( f"DRIVER={ZUP_SQL_CONFIG['driver']};" f"SERVER={ZUP_SQL_CONFIG['server']};" f"DATABASE={ZUP_SQL_CONFIG['database']};" f"UID={ZUP_SQL_CONFIG['user']};" f"PWD={ZUP_SQL_CONFIG['password']};" f"TrustServerCertificate={ZUP_SQL_CONFIG.get('trust_server_certificate', 'yes')};" f"Encrypt={ZUP_SQL_CONFIG.get('encrypt', 'no')};" )

def fetch_zup_absences_from_sql(target_date) -> pd.DataFrame: """ Извлекает оперативные отсутствия и действующие декреты из MS SQL 1С:ЗУП 3.1 на указанную дату (принимает как datetime.date, так и строку 'DD.MM.YYYY' / 'DD_MM_YYYY'). """ if isinstance(target_date, str): clean_date_str = target_date.replace('_', '.') try: target_date = datetime.strptime(clean_date_str, "%d.%m.%Y").date() except ValueError: logger.error(f"[❌] Неверный формат даты для SQL-запроса: {target_date}. Ожидался DD.MM.YYYY") return pd.DataFrame()

query = """
DECLARE @TargetDate DATE = ?;

-- 1. Оперативные отсутствия (Отпуска, Командировки, Больничные, Отгулы)
SELECT 
    LTRIM(RTRIM(ref_emp._Description)) AS [ФИО],
    CASE state._Fld16925RRef
        WHEN 0x9C10B2452D414FDF4A90E2B2AB81D3F7 THEN N'Отпуск основной'
        WHEN 0xBA63FCF94B4AD0664ED369D2E6505D67 THEN N'Командировка'
        WHEN 0x8C3B61F23954155A40EB0108FC0932DB THEN N'Болезнь'
        WHEN 0x853001C18D0965EE4B2702405C94054A THEN N'Отпуск неоплачиваемый по разрешению работодателя'
        WHEN 0xB7335AEFD8708C3E462861FC59489A38 THEN N'Отпуск по беременности и родам'
        ELSE N'Другое отсутствие'
    END AS [Вид_отсутствия]

FROM dbo._InfoRg16921 state WITH (NOLOCK)
INNER JOIN dbo._Reference299 ref_emp WITH (NOLOCK) 
    ON state._Fld16922RRef = ref_emp._IDRRef

WHERE @TargetDate BETWEEN CAST(CASE WHEN YEAR(state._Fld16926) > 3000 THEN DATEADD(YEAR, -2000, state._Fld16926) ELSE state._Fld16926 END AS DATE)
                      AND CAST(CASE WHEN YEAR(state._Fld16927) > 3000 THEN DATEADD(YEAR, -2000, state._Fld16927) ELSE state._Fld16927 END AS DATE)

UNION ALL

-- 2. Динамический выбор ДЕЙСТВУЮЩИХ декретниц по уходу за ребенком
SELECT 
    active_state.fio AS [ФИО],
    N'Отпуск по уходу за ребенком' AS [Вид_отсутствия]

FROM (
    SELECT 
        LTRIM(RTRIM(ref_emp._Description)) AS fio,
        all_states._Fld16925RRef AS state_guid,
        CAST(CASE WHEN YEAR(all_states._Fld16926) > 3000 THEN DATEADD(YEAR, -2000, all_states._Fld16926) ELSE all_states._Fld16926 END AS DATE) AS date_start,
        ROW_NUMBER() OVER (
            PARTITION BY all_states._Fld16922RRef 
            ORDER BY all_states._Fld16926 DESC
        ) AS rn
    FROM dbo._InfoRg16921 all_states WITH (NOLOCK)
    INNER JOIN dbo._Reference299 ref_emp WITH (NOLOCK) 
        ON all_states._Fld16922RRef = ref_emp._IDRRef
    WHERE CAST(CASE WHEN YEAR(all_states._Fld16926) > 3000 THEN DATEADD(YEAR, -2000, all_states._Fld16926) ELSE all_states._Fld16926 END AS DATE) <= @TargetDate
) active_state

WHERE active_state.rn = 1 
  AND active_state.state_guid = 0xA4FBA038663B3C2A48DA151C262855E1
  AND active_state.date_start >= DATEADD(YEAR, -3, @TargetDate)

ORDER BY [ФИО] ASC;
"""

try:
    conn_str = get_zup_connection_string()
    with pyodbc.connect(conn_str, timeout=5) as conn:
        df = pd.read_sql(query, conn, params=[target_date])
        
    if not df.empty:
        df['fio_clean'] = df['ФИО'].apply(normalize_fio)
    return df
except Exception as e:
    logger.error(f"[❌] Ошибка SQL-выгрузки отсутствий за {target_date}: {e}")
    return pd.DataFrame()

def fetch_zup_staff_from_sql() -> pd.DataFrame: """Резервная выгрузка штата из MS SQL.""" query = """ SELECT DISTINCT LTRIM(RTRIM(ref_emp._Description)) AS [ФИО], N'Организация' AS [Подразделение], N'Сотрудник' AS [Должность] FROM dbo._Reference299 ref_emp WITH (NOLOCK) WHERE ref_emp._Description <> '' AND ref_emp._Marked = 0x00 ORDER BY [ФИО] ASC; """ try: conn_str = get_zup_connection_string() with pyodbc.connect(conn_str, timeout=5) as conn: df = pd.read_sql(query, conn)

    if not df.empty:
        df['fio_clean'] = df['ФИО'].apply(normalize_fio)
    return df
except Exception as e:
    logger.error(f"[❌] Ошибка выгрузки штата из MS SQL: {e}")
    return pd.DataFrame()

def sync_zup_to_excel(target_date) -> bool: """Создает дамп в Excel при необходимости.""" try: if isinstance(target_date, str): clean_date_str = target_date.replace('_', '.') target_date_obj = datetime.strptime(clean_date_str, "%d.%m.%Y").date() else: target_date_obj = target_date

    date_str_file = target_date_obj.strftime("%d_%m_%Y")
    c_1c_dir = os.path.join(DATA_DIR, "1c")
    os.makedirs(c_1c_dir, exist_ok=True)

    df_staff = fetch_zup_staff_from_sql()
    df_absences = fetch_zup_absences_from_sql(target_date_obj)

    staff_excel_path = os.path.join(c_1c_dir, f"Штат_{date_str_file}.xlsx")
    absences_excel_path = os.path.join(c_1c_dir, f"Отсутствия_{date_str_file}.xlsx")

    with pd.ExcelWriter(staff_excel_path, engine='openpyxl') as writer:
        dummy_headers = pd.DataFrame([[""] * 13] * 8)
        dummy_headers.to_excel(writer, index=False, header=False)
        df_staff[['ФИО', 'Подразделение', 'Должность']].to_excel(writer, startrow=8, index=False)

    with pd.ExcelWriter(absences_excel_path, engine='openpyxl') as writer:
        dummy_headers = pd.DataFrame([[""] * 3] * 3)
        dummy_headers.to_excel(writer, index=False, header=False)
        df_absences[['ФИО', 'Вид_отсутствия']].to_excel(writer, startrow=3, index=False)

    return True

except Exception as e:
    logger.error(f"[❌] Ошибка прямого импорта из MS SQL 1С: {e}")
    return False


# File: ./api/__init__.py


# File: ./core/__init__.py


# File: ./core/database.py

import os import sqlite3 import json import pandas as pd from datetime import datetime from config import DATA_DIR

DB_PATH = os.path.join(DATA_DIR, "scud_orion_ai.db")

def get_connection(): """Создает подключение к базе данных SQLite с оптимизированными настройками.""" conn = sqlite3.connect(DB_PATH) conn.execute("PRAGMA foreign_keys = ON;") conn.execute("PRAGMA journal_mode = WAL;") return conn

def init_db(): """Создает структуру таблиц и индексов в базе данных.""" with get_connection() as conn: cursor = conn.cursor()

    cursor.execute("""
    CREATE TABLE IF NOT EXISTS scud_logs (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        log_date TEXT NOT NULL,
        fio TEXT NOT NULL,
        fio_clean TEXT NOT NULL,
        department TEXT,
        position TEXT,
        time_in TEXT,
        first_activity TEXT DEFAULT '—',
        time_out TEXT,
        time_in_building TEXT,
        is_present INTEGER NOT NULL,
        anomaly_flag TEXT DEFAULT 'NONE',
        snapshot_time TEXT DEFAULT NULL,
        snapshot_id TEXT DEFAULT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    """)

    cursor.execute("PRAGMA table_info(scud_logs);")
    cols = [col[1] for col in cursor.fetchall()]
    if 'snapshot_id' not in cols:
        cursor.execute("ALTER TABLE scud_logs ADD COLUMN snapshot_id TEXT DEFAULT NULL;")

    cursor.execute("""
    CREATE TABLE IF NOT EXISTS zup_staff (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        snapshot_date TEXT NOT NULL,
        fio TEXT NOT NULL,
        fio_clean TEXT NOT NULL,
        department TEXT,
        position TEXT,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    """)

    cursor.execute("""
    CREATE TABLE IF NOT EXISTS zup_absences (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        absence_date TEXT NOT NULL,
        fio TEXT NOT NULL,
        fio_clean TEXT NOT NULL,
        absence_type TEXT NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    """)

    cursor.execute("""
    CREATE TABLE IF NOT EXISTS anomalies_history (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        anomaly_date TEXT NOT NULL,
        fio TEXT NOT NULL,
        anomaly_type TEXT NOT NULL,
        details TEXT NOT NULL,
        human_status TEXT DEFAULT 'Pending',
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    """)

    cursor.execute("""
    CREATE TABLE IF NOT EXISTS ai_knowledge_base (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        rule_text TEXT UNIQUE NOT NULL,
        added_by TEXT DEFAULT 'Human',
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    """)

    cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_date ON scud_logs(log_date);")
    cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_fio ON scud_logs(fio_clean);")
    cursor.execute("CREATE INDEX IF NOT EXISTS idx_scud_snapshot ON scud_logs(snapshot_time);")

    conn.commit()

sync_knowledge_base_to_db()

def has_scud_logs_for_date(date_str): """Проверяет, есть ли в базе данные СКУД за указанную дату.""" with get_connection() as conn: cursor = conn.cursor() cursor.execute("SELECT 1 FROM scud_logs WHERE log_date = ? LIMIT 1", (date_str,)) return cursor.fetchone() is not None

def has_yesterday_final_snapshot(date_str): """Проверяет, зафиксирован ли уже ИТОГОВЫЙ вчерашний снапшот с индексом Y/22:00.""" with get_connection() as conn: cursor = conn.cursor() cursor.execute( "SELECT 1 FROM scud_logs WHERE log_date = ? AND (snapshot_id LIKE 'Y%' OR snapshot_time LIKE '%22:00:00') LIMIT 1", (date_str,) ) return cursor.fetchone() is not None

def get_or_create_snapshot_id(snapshot_time, date_str=None, is_yesterday=False): """ Генерирует датированный составной ID снапшота (YYYYMMDD-NNN или YYYYMMDD-NNN). Префикс 'Y' присваивается автоматически, если дата логов (date_str) предшествует дате снятия (snapshot_time). """ try: dt_snap = datetime.strptime(snapshot_time, "%Y-%m-%d %H:%M:%S").date() date_prefix = dt_snap.strftime("%Y%m%d") except (ValueError, TypeError): dt_snap = datetime.now().date() date_prefix = dt_snap.strftime("%Y%m%d")

# Автоматическая проверка: если дата логов раньше даты выгрузки — проставляем Y
if date_str:
    try:
        dt_log = datetime.strptime(date_str, "%d.%m.%Y").date()
        if dt_log < dt_snap:
            is_yesterday = True
    except Exception:
        pass

prefix = "Y" if is_yesterday else ""

with get_connection() as conn:
    cursor = conn.cursor()

    if date_str:
        cursor.execute(
            "SELECT snapshot_id FROM scud_logs WHERE log_date = ? AND snapshot_time = ? AND snapshot_id IS NOT NULL LIMIT 1",
            (date_str, snapshot_time)
        )
    else:
        cursor.execute(
            "SELECT snapshot_id FROM scud_logs WHERE snapshot_time = ? AND snapshot_id IS NOT NULL LIMIT 1",
            (snapshot_time,)
        )

    row = cursor.fetchone()
    if row and row[0]:
        return row[0]

    cursor.execute("""
        SELECT snapshot_id 
        FROM scud_logs 
        WHERE snapshot_id LIKE ? OR snapshot_id LIKE ?
        ORDER BY snapshot_id DESC LIMIT 1
    """, (f"{date_prefix}-%", f"Y{date_prefix}-%"))

    last_row = cursor.fetchone()
    next_seq = 1

    if last_row and last_row[0]:
        parts = last_row[0].replace("Y", "").split("-")
        if len(parts) > 1 and parts[1].isdigit():
            next_seq = int(parts[1]) + 1

    return f"{prefix}{date_prefix}-{next_seq:03d}"

def save_scud_to_db(df_scud, date_str, snapshot_time=None, is_yesterday=False): """Сохраняет логи СКУД с автоматическим присвоением составного snapshot_id.""" if df_scud is None or df_scud.empty: return

if not snapshot_time:
    snapshot_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# Передаем date_str в генератор snapshot_id
snapshot_id = get_or_create_snapshot_id(snapshot_time, date_str=date_str, is_yesterday=is_yesterday)

data_to_insert = []
for _, r in df_scud.iterrows():
    data_to_insert.append((
        date_str,
        r.get('Сотрудник', r.get('fio_raw', '')),
        r.get('fio_clean', ''),
        r.get('Подразделение', ''),
        r.get('Должность', ''),
        r.get('Начало_дня', 'Нет входа'),
        r.get('Первая_активность', '—'),
        r.get('Конец_дня', 'Нет выхода'),
        r.get('Находился_в_здании', '00:00'),
        1 if r.get('Пришел', False) else 0,
        r.get('anomaly_flag', 'NONE'),
        snapshot_time,
        snapshot_id
    ))

with get_connection() as conn:
    cursor = conn.cursor()
    cursor.execute("DELETE FROM scud_logs WHERE log_date = ? AND snapshot_time = ?", (date_str, snapshot_time))
    cursor.executemany("""
        INSERT INTO scud_logs (
            log_date, fio, fio_clean, department, position, 
            time_in, first_activity, time_out, time_in_building, 
            is_present, anomaly_flag, snapshot_time, snapshot_id
        )
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    """, data_to_insert)
    conn.commit()

def get_latest_snapshot_time(date_str=None): with get_connection() as conn: cursor = conn.cursor() if date_str: cursor.execute("SELECT snapshot_time FROM scud_logs WHERE log_date = ? AND snapshot_time IS NOT NULL ORDER BY snapshot_time DESC LIMIT 1", (date_str,)) else: cursor.execute("SELECT snapshot_time FROM scud_logs WHERE snapshot_time IS NOT NULL ORDER BY snapshot_time DESC LIMIT 1") row = cursor.fetchone() return row[0] if row else None

def load_scud_from_db_by_snapshot(date_str, snapshot_param=None): """ Загружает логи СКУД по ID снапшота ('20260805-001', 'Y20260805-001') или по штампу времени. С автоматическим маппингом полей Подразделения и Должности. """ with get_connection() as conn: df = pd.DataFrame()

    if snapshot_param:
        if "-" in str(snapshot_param) or str(snapshot_param).startswith('Y'):
            df = pd.read_sql_query(
                "SELECT * FROM scud_logs WHERE log_date = ? AND snapshot_id = ?", 
                conn, params=(date_str, str(snapshot_param))
            )
            if df.empty:
                df = pd.read_sql_query(
                    "SELECT * FROM scud_logs WHERE snapshot_id = ?", 
                    conn, params=(str(snapshot_param),)
                )

        if df.empty:
            df = pd.read_sql_query(
                "SELECT * FROM scud_logs WHERE log_date = ? AND snapshot_time = ?", 
                conn, params=(date_str, str(snapshot_param))
            )

    if df.empty:
        latest_time = get_latest_snapshot_time(date_str)
        if latest_time:
            df = pd.read_sql_query(
                "SELECT * FROM scud_logs WHERE log_date = ? AND snapshot_time = ?", 
                conn, params=(date_str, latest_time)
            )

    if not df.empty:
        df['Сотрудник'] = df['fio']
        df['Пришел'] = df['is_present'].astype(int) == 1 if 'is_present' in df.columns else False
        df['Начало_дня'] = df['time_in']
        df['Первая_активность'] = df['first_activity']
        df['Конец_дня'] = df['time_out']
        df['Находился_в_здании'] = df['time_in_building']
        
        # 💡 Маппинг колонок БД в стандартные русские наименования
        if 'department' in df.columns and 'Подразделение' not in df.columns:
            df['Подразделение'] = df['department']
        if 'position' in df.columns and 'Должность' not in df.columns:
            df['Должность'] = df['position']
    else:
        df = pd.DataFrame(columns=[
            'Сотрудник', 'fio_clean', 'Подразделение', 'Должность', 
            'Начало_дня', 'Первая_активность', 'Конец_дня', 
            'Находился_в_здании', 'Пришел', 'anomaly_flag'
        ])

    return df

def get_available_snapshots(date_str=None): """ Возвращает список снапшотов. Сортировка по времени snapshot_time DESC. """ with get_connection() as conn: cursor = conn.cursor() if date_str: cursor.execute(""" SELECT snapshot_id, log_date, snapshot_time, COUNT() as cnt FROM scud_logs WHERE log_date = ? AND snapshot_time IS NOT NULL GROUP BY snapshot_id, log_date, snapshot_time ORDER BY snapshot_time DESC """, (date_str,)) else: cursor.execute(""" SELECT snapshot_id, log_date, snapshot_time, COUNT() as cnt FROM scud_logs WHERE snapshot_time IS NOT NULL GROUP BY snapshot_id, log_date, snapshot_time ORDER BY snapshot_time DESC """) return cursor.fetchall()

def save_staff_to_db(df_staff, date_str): if df_staff is None or df_staff.empty: return data_to_insert = [ (date_str, r.get('ФИО', ''), r.get('fio_clean', ''), r.get('Подразделение', ''), r.get('Должность', '')) for _, r in df_staff.iterrows() ] with get_connection() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM zup_staff WHERE snapshot_date = ?", (date_str,)) cursor.executemany("INSERT INTO zup_staff (snapshot_date, fio, fio_clean, department, position) VALUES (?, ?, ?, ?, ?)", data_to_insert) conn.commit()

def save_absences_to_db(df_absent, date_str): if df_absent is None or df_absent.empty: return data_to_insert = [ (date_str, r.get('ФИО', r.get('fio_clean', '')), r.get('fio_clean', ''), r.get('Вид_отсутствия', '')) for _, r in df_absent.iterrows() ] with get_connection() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM zup_absences WHERE absence_date = ?", (date_str,)) cursor.executemany("INSERT INTO zup_absences (absence_date, fio, fio_clean, absence_type) VALUES (?, ?, ?, ?)", data_to_insert) conn.commit()

def save_anomalies_to_db(anomalies_list, date_str): if not anomalies_list: return data_to_insert = [ (date_str, a.get('fio', ''), a.get('type', ''), a.get('details', '')) for a in anomalies_list ] with get_connection() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM anomalies_history WHERE anomaly_date = ?", (date_str,)) cursor.executemany("INSERT INTO anomalies_history (anomaly_date, fio, anomaly_type, details) VALUES (?, ?, ?, ?)", data_to_insert) conn.commit()

def get_all_rules_from_db(): with get_connection() as conn: cursor = conn.cursor() cursor.execute("SELECT rule_text FROM ai_knowledge_base") return [r[0] for r in cursor.fetchall()]

def add_rule_to_db(rule_text, added_by="Human"): if not rule_text or not rule_text.strip(): return with get_connection() as conn: cursor = conn.cursor() try: cursor.execute("INSERT OR IGNORE INTO ai_knowledge_base (rule_text, added_by) VALUES (?, ?)", (rule_text.strip(), added_by)) conn.commit() except Exception as e: print(f"[⚠️] Ошибка записи правила в БД: {e}")

def sync_knowledge_base_to_db(): pass

def delete_snapshot_by_id(snapshot_id: str): """Удаляет конкретный снапшот из таблицы scud_logs по его ID.""" with get_connection() as conn: cursor = conn.cursor() cursor.execute("DELETE FROM scud_logs WHERE snapshot_id = ?", (snapshot_id,)) deleted_count = cursor.rowcount conn.commit() print(f"[✓] Удален снапшот [{snapshot_id}]. Удалено строк: {deleted_count}") return deleted_count

def delete_snapshots_by_date(date_str: str): """Удаляет все снапшоты за указанную дату (например, '04.08.2026').""" with get_connection() as conn: cursor = conn.cursor() # Удаляем по log_date или по дате внутри snapshot_id cursor.execute("DELETE FROM scud_logs WHERE log_date = ? OR snapshot_id LIKE ?", (date_str, f"%{date_str.replace('.', '')}%")) deleted_count = cursor.rowcount conn.commit() print(f"[✓] Удалены все снапшоты за дату [{date_str}]. Удалено строк: {deleted_count}") return deleted_count def init_department_synonyms_db(): """Создает таблицу синонимов отделов в БД SQLite.""" with get_connection() as conn: cursor = conn.cursor() cursor.execute(""" CREATE TABLE IF NOT EXISTS department_synonyms ( id INTEGER PRIMARY KEY AUTOINCREMENT, short_name TEXT UNIQUE NOT NULL, full_name TEXT NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); """) # По умолчанию добавляем ОВК -> Отдел внутреннего контроля cursor.execute(""" INSERT OR IGNORE INTO department_synonyms (short_name, full_name) VALUES ('овк', 'отдел внутреннего контроля') """) conn.commit()

def get_department_synonyms_dict(): """Возвращает словарь всех изученных синонимов {short_name: full_name}.""" init_department_synonyms_db() with get_connection() as conn: cursor = conn.cursor() cursor.execute("SELECT LOWER(short_name), LOWER(full_name) FROM department_synonyms") return {row[0]: row[1] for row in cursor.fetchall()}

def add_department_synonym_to_db(short_name, full_name): """Сохраняет новую пару синонимов отдела в базу SQLite.""" init_department_synonyms_db() with get_connection() as conn: cursor = conn.cursor() cursor.execute( "INSERT OR REPLACE INTO department_synonyms (short_name, full_name) VALUES (?, ?)", (short_name.strip().lower(), full_name.strip().lower()) ) conn.commit() print(f"[✓] В базу SQLite добавлен новый синоним отдела: '{short_name}' ⟷ '{full_name}'")


# File: ./modules/__init__.py


# File: ./HOWTO/работа с кодом.md

🛠 HOWTO: Правила внесения изменений и передачи кода в проекте

📌 Зачем это нужно

Проект scud_orion_ai_v2 активно растет (17+ модулей, СУБД SQLite, ИИ-контур). Передача полных файлов кода при каждой мелкой правке сжигает окно контекста LLM, замедляет диалог и приводит к потере ранее внесенных архитектурных фич.

🎯 Правила для разработчика и ИИ

1. Формат передачи изменений

При запросах и ответах используются точечные фрагменты кода (Diff-стиль) с указанием привязок.

Любой фрагмент должен содержать:

Точный путь к файлу (services/excel_exporter.py).
Имя целевой функции/класса (generate_summary_excel).
Зацепку (Context Anchor) — уникальную соседнюю строку или блок try/except.

📐 Шаблоны фрагментов

Вариант А: Замена существующей логики

Файл: services/excel_exporter.py
Функция: generate_summary_excel()
Место: Строка ~150, блок фильтрации no_pass_df

❌ Удалить:
no_pass_df = merged_df[merged_df.get('no_scud_pass', False) == True]
✅ Вставить:
if 'no_scud_pass' in merged_df.columns:
    no_pass_df = merged_df[merged_df['no_scud_pass'] == True]
else:
    no_pass_df = pd.DataFrame()

Вариант Б: Вставка нового условия/блока

Файл: main.py
Функция: detect_all_anomalies()
Место: После цикла for idx, row in merged_df.iterrows():

➕ Вставить код:
# ИСКЛЮЧЕНИЯ без документов 1С НЕ пропускаются дальше к аномалиям СКУД
if is_exc and not has_1c_reason:
    continue

Вариант В: Git Unified Diff Format

Файл: services/data_loader.py

@@ def process_scud_anomalies(df_scud, exceptions=None): @@
-  first_act = '—'
+  # Сохраняем вычисленную ранее активность из БД/файла
+  first_act = existing_fa if existing_fa not in ['—', '', 'None'] else '—'

🚀 Чек-лист перед запуском

Проверить синтаксис через python -m py_compile <файл.py>.
Запустить скрипт с флагом отладки python main.py -d.
Убедиться, что снапшот записан в SQLite (python scripts/db_cli.py snapshots).

194 KiB Raw Blame History Unescape Escape