added test logs to land tax

taxes_az/taxes_az/doctype/land_tax_declaration/land_tax_declaration.py

@@ -10,13 +10,13 @@ class Landtaxdeclaration(Document):
 def get_doctype_fields_info():
     """Gets information about fields of əlavə_1 table and Asset"""
     
-    frappe.log_error("Начало получения метаданных полей", "Fields Info Start")
+    frappe.log_error("Fields Info Start", "Начало получения метаданных полей")
     
     result = {}
     
     try:
         # Get metadata for əlavə_1 table
-        frappe.log_error("Получение метаданных для Land tax declaration Elave 1", "Elave1 Metadata")
+        frappe.log_error("Elave1 Metadata", "Получение метаданных для Land tax declaration Elave 1")
         elave1_meta = frappe.get_meta('Land tax declaration Elave 1')
         result['elave1_fields'] = []
         
@@ -31,10 +31,10 @@ def get_doctype_fields_info():
             }
             result['elave1_fields'].append(field_info)
         
-        frappe.log_error(f"Найдено полей в Elave 1: {len(result['elave1_fields'])}", "Elave1 Fields Count")
+        frappe.log_error("Elave1 Fields Count", f"Найдено полей в Elave 1: {len(result['elave1_fields'])}")
         
         # Get metadata for əlavə_2 table
-        frappe.log_error("Получение метаданных для Land tax declaration Elave 2", "Elave2 Metadata")
+        frappe.log_error("Elave2 Metadata", "Получение метаданных для Land tax declaration Elave 2")
         elave2_meta = frappe.get_meta('Land tax declaration Elave 2')
         result['elave2_fields'] = []
         
@@ -49,10 +49,10 @@ def get_doctype_fields_info():
             }
             result['elave2_fields'].append(field_info)
         
-        frappe.log_error(f"Найдено полей в Elave 2: {len(result['elave2_fields'])}", "Elave2 Fields Count")
+        frappe.log_error("Elave2 Fields Count", f"Найдено полей в Elave 2: {len(result['elave2_fields'])}")
         
         # Get metadata for Asset
-        frappe.log_error("Получение метаданных для Asset", "Asset Metadata")
+        frappe.log_error("Asset Metadata", "Получение метаданных для Asset")
         asset_meta = frappe.get_meta('Asset')
         result['asset_fields'] = []
         
@@ -67,13 +67,13 @@ def get_doctype_fields_info():
             }
             result['asset_fields'].append(field_info)
         
-        frappe.log_error(f"Найдено полей в Asset: {len(result['asset_fields'])}", "Asset Fields Count")
-        frappe.log_error("Метаданные успешно получены", "Fields Info Success")
+        frappe.log_error("Asset Fields Count", f"Найдено полей в Asset: {len(result['asset_fields'])}")
+        frappe.log_error("Fields Info Success", "Метаданные успешно получены")
         
         return result
         
     except Exception as e:
-        frappe.log_error(f"Ошибка в get_doctype_fields_info: {str(e)}\n{frappe.get_traceback()}", "Fields Info Error")
+        frappe.log_error("Fields Info Error", f"Ошибка в get_doctype_fields_info: {str(e)}\n{frappe.get_traceback()}")
         return {'error': str(e)}
 
 # ===============================
@@ -93,30 +93,24 @@ def calculate_agricultural_tax(hectare, cadastral_district_name, quality_groups,
         f"  - quality_groups: {quality_groups}\n"
         f"  - agricultural_land_purpose: {agricultural_land_purpose}"
     )
-    frappe.log_error(params_info, "Agri Tax Calc Start")
+    frappe.log_error("Agri Tax Start", params_info)
     
     try:
         # Input validation
         if not hectare or not cadastral_district_name or not quality_groups or not agricultural_land_purpose:
             error_msg = "Не все поля заполнены для расчета"
-            frappe.log_error(error_msg, "Agri Tax Validation")
+            frappe.log_error("Agri Tax Valid", error_msg)
             frappe.throw(error_msg)
         
         # Get score from JSON file
-        frappe.log_error(
-            f"Получение балла для района '{cadastral_district_name}', группа '{quality_groups}'",
-            "Get Cadastral Score"
-        )
+        frappe.log_error("Get Cadastral", f"Получение балла для района '{cadastral_district_name}', группа '{quality_groups}'")
         score = get_cadastral_score(cadastral_district_name, quality_groups)
-        frappe.log_error(f"Получен балл: {score}", "Score Retrieved")
+        frappe.log_error("Score Retrieved", f"Получен балл: {score}")
         
         # Determine markup
