Обновить dags/poruchitelstva.py

dags/poruchitelstva.py

@@ -32,96 +32,194 @@ def get_db_engine():
         max_overflow=20
     )
     
-def update_pogasheniya_structure_with_detailed_errors(**kwargs):
+def update_poruchitelstva_structure_with_detailed_errors(**kwargs):
     """
-    Версия с подробными сообщениями об ошибках
+    Версия с подробными сообщениями об ошибках для поручительств
     """
     engine = get_db_engine()
     
-    # Шаг 1: Проверяем существование функции get_years()
+    # Шаг 1: Проверяем данные в таблице sigma_gk
     try:
         with engine.connect() as conn:
-            # Проверяем, существует ли функция
+            # Проверяем существование таблицы sigma_gk
-            func_exists = conn.execute("""
-                SELECT EXISTS(
-                    SELECT 1 FROM pg_proc 
-                    JOIN pg_namespace ON pg_proc.pronamespace = pg_namespace.oid 
-                    WHERE proname = 'get_years' 
-                    AND nspname = 'public'
-                )
-            """).scalar()
-            
-            if not func_exists:
-                return "ERROR: Функция get_years() не существует в схеме public"
-            
-            # Проверяем существование таблицы years_for_pogasheniya
             table_exists = conn.execute("""
                 SELECT EXISTS(
                     SELECT 1 FROM information_schema.tables 
-                    WHERE table_name = 'years_for_pogasheniya' 
+                    WHERE table_name = 'sigma_gk' 
                     AND table_schema = 'public'
                 )
             """).scalar()
             
             if not table_exists:
-                return "ERROR: Таблица years_for_pogasheniya не существует"
+                return "ERROR: Таблица sigma_gk не существует"
             
-            # Проверяем, есть ли данные в таблице
+            # Проверяем, есть ли данные в таблице sigma_gk
             has_data = conn.execute("""
-                SELECT EXISTS(SELECT 1 FROM years_for_pogasheniya LIMIT 1)
+                SELECT EXISTS(SELECT 1 FROM sigma_gk LIMIT 1)
             """).scalar()
             
             if not has_data:
-                return "ERROR: Таблица years_for_pogasheniya пустая"
+                return "ERROR: Таблица sigma_gk пустая"
             
-            # Вызываем функцию get_years()
+            # Проверяем структуру таблицы sigma_gk
-            result = conn.execute("SELECT * FROM get_years()").fetchone()
+            columns_check = conn.execute("""
+                SELECT 
+                    COUNT(CASE WHEN column_name = 'poruchitel_name' THEN 1 END) as has_poruchitel_name,
+                    COUNT(CASE WHEN column_name = 'is_active' THEN 1 END) as has_is_active
+                FROM information_schema.columns 
+                WHERE table_name = 'sigma_gk' 
+                  AND table_schema = 'public'
+            """).fetchone()
             
-            if result is None:
+            has_poruchitel_name, has_is_active = columns_check
-                return "ERROR: Функция get_years() вернула NULL. Проверьте данные в таблице"
             
-            start_year, end_year = result
+            if not has_poruchitel_name:
+                return "ERROR: В таблице sigma_gk отсутствует колонка 'poruchitel_name'"
+            if not has_is_active:
+                return "ERROR: В таблице sigma_gk отсутствует колонка 'is_active'"
             
-            # Детальная проверка значений
+            # Проверяем, есть ли активные компании
-            error_messages = []
+            active_companies_count = conn.execute("""
+                SELECT COUNT(DISTINCT poruchitel_name)
+                FROM sigma_gk 
+                WHERE is_active = '1' 
+                  AND poruchitel_name IS NOT NULL 
+                  AND poruchitel_name != ''
+            """).scalar()
             
-            if start_year is None:
+            if active_companies_count == 0:
-                error_messages.append("start_year is NULL")
+                # Проверяем, есть ли вообще данные в колонке poruchitel_name
-            if end_year is None:
+                any_companies = conn.execute("""
-                error_messages.append("end_year is NULL")
+                    SELECT COUNT(DISTINCT poruchitel_name)
+                    FROM sigma_gk 
+                    WHERE poruchitel_name IS NOT NULL 
+                      AND poruchitel_name != ''
+                """).scalar()
                 
-            if error_messages:
+                if any_companies == 0:
-                return f"ERROR: {', '.join(error_messages)}"
+                    return "ERROR: В таблице sigma_gk нет данных в колонке poruchitel_name"
+                else:
+                    return "ERROR: В таблице sigma_gk нет активных компаний (is_active = '1')"
             
-            # Преобразуем в числа с проверкой
+            # Получаем список активных компаний для информации
-            try:
+            active_companies = conn.execute("""
-                start_year_int = int(start_year)
+                SELECT DISTINCT poruchitel_name
-                end_year_int = int(end_year)
+                FROM sigma_gk 
-            except ValueError:
+                WHERE is_active = '1' 
-                return f"ERROR: Невозможно преобразовать годы в числа: start_year='{start_year}', end_year='{end_year}'"
+                  AND poruchitel_name IS NOT NULL 
+                  AND poruchitel_name != ''
+                ORDER BY poruchitel_name
+                LIMIT 10
+            """).fetchall()
             
-            if start_year_int > end_year_int:
+            companies_list = [row[0] for row in active_companies]
-                return f"ERROR: Неправильный порядок лет: start_year ({start_year}) > end_year ({end_year})"
             
     except Exception as e:
-        return f"ERROR: Ошибка при проверке данных: {str(e)}"
+        return f"ERROR: Ошибка при проверке таблицы sigma_gk: {str(e)}"
     
-    # Шаг 2: Обновляем структуру
+    # Шаг 2: Проверяем существование необходимых функций
+    try:
+        with engine.connect() as conn:
+            # Проверяем существование функции update_poruchitelstva_system
+            func_exists = conn.execute("""
+                SELECT EXISTS(
+                    SELECT 1 FROM pg_proc 
+                    JOIN pg_namespace ON pg_proc.pronamespace = pg_namespace.oid 
+                    WHERE proname = 'update_poruchitelstva_system' 
+                    AND nspname = 'public'
+                )
+            """).scalar()
+            
+            if not func_exists:
+                return "ERROR: Функция update_poruchitelstva_system() не существует"
+            
+            # Проверяем существование функции rebuild_poruchitelstva_table
+            func_exists = conn.execute("""
+                SELECT EXISTS(
+                    SELECT 1 FROM pg_proc 
+                    JOIN pg_namespace ON pg_proc.pronamespace = pg_namespace.oid 
+                    WHERE proname = 'rebuild_poruchitelstva_table' 
+                    AND nspname = 'public'
+                )
+            """).scalar()
+            
+            if not func_exists:
+                return "ERROR: Функция rebuild_poruchitelstva_table() не существует"
+            
+            # Проверяем существование таблицы poruchitelstva
+            table_exists = conn.execute("""
+                SELECT EXISTS(
+                    SELECT 1 FROM information_schema.tables 
+                    WHERE table_name = 'poruchitelstva' 
+                    AND table_schema = 'public'
+                )
+            """).scalar()
+            
+            if not table_exists:
+                print("WARNING: Таблица poruchitelstva не существует, будет создана")
+            
+    except Exception as e:
+        return f"ERROR: Ошибка при проверке функций: {str(e)}"
+    
+    # Шаг 3: Обновляем систему поручительств
     try:
         with engine.begin() as conn:
+            # Сначала обновляем конфигурацию компаний
             update_result = conn.execute(
-                "SELECT update_years_and_rebuild(%s, %s)",
+                "SELECT update_poruchitelstva_system()"
-                (str(start_year), str(end_year))
             ).scalar()
             
-            return f"SUCCESS: {update_result}"
+            if not update_result:
+                return "ERROR: Функция update_poruchitelstva_system() вернула пустой результат"
+            
+            # Затем пересоздаем таблицу
+            conn.execute("SELECT rebuild_poruchitelstva_table()")
+            
+            # Проверяем результат
+            check_result = conn.execute("""
+                SELECT 
+                    (SELECT COUNT(*) FROM poruchitelstva) as main_table_count,
+                    (SELECT COUNT(*) FROM poruchitelstva_normalized) as normalized_count,
+                    (SELECT COUNT(DISTINCT column_name) - 7 
+                     FROM information_schema.columns 
+                     WHERE table_name = 'poruchitelstva' 
+                       AND table_schema = 'public') as company_columns_count
+            """).fetchone()
+            
+            main_count, normalized_count, company_cols = check_result
+            
+            result_message = (
+                f"SUCCESS: Система поручительств обновлена.\n"
+                f"• Активных компаний: {active_companies_count}\n"
+                f"• Пример компаний: {', '.join(companies_list[:3])}{'...' if len(companies_list) > 3 else ''}\n"
+                f"• Записей в основной таблице: {main_count or 0}\n"
+                f"• Записей в нормализованной таблице: {normalized_count or 0}\n"
+                f"• Колонок компаний в таблице: {company_cols or 0}"
+            )
+            
+            if normalized_count == 0:
+                result_message += "\nWARNING: Нормализованная таблица пуста. Возможно, нет данных о поручительствах."
+            
+            return result_message
             
     except Exception as e:
-        return f"ERROR: Ошибка при пересоздании таблицы: {str(e)}"
+        error_msg = str(e)
+        
+        # Проверяем, есть ли конкретные ошибки
+        if "duplicate key" in error_msg.lower():
+            return f"ERROR: Обнаружены дубликаты ключей. {error_msg}"
+        elif "unique constraint" in error_msg.lower():
+            return f"ERROR: Нарушение уникальности. {error_msg}"
+        elif "ambiguous column" in error_msg.lower():
+            return f"ERROR: Неоднозначное имя колонки. {error_msg}"
+        elif "function does not exist" in error_msg.lower():
+            return f"ERROR: Отсутствует необходимая функция. {error_msg}"
+        else:
+            return f"ERROR: Ошибка при обновлении системы поручительств: {error_msg}"
 
 
 with DAG(
-    dag_id='update_pogasheniya',
+    dag_id='update_poruchitelstva',
     default_args=default_args,
     description='Обновление списка погашений',
     schedule_interval=None,
@@ -129,10 +227,10 @@ with DAG(
     tags=['sigma'],
 ) as dag:
 
-    pogasheniya_task = PythonOperator(
+    poruchitelstva_task = PythonOperator(
-        task_id='update_pogasheniya_structure_with_detailed_errors',
+        task_id='update_poruchitelstva_structure_with_detailed_errors',
-        python_callable=update_pogasheniya_structure_with_detailed_errors,
+        python_callable=update_poruchitelstva_structure_with_detailed_errors,
         provide_context=True
     )
 
-pogasheniya_task
+poruchitelstva_task