-        frappe.log_error(
-            f"Получение коэффициента для назначения '{agricultural_land_purpose}'",
-            "Get Markup Coeff"
-        )
+        frappe.log_error("Get Markup", f"Получение коэффициента для назначения '{agricultural_land_purpose}'")
         markup = get_markup_coefficient(agricultural_land_purpose)
-        frappe.log_error(f"Получен коэффициент: {markup}", "Markup Retrieved")
+        frappe.log_error("Markup Retrieved", f"Получен коэффициент: {markup}")
         
         # Calculate using formula
         result = float(hectare) * score * markup
@@ -126,7 +120,7 @@ def calculate_agricultural_tax(hectare, cadastral_district_name, quality_groups,
             f"Формула: {hectare} × {score} × {markup} = {result}\n"
             f"Результат: {result} манат"
         )
-        frappe.log_error(calc_summary, "Agri Tax Calc Done")
+        frappe.log_error("Agri Tax Done", calc_summary)
         
         return {
             'tax_amount': result,
@@ -139,7 +133,7 @@ def calculate_agricultural_tax(hectare, cadastral_district_name, quality_groups,
         }
         
     except Exception as e:
-        frappe.log_error(f"Ошибка: {str(e)}\n{frappe.get_traceback()}", "Agri Tax Calc Error")
+        frappe.log_error("Agri Tax Error", f"Ошибка: {str(e)}\n{frappe.get_traceback()}")
         frappe.throw(f"Ошибка при расчете: {str(e)}")
 
 def get_cadastral_score(cadastral_district_name, quality_group):
@@ -151,24 +145,24 @@ def get_cadastral_score(cadastral_district_name, quality_group):
         f"Район: {cadastral_district_name}\n"
         f"Группа качества: {quality_group}"
     )
-    frappe.log_error(search_info, "Cadastral Score Search")
+    frappe.log_error("Cadastral Search", search_info)
     
     try:
         # Path to JSON file
         json_file_path = frappe.get_app_path('taxes_az', 'data', 'cadastral_points_data.json')
-        frappe.log_error(f"Путь к JSON: {json_file_path}", "JSON Path")
+        frappe.log_error("JSON Path", f"Путь к JSON: {json_file_path}")
         
         # Read JSON file
         with open(json_file_path, 'r', encoding='utf-8') as file:
             data = json.load(file)
         
         regions_count = len(data.get('cadastral_regions', []))
-        frappe.log_error(f"JSON загружен, регионов: {regions_count}", "JSON Loaded")
+        frappe.log_error("JSON Loaded", f"JSON загружен, регионов: {regions_count}")
         
         # Find corresponding region
         for region in data.get('cadastral_regions', []):
             if region.get('region_name') == cadastral_district_name:
-                frappe.log_error(f"Регион найден: {cadastral_district_name}", "Region Found")
+                frappe.log_error("Region Found", f"Регион найден: {cadastral_district_name}")
                 
                 # Get score for specified quality group
                 quality_groups = region.get('quality_groups', {})
@@ -178,32 +172,32 @@ def get_cadastral_score(cadastral_district_name, quality_group):
                     f"Группы качества в регионе: {list(quality_groups.keys())}\n"
                     f"Балл для группы '{quality_group}': {score}"
                 )
-                frappe.log_error(score_info, "Score Found")
+                frappe.log_error("Score Found", score_info)
                 
                 # If score is null or not found, return 0
                 return score if score is not None else 0
         
         # If region not found
         error_msg = f"Кадастровый район '{cadastral_district_name}' не найден в базе данных"
-        frappe.log_error(error_msg, "Region Not Found")
+        frappe.log_error("Region Not Found", error_msg)
         frappe.throw(error_msg)
         
     except FileNotFoundError:
         error_msg = f"Файл не найден: {json_file_path}"
-        frappe.log_error(error_msg, "JSON File Not Found")
+        frappe.log_error("JSON Not Found", error_msg)
         frappe.throw("Файл кадастровых данных не найден. Обратитесь к администратору")
     except json.JSONDecodeError as e:
-        frappe.log_error(f"Ошибка парсинга JSON: {str(e)}", "JSON Parse Error")
+        frappe.log_error("JSON Parse Err", f"Ошибка парсинга JSON: {str(e)}")
         frappe.throw("Ошибка чтения файла кадастровых данных")
     except Exception as e:
-        frappe.log_error(f"Ошибка: {str(e)}\n{frappe.get_traceback()}", "Cadastral Score Error")
+        frappe.log_error("Cadastral Error", f"Ошибка: {str(e)}\n{frappe.get_traceback()}")
         frappe.throw(f"Ошибка получения кадастрового балла: {str(e)}")
 
 def get_markup_coefficient(agricultural_land_purpose):
     """
     Determines markup coefficient based on land use purpose
     """
-    frappe.log_error(f"Назначение: {agricultural_land_purpose}", "Get Markup Start")
+    frappe.log_error("Markup Search", f"Назначение: {agricultural_land_purpose}")
     
     markup_map = {
         "Əkin, dinc və çoxillik əkmələr": 0.06,
@@ -215,10 +209,10 @@ def get_markup_coefficient(agricultural_land_purpose):
     if coefficient is None:
         available = list(markup_map.keys())
         error_msg = f"Неизвестный тип: {agricultural_land_purpose}\nДоступные: {available}"
-        frappe.log_error(error_msg, "Unknown Purpose Type")
+        frappe.log_error("Unknown Purpose", error_msg)
         frappe.throw(f"Неизвестный тип назначения земли: {agricultural_land_purpose}")
     
-    frappe.log_error(f"Коэффициент: {coefficient}", "Markup Found")
+    frappe.log_error("Markup Found", f"Коэффициент: {coefficient}")
     return coefficient
 
 # ===============================
@@ -237,29 +231,26 @@ def calculate_industrial_tax(hectare, territorial_unit_name, industrial_land_pur
         f"  - territorial_unit_name: {territorial_unit_name}\n"
         f"  - industrial_land_purpose: {industrial_land_purpose}"
     )
-    frappe.log_error(params_info, "Ind Tax Calc Start")
+    frappe.log_error("Ind Tax Start", params_info)
     
     try:
         # Input validation
         if not hectare or not territorial_unit_name or not industrial_land_purpose:
             error_msg = "Не все поля заполнены для расчета"
-            frappe.log_error(error_msg, "Ind Tax Validation")
+            frappe.log_error("Ind Tax Valid", error_msg)
             frappe.throw(error_msg)
         
         # Use value as is - this is square meters
         area_sqm = float(hectare)
-        frappe.log_error(f"Площадь для расчета: {area_sqm} м²", "Area Converted")
+        frappe.log_error("Area Converted", f"Площадь для расчета: {area_sqm} м²")
         
         # Get scores from JSON file
-        frappe.log_error(
-            f"Получение баллов для '{territorial_unit_name}', назначение '{industrial_land_purpose}'",
-            "Get Ind Scores"
-        )
+        frappe.log_error("Get Ind Scores", f"Получение баллов для '{territorial_unit_name}', назначение '{industrial_land_purpose}'")
         score_data = get_industrial_land_scores(territorial_unit_name, industrial_land_purpose)
-        frappe.log_error(f"Получены баллы: {score_data}", "Scores Retrieved")
+        frappe.log_error("Scores Retrieved", f"Получены баллы: {score_data}")
         
         # Calculate using progressive formula
-        frappe.log_error("Начало расчета по прогрессивной формуле", "Progressive Calc")
+        frappe.log_error("Progressive Calc", "Начало расчета по прогрессивной формуле")
         calculation_result = calculate_industrial_land_formula(area_sqm, score_data)
         
         calc_summary = (
@@ -267,7 +258,7 @@ def calculate_industrial_tax(hectare, territorial_unit_name, industrial_land_pur
             f"Формула: {calculation_result['formula']}\n"
             f"Результат: {calculation_result['total']} манат"
         )
-        frappe.log_error(calc_summary, "Ind Tax Calc Done")
+        frappe.log_error("Ind Tax Done", calc_summary)
         
         return {
             'tax_amount': calculation_result['total'],
@@ -275,7 +266,7 @@ def calculate_industrial_tax(hectare, territorial_unit_name, industrial_land_pur
         }
         
     except Exception as e:
-        frappe.log_error(f"Ошибка: {str(e)}\n{frappe.get_traceback()}", "Ind Tax Calc Error")
+        frappe.log_error("Ind Tax Error", f"Ошибка: {str(e)}\n{frappe.get_traceback()}")
         frappe.throw(f"Ошибка при расчете: {str(e)}")
 
 def get_industrial_land_scores(territorial_unit_name, industrial_land_purpose):
@@ -287,24 +278,24 @@ def get_industrial_land_scores(territorial_unit_name, industrial_land_purpose):
         f"Территория: {territorial_unit_name}\n"
         f"Назначение: {industrial_land_purpose}"
     )
-    frappe.log_error(search_info, "Ind Scores Search")
+    frappe.log_error("Ind Score Search", search_info)
     
     try:
         # Path to JSON file
         json_file_path = frappe.get_app_path('taxes_az', 'data', 'industrial_land_data.json')
-        frappe.log_error(f"Путь к JSON: {json_file_path}", "JSON Path")
+        frappe.log_error("JSON Path", f"Путь к JSON: {json_file_path}")
         
         # Read JSON file
         with open(json_file_path, 'r', encoding='utf-8') as file:
             data = json.load(file)
         
         regions_count = len(data.get('industrial_land_regions', []))
-        frappe.log_error(f"JSON загружен, регионов: {regions_count}", "JSON Loaded")
+        frappe.log_error("JSON Loaded", f"JSON загружен, регионов: {regions_count}")
         
         # Find corresponding region
         for region in data.get('industrial_land_regions', []):
             if region.get('settlement_name') == territorial_unit_name:
-                frappe.log_error(f"Регион найден: {territorial_unit_name}", "Region Found")
+                frappe.log_error("Region Found", f"Регион найден: {territorial_unit_name}")
                 
                 # Get scores for specified land purpose
                 land_purpose_rates = region.get('land_purpose_rates', {})
@@ -315,13 +306,10 @@ def get_industrial_land_scores(territorial_unit_name, industrial_land_purpose):
                         'up_to_10000': purpose_rates.get('up_to_10000_sqm', 0),
                         'above_10000': purpose_rates.get('above_10000_sqm', 0)
                     }
-                    frappe.log_error(f"Получены ставки: {result}", "Rates Found")
+                    frappe.log_error("Rates Found", f"Получены ставки: {result}")
                     return result
                 else:
-                    frappe.log_error(
-                        f"Назначение '{industrial_land_purpose}' не найдено в регионе",
-                        "Purpose Not Found"
-                    )
+                    frappe.log_error("Purpose Not Found", f"Назначение '{industrial_land_purpose}' не найдено в регионе")
         
         # If region or purpose not found
         error_msg = (
@@ -329,18 +317,18 @@ def get_industrial_land_scores(territorial_unit_name, industrial_land_purpose):
             f"Территория: '{territorial_unit_name}'\n"
             f"Назначение: '{industrial_land_purpose}'"
         )
-        frappe.log_error(error_msg, "Data Not Found")
+        frappe.log_error("Data Not Found", error_msg)
         frappe.throw(f"Данные не найдены для территории '{territorial_unit_name}' и назначения '{industrial_land_purpose}'")
         
     except FileNotFoundError:
         error_msg = f"Файл не найден: {json_file_path}"
-        frappe.log_error(error_msg, "JSON File Not Found")
+        frappe.log_error("JSON Not Found", error_msg)
         frappe.throw("Файл данных промышленных земель не найден. Обратитесь к администратору")
     except json.JSONDecodeError as e:
-        frappe.log_error(f"Ошибка парсинга JSON: {str(e)}", "JSON Parse Error")
+        frappe.log_error("JSON Parse Err", f"Ошибка парсинга JSON: {str(e)}")
         frappe.throw("Ошибка чтения файла данных промышленных земель")
     except Exception as e:
-        frappe.log_error(f"Ошибка: {str(e)}\n{frappe.get_traceback()}", "Ind Scores Error")
+        frappe.log_error("Ind Score Error", f"Ошибка: {str(e)}\n{frappe.get_traceback()}")
         frappe.throw(f"Ошибка получения баллов промышленных земель: {str(e)}")
 
 def calculate_industrial_land_formula(area_sqm, score_data):
@@ -352,7 +340,7 @@ def calculate_industrial_land_formula(area_sqm, score_data):
         f"Площадь: {area_sqm} м²\n"
         f"Баллы: {score_data}"
     )
-    frappe.log_error(calc_info, "Formula Calc Start")
+    frappe.log_error("Formula Start", calc_info)
     
     up_to_10000_score = score_data['up_to_10000']
     above_10000_score = score_data['above_10000']
@@ -374,10 +362,7 @@ def calculate_industrial_land_formula(area_sqm, score_data):
         
         formula_text = f"{area_sqm} ÷ 100 × {up_to_10000_score} = {total}"
         
-        frappe.log_error(
-            f"Простой расчет (площадь ≤ 10000):\n{formula_text}",
-            "Simple Formula"
-        )
+        frappe.log_error("Simple Formula", f"Простой расчет (площадь ≤ 10000):\n{formula_text}")
         
     else:
         # Progressive system: up to 10000 sqm + above 10000 sqm
@@ -410,7 +395,7 @@ def calculate_industrial_land_formula(area_sqm, score_data):
             f"  Часть 2 (свыше 10000): {calculation_parts[1]['formula']}\n"
             f"  Итого: {total}"
         )
-        frappe.log_error(progressive_info, "Progressive Formula")
+        frappe.log_error("Progressive", progressive_info)
     
     result = {
         'total': total,
@@ -420,7 +405,7 @@ def calculate_industrial_land_formula(area_sqm, score_data):
         'scores_used': score_data
     }
     
-    frappe.log_error(f"Расчет завершен, результат: {result}", "Formula Calc Done")
+    frappe.log_error("Formula Done", f"Расчет завершен, результат: {result}")
     return result
 
 @frappe.whitelist()
@@ -433,12 +418,12 @@ def get_assets_for_year(asset_type, year):
         f"Тип актива: {asset_type}\n"
         f"Год: {year}"
     )
-    frappe.log_error(search_info, "Get Assets Start")
+    frappe.log_error("Get Assets Start", search_info)
     
     try:
         # Convert year to int for comparison
         target_year = int(year)
-        frappe.log_error(f"Целевой год (int): {target_year}", "Year Converted")
+        frappe.log_error("Year Converted", f"Целевой год (int): {target_year}")
         
         # Build filters
         filters = {
@@ -446,7 +431,7 @@ def get_assets_for_year(asset_type, year):
             'custom_asset_type': asset_type
         }
         
-        frappe.log_error(f"Фильтры: {filters}", "Filters Set")
+        frappe.log_error("Filters Set", f"Фильтры для поиска:\n  - docstatus: 1\n  - custom_asset_type: {asset_type}")
         
         # Get appropriate fields based on asset type
         if asset_type == 'Kənd təsərrüfatı təyinatlı torpaq sahələri':
@@ -479,12 +464,12 @@ def get_assets_for_year(asset_type, year):
             f"Тип: {asset_type_short}\n"
             f"Поля для выборки:\n" + "\n".join([f"  - {f}" for f in fields])
         )
-        frappe.log_error(fields_info, "Fields Selected")
+        frappe.log_error("Fields Selected", fields_info)
         
         # Get all assets of the specified type
-        frappe.log_error("Выполнение запроса к БД...", "DB Query Start")
+        frappe.log_error("DB Query Start", "Выполнение запроса к БД...")
         assets = frappe.get_list('Asset', filters=filters, fields=fields)
-        frappe.log_error(f"Получено активов из БД: {len(assets)}", "DB Query Done")
+        frappe.log_error("DB Query Done", f"Получено активов из БД: {len(assets)}")
         
         # Filter by purchase_date year
         filtered_assets = []
@@ -497,22 +482,13 @@ def get_assets_for_year(asset_type, year):
                 
                 if purchase_year == target_year:
                     filtered_assets.append(asset)
-                    frappe.log_error(
-                        f"Актив подходит: {asset['name']} (дата: {asset['purchase_date']})",
-                        "Asset Matched"
-                    )
+                    frappe.log_error("Asset Matched", f"Актив подходит: {asset['name']} (дата: {asset['purchase_date']})")
                 else:
                     skipped_wrong_year += 1
-                    frappe.log_error(
-                        f"Актив пропущен: {asset['name']} (год: {purchase_year}, нужен {target_year})",
-                        "Asset Skipped"
-                    )
+                    frappe.log_error("Asset Skipped", f"Актив пропущен: {asset['name']} (год: {purchase_year}, нужен {target_year})")
             else:
                 skipped_no_date += 1
-                frappe.log_error(
-                    f"Актив без даты: {asset['name']}",
-                    "Asset No Date"
-                )
+                frappe.log_error("Asset No Date", f"Актив без даты: {asset['name']}")
         
         summary = (
             f"Результаты фильтрации:\n"
@@ -521,10 +497,10 @@ def get_assets_for_year(asset_type, year):
             f"Пропущено (другой год): {skipped_wrong_year}\n"
             f"Пропущено (нет даты): {skipped_no_date}"
         )
-        frappe.log_error(summary, "Get Assets Done")
+        frappe.log_error("Get Assets Done", summary)
         
         return filtered_assets
         
     except Exception as e:
-        frappe.log_error(f"Ошибка: {str(e)}\n{frappe.get_traceback()}", "Get Assets Error")
+        frappe.log_error("Get Assets Error", f"Ошибка: {str(e)}\n{frappe.get_traceback()}")
         return []