diff --git a/formula_editor/api.py b/formula_editor/api.py
index 5c848b0..d9aca4b 100644
--- a/formula_editor/api.py
+++ b/formula_editor/api.py
@@ -7,17 +7,29 @@ def get_doctype_fields(doctype):
     for field in meta.fields:
         if field.fieldtype in ["Int", "Float", "Currency"]:
             fields.append({"fieldname": field.fieldname, "label": field.label, "fieldtype": field.fieldtype})
-    # Проверяем таблицы внутри DocType (например, items в Sales Invoice)
+            
+    # Проверяем таблицы внутри DocType
     for child in meta.fields:
         if child.fieldtype == "Table":
             child_meta = frappe.get_meta(child.options)
             for sub_field in child_meta.fields:
                 if sub_field.fieldtype in ["Int", "Float", "Currency"]:
+                    # Обычные поля табличной части (для суммирования)
                     fields.append({
                         "fieldname": f"{child.fieldname}_{sub_field.fieldname}",
                         "label": f"{child.label} → {sub_field.label}",
                         "fieldtype": sub_field.fieldtype
                     })
+                    
+                    # Добавляем поля для конкретных строк таблицы (первые 10 строк)
+                    for row_idx in range(1, 11):
+                        fields.append({
+                            "fieldname": f"{child.fieldname}_{row_idx}_{sub_field.fieldname}",
+                            "label": f"{child.label} → Строка {row_idx} → {sub_field.label}",
+                            "fieldtype": sub_field.fieldtype,
+                            "is_row_specific": True,
+                            "row_index": row_idx
+                        })
     return fields
 
 @frappe.whitelist()
diff --git a/formula_editor/formula_editor/doctype/formula_editor/formula_editor.js b/formula_editor/formula_editor/doctype/formula_editor/formula_editor.js
index c146918..0edf6c3 100644
--- a/formula_editor/formula_editor/doctype/formula_editor/formula_editor.js
+++ b/formula_editor/formula_editor/doctype/formula_editor/formula_editor.js
@@ -5,6 +5,13 @@ frappe.ui.form.on('Formula Editor', {
             frm.set_value("universal_fields_storage", "{}");
         }
         
+        addTokenStyles()
+
+        // Инициализация хранилища для формул строк табличных частей
+        if (!frm.doc.table_row_formulas_storage) {
+            frm.set_value("table_row_formulas_storage", "{}");
+        }
+        
         if (!frm.is_initialized) {
             frm.is_initialized = true;
     
@@ -30,7 +37,6 @@ frappe.ui.form.on('Formula Editor', {
     },
     
     before_remove: function(frm) {
-        
         if (frm.doc.target_doctype) {
             delete_client_script_for_doctype(frm.doc.target_doctype);
         }
@@ -58,6 +64,24 @@ function restore_formulas(frm) {
             $(this).val(value);
         }
     });
+    
+    // Убедимся, что предопределенные события обрабатываются при первой загрузке формы
+    if (Object.keys(stored_formulas).length > 0) {
+        let hasRefreshTriggers = false;
+        
+        // Проверяем, есть ли формулы с триггером "При открытии документа"
+        Object.keys(stored_formulas).forEach(fieldname => {
+            const formula = stored_formulas[fieldname];
+            if (formula && formula.triggers && formula.triggers.includes("При открытии документа")) {
+                hasRefreshTriggers = true;
+            }
+        });
+        
+        // Если нашли такие формулы, вызываем обработчик refresh для их выполнения
+        if (hasRefreshTriggers && typeof frm.trigger === 'function') {
+            setTimeout(() => frm.trigger('refresh'), 100);
+        }
+    }
 }
 
 function save_formulas(frm) {
@@ -68,15 +92,18 @@ function save_formulas(frm) {
         let formula = $(this).val();
         let is_table_field = $(this).attr("data-is-table-field") === "true";
         
-        // Ищем триггерное поле
+        // Получаем триггерное поле
         let triggers = $(frm.fields_dict.formula_fields.wrapper)
             .find(`[data-fieldname="${fieldname}_triggers"] input`).val();
 
-        formula_data[fieldname] = {
-            formula: formula || "",
-            triggers: triggers || "",
-            is_table_field: is_table_field
-        };
+        // Проверяем, что формула или триггеры не пустые
+        if (formula.trim() !== "" || (triggers && triggers.trim() !== "")) {
+            formula_data[fieldname] = {
+                formula: formula || "",
+                triggers: triggers || "",
+                is_table_field: is_table_field
+            };
+        }
     });
 
     frm.set_value("formula_storage", JSON.stringify(formula_data));
@@ -84,13 +111,13 @@ function save_formulas(frm) {
 
 function generate_client_script(frm) {
     if (!frm.doc.target_doctype) {
-        console.error("❌ Target Doctype отсутствует!");
         return;
     }
 
     let target_doctype = frm.doc.target_doctype;
     let formula_data = JSON.parse(frm.doc.formula_storage || "{}");
     let universal_fields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+    let table_row_formulas = JSON.parse(frm.doc.table_row_formulas_storage || "{}");
 
     let main_script = `// Generated by Formula Editor\nfrappe.ui.form.on("${target_doctype}", {\n`;
     let functions = [];
@@ -99,7 +126,8 @@ function generate_client_script(frm) {
 
     // Получаем информацию о таблицах DocType
     getTableDoctypes(target_doctype, table_doctypes);
-    console.log("📊 Соответствие таблиц и DocType:", table_doctypes);
+    
+    // Проверяем содержимое table_row_formulas
 
     // Сбор всех табличных частей и их полей
     let child_tables = {};
@@ -122,6 +150,9 @@ function generate_client_script(frm) {
     // Добавляем функцию преобразования выражений
     functions.push(generateTransformExpressionFunction(universal_fields));
 
+    // Добавляем функцию для работы с конкретными строками табличных частей
+    functions.push(generateTableRowAccessFunction());
+
     // Создаем список всех полей, которые используют универсальные поля
     let fieldsUsingUniversal = [];
     
@@ -179,7 +210,7 @@ function generate_client_script(frm) {
         let field_info = formula_data[fieldname];
 
         if (!field_info || typeof field_info !== "object" || !field_info.formula) {
-            console.warn(`⚠️ Пропущено поле ${fieldname}, так как оно не содержит формулу.`);
+            // console.warn(`⚠️ Пропущено поле ${fieldname}, так как оно не содержит формулу.`);
             return;
         }
 
@@ -231,9 +262,14 @@ try {
     
     // Затем оцениваем формулу
     let result = eval(transform_expression("${formula}", false));
+    
+    // Проверка на NaN и преобразование в 0
+    if (isNaN(result)) {
+        result = 0;
+    }
+    
     frm.set_value("${fieldname}", result);
 } catch (e) {
-    console.error("❌ Ошибка в формуле для ${fieldname}: ${formula}", e);
 }
 }`);
             } else {
@@ -241,9 +277,14 @@ try {
 function calculate_${fieldname}(frm) {
 try {
     let result = eval(transform_expression("${formula}", false));
+    
+    // Проверка на NaN и преобразование в 0
+    if (isNaN(result)) {
+        result = 0;
+    }
+    
     frm.set_value("${fieldname}", result);
 } catch (e) {
-    console.error("❌ Ошибка в формуле для ${fieldname}: ${formula}", e);
 }
 }`);
             }
@@ -286,12 +327,27 @@ try {
         }
     });
     
+    // Добавляем функции для расчета формул конкретных строк табличных частей
+    if (Object.keys(table_row_formulas).length > 0) {
+        // Создаем функции для расчета формул строк таблиц
+        generateTableRowFormulasHandlers(table_row_formulas, functions, target_doctype, universal_fields);
+    }
+    
     // Добавляем обработчик refresh, если были найдены формулы с триггером "При открытии документа"
-    if (refreshHandlers.length > 0) {
+    if (refreshHandlers.length > 0 || Object.keys(table_row_formulas).length > 0) {
         // Создаем обработчик refresh с вызовом всех нужных функций расчета
         let refreshHandlerBody = `    "refresh": ${refreshHandlers.some(h => h.uses_universal) ? 'async ' : ''}function(frm) {\n`;
         
+        // Если есть формулы для строк табличных частей, инициализируем их
+        if (Object.keys(table_row_formulas).length > 0) {
+            refreshHandlerBody += `        initialize_table_row_formulas(frm);\n`;
+        }
+        
         // Добавляем вызовы всех обработчиков
+        if (refreshHandlers.some(h => h.uses_universal)) {
+            refreshHandlerBody += `        await calculate_universal_fields(frm);\n`;
+        }
+        
         refreshHandlers.forEach(handler => {
             if (handler.uses_universal) {
                 refreshHandlerBody += `        await calculate_${handler.field}(frm);\n`;
@@ -306,226 +362,83 @@ try {
         main_script = main_script.replace('frappe.ui.form.on("' + target_doctype + '", {\n', 
                                           'frappe.ui.form.on("' + target_doctype + '", {\n' + refreshHandlerBody);
     }
+    
+    // Добавляем обработчики для событий табличных частей
+    main_script = addTableRowFormulaHandlers(main_script, table_row_formulas, table_doctypes);
 
     main_script += `});`;
 
     // Напрямую добавляем скрипты для дочерних таблиц
-    let child_scripts = '';
-    
-    // Создаем список имеющихся таблиц из триггеров
-    const tableTriggers = {};
-    Object.keys(table_field_triggers).forEach(trigger => {
-        if (trigger.includes('_')) {
-            const parts = trigger.split('_');
-            const tableName = parts[0];
-            const fieldName = parts.slice(1).join('_');
-            
-            if (!tableTriggers[tableName]) {
-                tableTriggers[tableName] = {};
-            }
-            
-            if (!tableTriggers[tableName][fieldName]) {
-                tableTriggers[tableName][fieldName] = [];
-            }
-            
-            // Добавляем все поля основного документа, зависящие от этого поля таблицы
-            table_field_triggers[trigger].forEach(item => {
-                tableTriggers[tableName][fieldName].push(item);
-            });
-        }
-    });
-    
-    // Для каждой таблицы создаем отдельный скрипт
-    Object.keys(tableTriggers).forEach(tableName => {
-        // Определяем DocType дочерней таблицы
-        const childDoctype = table_doctypes[tableName] || `${target_doctype} Item`;
-        
-        // Начинаем скрипт
-        let tableScript = `\n\nfrappe.ui.form.on("${childDoctype}", {\n`;
-        
-        // Добавляем обработчики для каждого поля
-        Object.keys(tableTriggers[tableName]).forEach(fieldName => {
-            const handlers = tableTriggers[tableName][fieldName];
-            const hasAsyncHandler = handlers.some(h => h.uses_universal);
-            
-            // Создаем обработчик исходя из асинхронности
-            if (hasAsyncHandler) {
-                tableScript += `    "${fieldName}": async function(frm, cdt, cdn) {\n`;
-                
-                // Добавляем вызовы всех обработчиков
-                handlers.forEach(handler => {
-                    if (handler.uses_universal) {
-                        tableScript += `        await calculate_${handler.main_field}(frm);\n`;
-                    } else {
-                        tableScript += `        calculate_${handler.main_field}(frm);\n`;
-                    }
-                });
-                
-                tableScript += `    },\n`;
-            } else {
-                tableScript += `    "${fieldName}": function(frm, cdt, cdn) {\n`;
-                
-                // Добавляем вызовы всех обработчиков
-                handlers.forEach(handler => {
-                    tableScript += `        calculate_${handler.main_field}(frm);\n`;
-                });
-                
-                tableScript += `    },\n`;
-            }
-        });
-        
-        // Закрываем скрипт таблицы
-        tableScript += `});`;
-        child_scripts += tableScript;
-    });
+    const child_scripts = generate_child_table_script(table_child_scripts, table_doctypes, table_field_triggers, formula_data, functions);
     
     // Добавляем скрипты дочерних таблиц к основному скрипту
     main_script += child_scripts;
 
     let final_script = `${main_script}\n\n${functions.join("\n\n")}`;
-    console.log("✅ **Сгенерированный Client Script:**\n", final_script);
 
     update_or_create_client_script(target_doctype, final_script);
 }
 
 // Новая функция для генерации скриптов дочерних таблиц с расширенным логированием
-function generate_child_table_script(table_child_scripts, table_doctypes, table_fields_triggers, formula_data, functions) {
+function generate_child_table_script(table_child_scripts, table_doctypes, table_field_triggers, formula_data, functions) {
     let child_scripts = '';
     
-    console.log("🔍 DEBUG: Вход в функцию generate_child_table_script");
-    console.log("🔍 DEBUG: table_child_scripts:", JSON.stringify(table_child_scripts, null, 2));
-    console.log("🔍 DEBUG: table_fields_triggers:", JSON.stringify(table_fields_triggers, null, 2));
-    
-    // Обрабатываем каждую табличную часть
-    Object.keys(table_child_scripts).forEach(table_name => {
-        const childInfo = table_child_scripts[table_name];
-        const childDoctype = childInfo.doctype;
-        const uses_universal = childInfo.uses_universal;
+    Object.keys(table_child_scripts).forEach(tableName => {
+        let childDoctype = table_child_scripts[tableName].doctype;
+        let usesUniversalFields = table_child_scripts[tableName].uses_universal;
+        let table_script = `\n\nfrappe.ui.form.on("${childDoctype}", {\n`;
         
-        console.log(`🔍 DEBUG: Генерируем скрипт для таблицы ${table_name}, DocType: ${childDoctype}`);
-        
-        // Начинаем скрипт для дочерней таблицы
-        let child_script = `\n\nfrappe.ui.form.on("${childDoctype}", {\n`;
-        
-        // Функция расчета для строки табличной части
-        let calcFunctionBody = '';
-        
-        // Добавляем асинхронность, если есть универсальные поля
-        if (uses_universal) {
-            calcFunctionBody = `
-async function calculate_${table_name}_row(frm, cdt, cdn) {
-    let row = locals[cdt][cdn];
-    
-    try {
-        // Сначала вычисляем универсальные поля
-        await calculate_universal_fields(frm);
-`;
-        } else {
-            calcFunctionBody = `
-function calculate_${table_name}_row(frm, cdt, cdn) {
-    let row = locals[cdt][cdn];
-    
-    try {`;
+        // Создаем общую функцию для расчета формул в строке таблицы
+        let calcFunction = `
+        ${usesUniversalFields ? 'async ' : ''}function calculate_${tableName}_row(frm, cdt, cdn) {
+            let row = locals[cdt][cdn];
+
+            try {`;
+            
+        // Если таблица использует универсальные поля, сначала вычисляем их
+        if (usesUniversalFields) {
+            calcFunction += `
+                // Вычисляем универсальные поля
+                await calculate_universal_fields(frm);
+            `;
         }
-        
+
         // Добавляем расчеты для каждого поля табличной части
-        childInfo.calculations.forEach(calc => {
-            calcFunctionBody += `
-        // Расчет для поля ${calc.field}
-        row["${calc.field}"] = eval(transform_expression("${calc.formula}", true, "${table_name}"));
-`;
+        table_child_scripts[tableName].calculations.forEach(calc => {
+            calcFunction += `
+                // Расчет для поля ${calc.field}
+                row["${calc.field}"] = eval(transform_expression("${calc.formula}", true, "${tableName}"));
+            `;
         });
         
-        calcFunctionBody += `
-        frm.refresh_field("${table_name}");
-    } catch (e) {
-        console.error("❌ Ошибка в формуле для таблицы ${table_name}:", e);
-    }
-}`;
-        
-        functions.push(calcFunctionBody);
-        
-        console.log(`🔍 DEBUG: Поля-триггеры в таблице ${table_name}:`, Array.from(childInfo.fields).join(', '));
-        
-        // Собираем все уникальные имена полей из триггеров таблицы для основного документа
-        const allTableFieldTriggers = {};
-        if (table_fields_triggers[table_name]) {
-            Object.keys(table_fields_triggers[table_name]).forEach(fieldName => {
-                allTableFieldTriggers[fieldName] = table_fields_triggers[table_name][fieldName];
-            });
-        }
-        
-        console.log(`🔍 DEBUG: Триггеры полей для основного документа из таблицы ${table_name}:`, Object.keys(allTableFieldTriggers).join(', '));
-        
-        // Добавляем обработчики для триггеров табличной части
-        Array.from(childInfo.fields).forEach(field => {
-            console.log(`🔍 DEBUG: Обрабатываем поле-триггер ${field} в таблице ${table_name}`);
-            
-            // Проверяем, есть ли этот триггер в table_fields_triggers
-            const isMainDocumentTrigger = allTableFieldTriggers[field] !== undefined;
-            
-            console.log(`🔍 DEBUG: Триггер ${field} ${isMainDocumentTrigger ? 'НАЙДЕН' : 'НЕ НАЙДЕН'} в списке триггеров основного документа`);
-            
-            // Если есть триггер, который обновляет поля основного документа
-            if (isMainDocumentTrigger) {
-                const triggers = allTableFieldTriggers[field];
-                
-                console.log(`🔍 DEBUG: Для триггера ${field} найдено ${triggers.length} обработчиков основного документа`);
-                
-                const triggerCodes = triggers.map(t => {
-                    const code = t.uses_universal ? 
-                        `await calculate_${t.main_field}(frm);` : 
-                        `calculate_${t.main_field}(frm);`;
-                    console.log(`🔍 DEBUG: Генерируем код для поля ${t.main_field}: ${code}`);
-                    return code;
-                });
-                
-                if (uses_universal) {
-                    child_script += `    "${field}": async function(frm, cdt, cdn) { 
-        // Сначала обновляем значения в текущей строке
-        await calculate_${table_name}_row(frm, cdt, cdn);
-        
-        // Затем пересчитываем поля основного документа
-        ${triggerCodes.join('\n        ')}
-    },\n`;
-                } else {
-                    child_script += `    "${field}": function(frm, cdt, cdn) { 
-        // Сначала обновляем значения в текущей строке
-        calculate_${table_name}_row(frm, cdt, cdn);
-        
-        // Затем пересчитываем поля основного документа
-        ${triggers.map(t => {
-            if (t.uses_universal) {
-                return `// Асинхронная функция требует await, вызываем через setTimeout
-                setTimeout(async function() { await calculate_${t.main_field}(frm); }, 0);`;
-            } else {
-                return `calculate_${t.main_field}(frm);`;
+        calcFunction += `
+                frm.refresh_field("${tableName}");
+            } catch (e) {
             }
-        }).join('\n        ')}
-    },\n`;
-                }
+        }`;
+
+        functions.push(calcFunction);
+
+        // Добавляем обработчики для каждого триггерного поля
+        Array.from(table_child_scripts[tableName].fields).forEach(field => {
+            if (usesUniversalFields) {
+                table_script += `    "${field}": async function(frm, cdt, cdn) { await calculate_${tableName}_row(frm, cdt, cdn); },\n`;
             } else {
-                // Стандартное поведение - только обновление текущей строки
-                if (uses_universal) {
-                    child_script += `    "${field}": async function(frm, cdt, cdn) { await calculate_${table_name}_row(frm, cdt, cdn); },\n`;
-                } else {
-                    child_script += `    "${field}": function(frm, cdt, cdn) { calculate_${table_name}_row(frm, cdt, cdn); },\n`;
-                }
+                table_script += `    "${field}": function(frm, cdt, cdn) { calculate_${tableName}_row(frm, cdt, cdn); },\n`;
             }
         });
         
-        // Закрываем скрипт табличной части
-        child_script += `});`;
-        child_scripts += child_script;
+        table_script += `});`;
+        child_scripts += table_script;
     });
     
-    console.log("🔍 DEBUG: Результат generate_child_table_script:", child_scripts);
     return child_scripts;
 }
 
 // Вспомогательные функции для generate_client_script
 function getTableDoctypes(target_doctype, table_doctypes) {
     // Пытаемся получить информацию о таблицах через API
+    
     frappe.call({
         method: "frappe.client.get",
         args: {
@@ -534,18 +447,19 @@ function getTableDoctypes(target_doctype, table_doctypes) {
         },
         async: false,
         callback: function(r) {
-            if (r.message && r.message.child_tables) {
-                r.message.child_tables.forEach(table => {
-                    if (table.options) {
-                        table_doctypes[table.fieldname] = table.options;
+            if (r.message && r.message.fields) {
+                r.message.fields.forEach(field => {
+                    if (field.fieldtype === 'Table' && field.options) {
+                        table_doctypes[field.fieldname] = field.options;
                     }
                 });
             }
         }
     });
 
-    // Если данные не получены, используем альтернативный способ
+    // Если данные не получены, используем альтернативный способ через meta
     if (Object.keys(table_doctypes).length === 0) {
+        
         const meta = frappe.get_meta(target_doctype);
         if (meta && meta.fields) {
             meta.fields.forEach(field => {
@@ -555,6 +469,11 @@ function getTableDoctypes(target_doctype, table_doctypes) {
             });
         }
     }
+    
+    // Проверяем результат
+    if (Object.keys(table_doctypes).length === 0) {
+    } else {
+    }
 }
 
 function collectChildTables(formula_data, child_tables) {
@@ -583,7 +502,6 @@ function generateUniversalFieldsFunction(universal_fields) {
             ${Object.keys(universal_fields).map(fieldId => {
                 const field = universal_fields[fieldId];
                 if (!field || !field.name || !field.doctype || !field.fieldname) {
-                    console.warn(`⚠️ Некорректное универсальное поле с ID ${fieldId}:`, field);
                     return '';
                 }
                 
@@ -629,14 +547,12 @@ function generateUniversalFieldsFunction(universal_fields) {
                                 
                                 // Проверяем, что поле ay имеет допустимое значение
                                 if (!docValues.ay || typeof docValues.ay !== 'string') {
-                                    console.warn("⚠️ Поле 'ay' пустое или имеет некорректный формат", docValues.ay);
                                     skipCalculation_${fieldId} = true;
                                     return;
                                 }
                                 
                                 // Проверяем, что поле il имеет допустимое значение
                                 if (!docValues.il || isNaN(parseInt(docValues.il))) {
-                                    console.warn("⚠️ Поле 'il' пустое или имеет некорректный формат", docValues.il);
                                     skipCalculation_${fieldId} = true;
                                     return;
                                 }
@@ -648,13 +564,10 @@ function generateUniversalFieldsFunction(universal_fields) {
                                     // Добавляем два фильтра для диапазона дат
                                     filters_${fieldId}.push(["${filter.field}", ">=", dateRange.start]);
                                     filters_${fieldId}.push(["${filter.field}", "<=", dateRange.end]);
-                                    console.log("🔍 Применяем специальные фильтры по датам для ${field.name}:", dateRange);
                                 } else {
-                                    console.warn("⚠️ Не удалось обработать специальные поля месяца и года", docValues);
                                     skipCalculation_${fieldId} = true;
                                 }
                             } else {
-                                console.log("🔍 Пропуск расчета ${field.name}: поля 'ay' или 'il' не определены");
                                 skipCalculation_${fieldId} = true;
                                 }
                                 `;
@@ -664,7 +577,6 @@ function generateUniversalFieldsFunction(universal_fields) {
                                 if (frm.doc["${filter.docField}"] !== undefined) {
                                     filters_${fieldId}.push(["${filter.field}", "${filter.operator}", frm.doc["${filter.docField}"]]);
                                 } else {
-                                    console.log("⚠️ Поле '${filter.docField}' не определено в документе");
                                     skipCalculation_${fieldId} = true;
                                 }
                                 `;
@@ -680,14 +592,11 @@ function generateUniversalFieldsFunction(universal_fields) {
                     
                     // Проверяем, нужно ли пропустить расчет
                     if (skipCalculation_${fieldId}) {
-                        console.log("⚠️ Расчет ${field.name} пропущен из-за отсутствия или некорректности данных");
                         if (!frm.doc.__universalFields) frm.doc.__universalFields = {};
                         frm.doc.__universalFields["${fieldId}"] = 0;
                         return;
                     }
                     
-                    console.log("🔍 Применяемые фильтры для ${field.name}:", filters_${fieldId});
-                    
                     const result_${fieldId} = await frappe.db.get_list("${field.doctype}", {
                         fields: ["${field.fieldname}"],
                         filters: filters_${fieldId},
@@ -703,10 +612,7 @@ function generateUniversalFieldsFunction(universal_fields) {
                     // Сохраняем результат в временное поле документа
                     if (!frm.doc.__universalFields) frm.doc.__universalFields = {};
                     frm.doc.__universalFields["${fieldId}"] = univ_${fieldId};
-                    
-                    console.log("✅ Универсальное поле ${field.name} рассчитано:", univ_${fieldId});
                 } catch (error) {
-                    console.error("❌ Ошибка при расчете универсального поля ${field.name}:", error);
                     if (!frm.doc.__universalFields) frm.doc.__universalFields = {};
                     frm.doc.__universalFields["${fieldId}"] = 0;
                 }`;
@@ -741,7 +647,6 @@ function generateUniversalFieldsFunction(universal_fields) {
             
             // Получаем год из поля il или используем текущий год
             let year = docValues.il || new Date().getFullYear();
-            console.log(\`🔹 Обработка специальных полей: ay=\${docValues.ay} (\${monthNum}), il=\${year}\`);
             
             // Определяем первый день месяца (1-е число)
             const firstDay = new Date(year, monthNum - 1, 1);
@@ -753,8 +658,6 @@ function generateUniversalFieldsFunction(universal_fields) {
             const firstDayStr = \`\${year}.\${String(monthNum).padStart(2, '0')}.01\`;
             const lastDayStr = \`\${year}.\${String(monthNum).padStart(2, '0')}.\${String(lastDay.getDate()).padStart(2, '0')}\`;
             
-            console.log(\`🔹 Диапазон дат для \${docValues.ay} \${year}: \${firstDayStr} - \${lastDayStr}\`);
-            
             // Возвращаем объект с диапазоном дат
             return {
                 start: firstDayStr,
@@ -806,7 +709,6 @@ function generateTransformExpressionFunction(universal_fields) {
     return `
     // Функция для преобразования выражений формул
     function transform_expression(expression, for_child_table = false, table_name = null) {
-        console.log("🔄 Исходная формула:", expression, "для табличной части:", for_child_table, "таблица:", table_name);
         
         let transformed = expression;
         
@@ -832,7 +734,6 @@ function generateTransformExpressionFunction(universal_fields) {
             // Проверяем использование val() для табличных полей (должны использоваться sum())
             const valTablePattern = new RegExp(\`val\\\\(\${tablePrefix}_([^)]+)\\\\)\`, 'g');
             transformed = transformed.replace(valTablePattern, (match, fieldName) => {
-                console.warn(\`⚠️ Использование val() для табличного поля. Заменено на sum(): \${match}\`);
                 return \`(frm.doc["\${tablePrefix}"] && frm.doc["\${tablePrefix}"].reduce((sum, row) => sum + (parseFloat(row["\${fieldName}"]) || 0), 0) || 0)\`;
             });
         }
@@ -845,36 +746,32 @@ function generateTransformExpressionFunction(universal_fields) {
                 if (field.startsWith(table_name + '_')) {
                     // Извлекаем имя поля без префикса
                     const actualFieldName = field.substring(table_name.length + 1);
-                    return \`row["\${actualFieldName}"]\`;
+                    return \`(parseFloat(row["\${actualFieldName}"]) || 0)\`;
                 }
                 // Если поле не из текущей таблицы, используем frm.doc
-                return \`frm.doc["\${field}"]\`;
+                return \`(parseFloat(frm.doc["\${field}"]) || 0)\`;
             });
             
             // Обрабатываем row() как обычно для табличной части
             transformed = transformed.replace(/row\\(([^)]+)\\)/g, (match, field) => {
-                return \`row["\${field}"]\`;
+                return \`(parseFloat(row["\${field}"]) || 0)\`;
             });
         } else {
             // Стандартная замена для обычных полей
             transformed = transformed.replace(/val\\(([^)]+)\\)/g, (match, field) => {
-                return \`frm.doc["\${field}"]\`;
+                return \`(parseFloat(frm.doc["\${field}"]) || 0)\`;
             });
             
             // Предупреждение, если row() используется вне таблицы
             transformed = transformed.replace(/row\\(([^)]+)\\)/g, (match, field) => {
-                console.warn("⚠️ Функция row() используется вне контекста табличной части");
                 return \`0 /* ERROR: row() вне табличной части */\`;
             });
         }
         
         // Обработка процентов
         transformed = transformed.replace(/(frm\\.doc\\["[^"]+"\]|\\d+|row\\["[^"]+"\])\\s*([+\\-])\\s*(\\d+(\\.\\d+)?)%/g, (match, base, operator, percent) => {
-            console.log("✅ Обнаружен процент в выражении:", match);
             return \`\${base} \${operator} ((\${base} * \${percent}) / 100)\`;
         });
-        
-        console.log("🔄 Трансформированная формула:", transformed);
         return transformed;
     }`;
 }
@@ -1002,7 +899,6 @@ function update_or_create_client_script(target_doctype, script_code) {
                 );
                 
                 if (formula_script) {
-                    console.log(`🔄 Найден существующий Formula Editor Script: ${formula_script.name}. Обновляем...`);
                     
                     frappe.call({
                         method: "frappe.client.set_value",
@@ -1017,18 +913,14 @@ function update_or_create_client_script(target_doctype, script_code) {
                         },
                         callback: function(response) {
                             if (response.message) {
-                                console.log(`✅ Formula Editor Script обновлен для ${target_doctype}`);
                             } else {
-                                console.error("❌ Ошибка при обновлении Formula Editor Script", response);
                             }
                         }
                     });
                 } else {
-                    console.log("⚠️ Существующий Formula Editor Script не найден. Создаем новый...");
                     createNewFormulaScript(target_doctype, script_code, formula_script_name);
                 }
             } else {
-                console.log("⚠️ Клиентских скриптов для DocType не найдено. Создаем новый...");
                 createNewFormulaScript(target_doctype, script_code, formula_script_name);
             }
         }
@@ -1053,9 +945,7 @@ function createNewFormulaScript(target_doctype, script_code, script_name) {
         },
         callback: function(response) {
             if (response.message) {
-                console.log(`✅ Formula Editor Script создан для ${target_doctype} с именем ${script_name}`);
             } else {
-                console.error("❌ Ошибка при создании Formula Editor Script", response);
             }
         }
     });
@@ -1144,6 +1034,9 @@ function generate_dynamic_fields(frm, doctype, callback) {
                     // Добавляем секцию универсальных полей
                     addUniversalFieldsSection(wrapper);
                     
+                    // Добавляем секцию формул для строк табличных частей
+                    addTableRowFormulasSection(wrapper);
+                    
                     // Создаем поля для каждой группы
                     Object.keys(grouped_fields).forEach(group => {
                         let section_name = group === "Основные поля" ? group : `${group} (${group.replace(/\s+/g, '_').toLowerCase()})`;
@@ -1168,6 +1061,9 @@ function generate_dynamic_fields(frm, doctype, callback) {
                     initUniversalFields(frm);
                     renderUniversalFields(frm);
                     
+                    // Инициализируем формулы для строк табличных частей
+                    initTableRowFormulas(frm);
+                    
                     // Прикрепляем обработчики событий
                     attachFormulaBuilderEvents(frm, formula_fields, grouped_fields);
                     attachTriggerEditorEvents(frm, trigger_fields, grouped_trigger_fields);
@@ -1185,6 +1081,8 @@ function createModals() {
     createFormulaBuilderModal();
     createTriggerFieldsModal();
     createUniversalFieldsModal();
+    createTableRowFormulaModal();
+    createTableRowFieldSelectorModal();
 }
 
 // Создание HTML для поля формулы
@@ -1217,6 +1115,24 @@ function createFormulaFieldHtml(field, dataAttr) {
 
 // Общие функции и утилиты
 function determineFieldType(fieldName, group, isInTableField) {
+    // Проверяем, является ли поле ссылкой на строку табличной части
+    const rowPattern = /^([a-z_]+)_row_(\d+)_([a-z_]+)$/i;
+    const rowMatch = fieldName.match(rowPattern);
+    
+    if (rowMatch) {
+        const tableName = rowMatch[1];
+        const rowIndex = rowMatch[2];
+        const fieldNameInRow = rowMatch[3];
+        
+        return {
+            type: 'table_row',
+            tableName: tableName,
+            rowIndex: rowIndex,
+            fieldName: fieldNameInRow,
+            fullFieldName: fieldName
+        };
+    }
+    
     // Получаем части имени поля
     // Проверяем существование имен групп "items", "taxes" и т.д. без подчеркивания
     const tablePrefixes = ["items", "taxes", "packed_items", "payments", "advances", "timesheets", "payment_schedule", "sales_team"];
@@ -1713,42 +1629,42 @@ $('head').append(modalStyles);
 }
 
 function createTriggerFieldsModal() {
-if ($("#trigger_fields_modal").length) {
-    return;
-}
+    if ($("#trigger_fields_modal").length) {
+        return;
+    }
 
-const modalHtml = `
-<div id="trigger_fields_modal" class="modal fade" tabindex="-1" role="dialog">
-    <div class="modal-dialog modal-lg" role="document">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h5 class="modal-title">Редактор полей изменения</h5>
-                <button type="button" class="close" data-dismiss="modal" aria-label="Close">
-                    <span aria-hidden="true">&times;</span>
-                </button>
-            </div>
-            <div class="modal-body">
-                <div class="trigger-workspace">
-                    <div class="trigger-result-container">
-                        <div class="trigger-result-title">Поля изменения:</div>
-                        <div class="trigger-result" contenteditable="true"></div>
-                    </div>
-                    <div class="fields-panel">
-                        <div class="fields-title">Доступные поля:</div>
-                        <div class="trigger-field-groups-container"></div>
+    const modalHtml = `
+    <div id="trigger_fields_modal" class="modal fade" tabindex="-1" role="dialog">
+        <div class="modal-dialog modal-lg" role="document">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Редактор полей изменения</h5>
+                    <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                        <span aria-hidden="true">&times;</span>
+                    </button>
+                </div>
+                <div class="modal-body">
+                    <div class="trigger-workspace">
+                        <div class="trigger-result-container">
+                            <div class="trigger-result-title">Поля изменения:</div>
+                            <div class="trigger-result" contenteditable="true"></div>
+                        </div>
+                        <div class="fields-panel">
+                            <div class="fields-title">Доступные поля:</div>
+                            <div class="trigger-field-groups-container"></div>
+                        </div>
                     </div>
                 </div>
-            </div>
-            <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" data-dismiss="modal">Отмена</button>
-                <button type="button" class="btn btn-primary apply-triggers">Применить</button>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-dismiss="modal">Отмена</button>
+                    <button type="button" class="btn btn-primary apply-triggers">Применить</button>
+                </div>
             </div>
         </div>
     </div>
-</div>
-`;
+    `;
 
-$('body').append(modalHtml);
+    $('body').append(modalHtml);
 }
 
 function createUniversalFieldsModal() {
@@ -1797,187 +1713,243 @@ $(frm.wrapper).on('click', '.open-formula-builder', function() {
 }
 
 function openFormulaBuilder(frm, targetFieldname, isTableField, currentFormula, fields, grouped_fields) {
-const $modal = $("#formula_builder_modal");
-const $resultContainer = $modal.find(".formula-result");
+    const $modal = $("#formula_builder_modal");
+    const $resultContainer = $modal.find(".formula-result");
 
-// Очистка предыдущих обработчиков и данных
-$modal.off('click', '.field-btn');
-$resultContainer.empty();
-$modal.find(".field-groups-container").empty();
+    // Очистка предыдущих обработчиков и данных
+    $modal.off('click', '.field-btn');
+    $resultContainer.empty();
+    $modal.find(".field-groups-container").empty();
 
-// Заполняем текущую формулу, если она есть
-if (currentFormula) {
-    parseAndRenderFormula($resultContainer, currentFormula, isTableField);
-}
+    // Заполняем текущую формулу, если она есть
+    if (currentFormula) {
+        parseAndRenderFormula($resultContainer, currentFormula, isTableField);
+    }
 
-// Заполняем панель с полями
-populateFieldsPanel($modal, frm, grouped_fields, isTableField);
+    // Заполняем панель с полями
+    populateFieldsPanel($modal, frm, grouped_fields, isTableField);
 
-// Сохраняем данные о текущем поле
-$modal.data("target-field", targetFieldname);
-$modal.data("is-table-field", isTableField);
+    // Сохраняем данные о текущем поле
+    $modal.data("target-field", targetFieldname);
+    $modal.data("is-table-field", isTableField);
 
-// Обработчики для кнопок операторов
-$modal.find('.operator-btn').off('click').on('click', function() {
-    const operator = $(this).data('operator');
-    addTokenToFormula(operator, 'operator', $resultContainer);
-});
+    // Обработчики для кнопок операторов
+    $modal.find('.operator-btn').off('click').on('click', function() {
+        const operator = $(this).data('operator');
+        addTokenToFormula(operator, 'operator', $resultContainer);
+    });
 
-// Обработчик для кнопки применения формулы
-$modal.find('.apply-formula').off('click').on('click', function() {
-    const formula = getFormulaText($resultContainer);
-    const $targetInput = $(frm.wrapper).find(`.formula-input[data-fieldname="${targetFieldname}"]`);
-    $targetInput.val(formula);
-    $modal.modal('hide');
-});
+    // Обработчик для кнопки применения формулы
+    $modal.find('.apply-formula').off('click').on('click', function() {
+        const formula = getFormulaText($resultContainer);
+        const $targetInput = $(frm.wrapper).find(`.formula-input[data-fieldname="${targetFieldname}"]`);
+        $targetInput.val(formula);
+        $modal.modal('hide');
+    });
 
-// Обработчики для кнопок полей - используем делегирование событий
-$modal.on('click', '.field-btn', function() {
-    const fieldname = $(this).data('fieldname');
-    addTokenToFormula(fieldname, 'field', $resultContainer, isTableField, $(this).data('group'));
-});
+    // Обработчики для кнопок полей - используем делегирование событий
+    $modal.on('click', '.field-btn', function() {
+        const fieldname = $(this).data('fieldname');
+        addTokenToFormula(fieldname, 'field', $resultContainer, isTableField, $(this).data('group'));
+    });
 
-// Обработчики для кнопок универсальных полей
-$modal.on('click', '.universal-field-btn', function() {
-    const fieldId = $(this).data('field-id');
-    addTokenToFormula(fieldId, 'universal-field', $resultContainer, isTableField, null, frm);
-});
+    // Обработчики для кнопок универсальных полей
+    $modal.on('click', '.universal-field-btn', function() {
+        const fieldId = $(this).data('field-id');
+        addTokenToFormula(fieldId, 'universal-field', $resultContainer, isTableField, null, frm);
+    });
 
-// Показываем модальное окно
-$modal.modal('show');
+    // Показываем модальное окно
+    $modal.modal('show');
 
-// Инициализируем перетаскивание
-initDragAndDrop($modal, $resultContainer, isTableField, frm);
+    // Инициализируем перетаскивание
+    initDragAndDrop($modal, $resultContainer, isTableField, frm);
 
-// Настраиваем редактируемый контейнер
-setupEditableContainer($resultContainer);
+    // Настраиваем редактируемый контейнер
+    setupEditableContainer($resultContainer);
 
-// Фокусируемся на редактируемом поле
-$resultContainer.focus();
+    // Фокусируемся на редактируемом поле
+    $resultContainer.focus();
 }
 
 function addTokenToFormula(token, type, $resultContainer, isTableField = false, group = null, frm = null) {
-if (type === 'field') {
-    let formulaText;
-    
-    // Определяем тип поля и формулу
-    const fieldInfo = determineFieldType(token, group, isTableField);
-    
-    if (fieldInfo.type === 'row') {
-        formulaText = `row(${fieldInfo.fieldName})`;
-    } else if (fieldInfo.type === 'sum') {
-        let tableName = fieldInfo.tableName || token.match(/^([a-z_]+)/)[1];
-        let fieldWithoutPrefix = token.substring(tableName.length);
-        if (fieldWithoutPrefix.startsWith('_')) {
-            fieldWithoutPrefix = fieldWithoutPrefix.substring(1);
+    if (type === 'field') {
+        let formulaText;
+        
+        // Определяем тип поля и формулу
+        const fieldInfo = determineFieldType(token, group, isTableField);
+        
+        if (fieldInfo.type === 'table_row') {
+            // Для полей конкретных строк таблиц
+            formulaText = `val(${fieldInfo.fullFieldName})`;
+        } else if (fieldInfo.type === 'row') {
+            formulaText = `row(${fieldInfo.fieldName})`;
+        } else if (fieldInfo.type === 'sum') {
+            let tableName = fieldInfo.tableName || token.match(/^([a-z_]+)/)[1];
+            let fieldWithoutPrefix = token.substring(tableName.length);
+            if (fieldWithoutPrefix.startsWith('_')) {
+                fieldWithoutPrefix = fieldWithoutPrefix.substring(1);
+            }
+            
+            formulaText = `sum(${tableName}_${fieldWithoutPrefix})`;
+        } else {
+            formulaText = `val(${fieldInfo.fieldName})`;
         }
         
-        formulaText = `sum(${tableName}_${fieldWithoutPrefix})`;
-    } else {
-        formulaText = `val(${fieldInfo.fieldName})`;
-    }
-    
-    const $token = $(`<span class="formula-token field" data-value="${formulaText}" contenteditable="false" draggable="true">${formulaText}<span class="token-remove">×</span></span>`);
-    $resultContainer.append($token).append(' ');
-} else if (type === 'operator') {
-    const $token = $(`<span class="formula-token operator" data-value="${token}" contenteditable="false" draggable="true">${token}<span class="token-remove">×</span></span>`);
-    $resultContainer.append($token).append(' ');
-} else if (type === 'universal-field') {
-    // Обработка для универсальных полей
-    const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
-    const field = universalFields[token];
-    if (field) {
-        const formulaText = `univ(${field.name})`;
-        const $token = $(`<span class="formula-token field universal-field" data-value="${formulaText}" contenteditable="false" draggable="true">${formulaText}<span class="token-remove">×</span></span>`);
+        const $token = $(`<span class="formula-token field" data-value="${formulaText}" contenteditable="false" draggable="true">${formulaText}<span class="token-remove">×</span></span>`);
         $resultContainer.append($token).append(' ');
+    } else if (type === 'operator') {
+        const $token = $(`<span class="formula-token operator" data-value="${token}" contenteditable="false" draggable="true">${token}<span class="token-remove">×</span></span>`);
+        $resultContainer.append($token).append(' ');
+    } else if (type === 'universal-field') {
+        // Обработка для универсальных полей
+        const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+        const field = universalFields[token];
+        if (field) {
+            const formulaText = `univ(${field.name})`;
+            const $token = $(`<span class="formula-token field universal-field" data-value="${formulaText}" contenteditable="false" draggable="true">${formulaText}<span class="token-remove">×</span></span>`);
+            $resultContainer.append($token).append(' ');
+        }
     }
-}
 
-// Переносим курсор в конец контейнера
-setEndOfContentEditable($resultContainer[0]);
+    // Переносим курсор в конец контейнера
+    setEndOfContentEditable($resultContainer[0]);
 
-// Добавляем обработчики для токенов
-addTokenHandlers($resultContainer);
+    // Добавляем обработчики для токенов
+    addTokenHandlers($resultContainer);
 }
 
 function populateFieldsPanel($modal, frm, grouped_fields, isTableField) {
-const $container = $modal.find(".field-groups-container");
-
-Object.keys(grouped_fields).forEach(group => {
-    const $fieldGroup = $(`
+    const $container = $modal.find(".field-groups-container");
+    $container.empty();
+    
+    // Добавляем секцию предопределенных событий
+    const $predefinedEventsGroup = $(`
         <div class="field-group">
-            <div class="field-group-title">${group}</div>
-            <div class="field-buttons-container" data-group="${group}"></div>
+            <div class="field-group-title">Предопределенные события</div>
+            <div class="field-buttons-container" data-group="predefined-events"></div>
         </div>
     `);
     
-    const $buttonsContainer = $fieldGroup.find('.field-buttons-container');
+    const $predefinedButtonsContainer = $predefinedEventsGroup.find('.field-buttons-container');
     
-    grouped_fields[group].forEach(field => {
-        // Определяем, является ли это поле таблицы или нет
-        const isField = group === "Основные поля";
-        
-        // Создаем кнопку поля с правильными атрибутами
-        const $fieldBtn = $(`
-            <button class="btn btn-sm field-btn draggable-item" 
-                data-fieldname="${field.fieldname}" 
-                data-label="${field.label}"
-                data-group="${group}"
+    // Добавляем кнопки для предопределенных событий
+    const predefinedEvents = [
+        { name: "При открытии документа", id: "При открытии документа" }
+    ];
+    
+    predefinedEvents.forEach(event => {
+        const $eventBtn = $(`
+            <button class="btn btn-sm field-btn highlight-event draggable-item" 
+                data-fieldname="${event.id}" 
+                data-label="${event.name}"
+                data-group="predefined-events"
+                data-field-type="event"
                 draggable="true">
-                ${field.label}
+                ${event.name}
             </button>
         `);
         
-        $buttonsContainer.append($fieldBtn);
+        $predefinedButtonsContainer.append($eventBtn);
     });
     
-    $container.append($fieldGroup);
-});
-
-// Добавляем секцию универсальных полей
-if (frm.doc.universal_fields_storage) {
-    const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+    // Добавляем группу предопределенных событий в начало контейнера
+    $container.prepend($predefinedEventsGroup);
     
-    if (Object.keys(universalFields).length > 0) {
-        const $universalFieldGroup = $(`
+    // Добавляем стандартные поля
+    Object.keys(grouped_fields).forEach(group => {
+        const $fieldGroup = $(`
             <div class="field-group">
-                <div class="field-group-title">Универсальные поля</div>
-                <div class="field-buttons-container" data-group="universal-fields"></div>
+                <div class="field-group-title">${group}</div>
+                <div class="field-buttons-container" data-group="${group}"></div>
             </div>
         `);
         
-        const $buttonsContainer = $universalFieldGroup.find('.field-buttons-container');
+        const $buttonsContainer = $fieldGroup.find('.field-buttons-container');
         
-        Object.keys(universalFields).forEach(fieldId => {
-            const field = universalFields[fieldId];
+        grouped_fields[group].forEach(field => {
+            // Определяем, является ли это поле таблицы или нет
+            const isTableGroupField = group !== "Основные поля";
             
+            // Создаем кнопку поля с правильными атрибутами
+            const btnClass = isTableGroupField ? "field-btn table-field-btn" : "field-btn";
             const $fieldBtn = $(`
-                <button class="btn btn-sm universal-field-btn draggable-item" 
-                    data-field-id="${fieldId}"
-                    data-name="${field.name}"
+                <button class="btn btn-sm ${btnClass} draggable-item" 
+                    data-fieldname="${field.fieldname}" 
+                    data-label="${field.label}"
+                    data-group="${group}"
+                    data-field-type="${isTableGroupField ? 'table' : 'field'}"
                     draggable="true">
-                    ${field.name}
+                    ${field.label}
                 </button>
             `);
             
             $buttonsContainer.append($fieldBtn);
         });
         
-        $container.append($universalFieldGroup);
+        $container.append($fieldGroup);
+    });
+    
+    // Добавляем секцию универсальных полей
+    if (frm.doc.universal_fields_storage) {
+        const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
         
-        // Настраиваем перетаскивание универсальных полей
-        $modal.find('.universal-field-btn').on('dragstart', function(e) {
-            const fieldId = $(this).data('field-id');
-            const fieldName = $(this).data('name');
+        if (Object.keys(universalFields).length > 0) {
+            const $universalFieldGroup = $(`
+                <div class="field-group">
+                    <div class="field-group-title">Универсальные поля</div>
+                    <div class="field-buttons-container" data-group="universal-fields"></div>
+                </div>
+            `);
             
-            e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify({
-                type: 'universal-field',
-                fieldId: fieldId,
-                name: fieldName
-            }));
-        });
+            const $universalButtonsContainer = $universalFieldGroup.find('.field-buttons-container');
+            
+            Object.keys(universalFields).forEach(fieldId => {
+                const field = universalFields[fieldId];
+                
+                if (!field || !field.name) return;
+                
+                const $fieldBtn = $(`
+                    <button class="btn btn-sm universal-field-btn draggable-item" 
+                        data-fieldname="univ(${field.name})" 
+                        data-label="${field.name}"
+                        data-group="universal-fields"
+                        data-field-type="universal"
+                        draggable="true">
+                        ${field.name}
+                    </button>
+                `);
+                
+                $universalButtonsContainer.append($fieldBtn);
+            });
+            
+            $container.append($universalFieldGroup);
+        }
     }
-}
+    
+    // Добавляем группу для полей строк табличных частей
+    const $tableRowGroup = $(`
+        <div class="field-group">
+            <div class="field-group-title">Поля строк табличных частей</div>
+            <div class="field-buttons-container table-row-fields-container">
+                <button class="btn btn-warning btn-sm select-table-row-field">
+                    <i class="fa fa-plus"></i> Выбрать поле строки т.ч.
+                </button>
+            </div>
+        </div>
+    `);
+    
+    $container.append($tableRowGroup);
+    
+    // Добавляем обработчик для кнопки выбора поля строки табличной части
+    $tableRowGroup.find('.select-table-row-field').on('click', function() {
+        // Определяем целевой контейнер в зависимости от контекста
+        const targetContainer = $modal.hasClass('trigger-focus') ? 
+            $modal.find(".table-row-trigger") : 
+            $modal.find(".formula-result");
+            
+        openTableRowFieldSelector(frm, targetContainer, $modal.hasClass('trigger-focus'));
+    });
 }
 
 function initDragAndDrop($modal, $resultContainer, isTableField, frm) {
@@ -2345,21 +2317,54 @@ function openTriggerFieldsEditor(frm, targetFieldname, currentTriggers, fields,
     // Заполняем панель с полями
     populateTriggerFieldsPanel($modal, frm, grouped_fields);
 
-    // Сохраняем данные о текущем поле
+    // Сохраняем данные о текущем поле и сбрасываем флаг table-row
     $modal.data("target-field", targetFieldname);
+    $modal.data("is-for-table-row", false);
 
     // Обработчик для кнопки применения триггеров
     $modal.find('.apply-triggers').off('click').on('click', function() {
         const triggers = getTriggerFieldsText($resultContainer);
-        const $targetInput = $(frm.wrapper).find(`.trigger-input[data-fieldname="${targetFieldname}_triggers"]`);
-        $targetInput.val(triggers);
+        
+        // Проверяем, для контейнера строки таблицы или обычного поля
+        if ($modal.data("is-for-table-row")) {
+            const $tableRowContainer = $modal.data("table-row-container");
+            
+            // Очищаем контейнер строки таблицы
+            $tableRowContainer.empty();
+            
+            // Переносим триггеры из модального окна в контейнер строки таблицы
+            if (triggers) {
+                parseAndRenderTriggers($tableRowContainer, triggers);
+            }
+        } else {
+            // Стандартное поведение для обычного поля
+            const $targetInput = $(frm.wrapper).find(`.trigger-input[data-fieldname="${targetFieldname}_triggers"]`);
+            $targetInput.val(triggers);
+        }
+        
         $modal.modal('hide');
     });
 
     // Обработчики для кнопок полей
     $modal.on('click', '.trigger-field-btn', function() {
         const fieldname = $(this).data('fieldname');
-        addTokenToTriggers(fieldname, $resultContainer);
+        
+        // Определяем тип поля по классу кнопки
+        let fieldType = 'field';
+        if ($(this).hasClass('highlight-event')) {
+            fieldType = 'event';
+        } else if ($(this).hasClass('universal-field-btn')) {
+            fieldType = 'universal';
+        } else if ($(this).hasClass('table-field-btn')) {
+            fieldType = 'table';
+        }
+        
+        addTokenToTriggers(fieldname, $resultContainer, fieldType);
+    });
+    
+    // Обработчик для кнопки выбора полей строк табличных частей
+    $modal.on('click', '.select-table-row-trigger-field', function() {
+        openTableRowFieldSelector(frm, $resultContainer, true);
     });
 
     // Показываем модальное окно
@@ -2377,6 +2382,7 @@ function openTriggerFieldsEditor(frm, targetFieldname, currentTriggers, fields,
 
 function populateTriggerFieldsPanel($modal, frm, grouped_fields) {
     const $container = $modal.find(".trigger-field-groups-container");
+    $container.empty();
     
     // Добавляем секцию предопределенных событий
     const $predefinedEventsGroup = $(`
@@ -2410,8 +2416,48 @@ function populateTriggerFieldsPanel($modal, frm, grouped_fields) {
     // Добавляем группу предопределенных событий в начало контейнера
     $container.prepend($predefinedEventsGroup);
     
+    // Добавляем секцию универсальных полей, если они есть
+    if (frm.doc.universal_fields_storage) {
+        const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+        
+        if (Object.keys(universalFields).length > 0) {
+            const $universalFieldGroup = $(`
+                <div class="trigger-field-group">
+                    <div class="trigger-field-group-title">Универсальные поля</div>
+                    <div class="trigger-field-buttons-container" data-group="universal-fields"></div>
+                </div>
+            `);
+            
+            const $universalButtonsContainer = $universalFieldGroup.find('.trigger-field-buttons-container');
+            
+            Object.keys(universalFields).forEach(fieldId => {
+                const field = universalFields[fieldId];
+                
+                if (!field || !field.name) return;
+                
+                const $fieldBtn = $(`
+                    <button class="btn btn-sm trigger-field-btn universal-field-btn draggable-item" 
+                        data-fieldname="univ(${field.name})" 
+                        data-label="${field.name}"
+                        data-group="universal-fields"
+                        data-field-id="${fieldId}"
+                        draggable="true">
+                        ${field.name}
+                    </button>
+                `);
+                
+                $universalButtonsContainer.append($fieldBtn);
+            });
+            
+            $container.append($universalFieldGroup);
+        }
+    }
+    
     // Добавляем обычные поля
     Object.keys(grouped_fields).forEach(group => {
+        // Пропускаем пустые группы
+        if (!grouped_fields[group] || grouped_fields[group].length === 0) return;
+        
         const $fieldGroup = $(`
             <div class="trigger-field-group">
                 <div class="trigger-field-group-title">${group}</div>
@@ -2423,8 +2469,11 @@ function populateTriggerFieldsPanel($modal, frm, grouped_fields) {
         
         grouped_fields[group].forEach(field => {
             // Создаем кнопку поля с информацией о типе поля
+            const isTableField = group !== "Основные поля";
+            const btnClass = isTableField ? "trigger-field-btn table-field-btn" : "trigger-field-btn";
+            
             const $fieldBtn = $(`
-                <button class="btn btn-sm trigger-field-btn draggable-item" 
+                <button class="btn btn-sm ${btnClass} draggable-item" 
                     data-fieldname="${field.fieldname}" 
                     data-label="${field.label}"
                     data-group="${group}"
@@ -2440,10 +2489,24 @@ function populateTriggerFieldsPanel($modal, frm, grouped_fields) {
         $container.append($fieldGroup);
     });
     
-    // Добавляем стили для выделения предопределенных событий
-    if (!$("#predefined-events-style").length) {
+    // Добавляем группу для полей строк табличных частей
+    const $tableRowGroup = $(`
+        <div class="trigger-field-group">
+            <div class="trigger-field-group-title">Поля строк табличных частей</div>
+            <div class="trigger-field-buttons-container table-row-fields-container">
+                <button class="btn btn-warning btn-sm select-table-row-trigger-field">
+                    <i class="fa fa-plus"></i> Выбрать поле строки т.ч.
+                </button>
+            </div>
+        </div>
+    `);
+    
+    $container.append($tableRowGroup);
+
+    // Добавляем стили для выделения различных типов триггеров
+    if (!$("#trigger-field-styles").length) {
         $("head").append(`
-            <style id="predefined-events-style">
+            <style id="trigger-field-styles">
                 .highlight-event {
                     background-color: #f8f1c6 !important;
                     border-color: #e6d292 !important;
@@ -2455,21 +2518,85 @@ function populateTriggerFieldsPanel($modal, frm, grouped_fields) {
                     background-color: #f8f1c6;
                     border-color: #e6d292;
                 }
+                
+                .universal-field-btn {
+                    background-color: #eff8e6 !important;
+                    border-color: #b7d69d !important;
+                }
+                .universal-field-btn:hover {
+                    background-color: #deedcf !important;
+                }
+                .trigger-token.universal-field {
+                    background-color: #eff8e6;
+                    border-color: #b7d69d;
+                }
+                
+                .table-field-btn {
+                    background-color: #e3efff !important;
+                    border-color: #abc9f5 !important;
+                }
+                .table-field-btn:hover {
+                    background-color: #d0e5ff !important;
+                }
+                .trigger-token.table-field {
+                    background-color: #e3efff;
+                    border-color: #abc9f5;
+                }
+                
+                .table-row-field-btn {
+                    background-color: #fff3cd !important;
+                    border-color: #ffeeba !important;
+                }
+                .table-row-field-btn:hover {
+                    background-color: #ffeeba !important;
+                }
+                .trigger-token.table-row-field {
+                    background-color: #fff3cd;
+                    border-color: #ffeeba;
+                }
+                
+                .btn.select-table-row-field,
+                .btn.select-table-row-trigger-field {
+                    background-color: #fff3cd;
+                    border-color: #ffeeba;
+                }
+                
+                .btn.select-table-row-field:hover,
+                .btn.select-table-row-trigger-field:hover {
+                    background-color: #ffeeba;
+                    border-color: #ffdf7e;
+                }
             </style>
         `);
     }
 }
 
-function addTokenToTriggers(fieldname, $resultContainer) {
+function addTokenToTriggers(fieldname, $resultContainer, fieldType = 'field') {
     // Проверяем, не добавлено ли уже это поле
     const existingTokens = $resultContainer.find(`.trigger-token[data-value="${fieldname}"]`);
     if (existingTokens.length > 0) {
         return; // Если поле уже добавлено, не добавляем его снова
     }
 
-    // Определяем, является ли это предопределенным событием
-    const isPredefined = isPredefinedEvent(fieldname);
-    const tokenClass = isPredefined ? "trigger-token field highlight-event" : "trigger-token field";
+    // Определяем класс токена в зависимости от типа поля
+    let tokenClass = "trigger-token field";
+    
+    switch (fieldType) {
+        case 'event':
+            tokenClass = "trigger-token field highlight-event";
+            break;
+        case 'universal':
+            tokenClass = "trigger-token field universal-field";
+            break;
+        case 'table':
+            tokenClass = "trigger-token field table-field";
+            break;
+        case 'table-row':
+            tokenClass = "trigger-token field table-row-field";
+            break;
+        default:
+            tokenClass = "trigger-token field";
+    }
     
     const $token = $(`<span class="${tokenClass}" data-value="${fieldname}" contenteditable="false">${fieldname}<span class="token-remove">×</span></span>`);
     $resultContainer.append($token).append(' ');
@@ -2496,7 +2623,8 @@ function attachTriggerTokenEvents($container) {
             e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify({
                 type: 'trigger-token',
                 value: $(this).data('value'),
-                html: $(this)[0].outerHTML
+                html: $(this)[0].outerHTML,
+                tokenClass: $(this).attr('class')
             }));
             window.draggedTriggerElement = this;
         });
@@ -2507,13 +2635,13 @@ function attachTriggerTokenEvents($container) {
     });
 }
 
-function initTriggerDragAndDrop($modal, $resultContainer) {
+function initTriggerDragAndDrop($modal, $triggerContainer) {
     // Очищаем предыдущие обработчики
-    $modal.find('.trigger-field-btn').off('dragstart');
-    $resultContainer.off('dragover dragleave drop');
+    $modal.find('.field-btn, .universal-field-btn, .trigger-field-btn').off('dragstart');
+    $triggerContainer.off('dragover dragleave drop');
 
-    // Настраиваем перетаскивание существующих токенов
-    $resultContainer.find('.trigger-token').each(function() {
+    // Настраиваем перетаскивание существующих токенов в триггер-контейнере
+    $triggerContainer.find('.trigger-token').each(function() {
         $(this).attr('draggable', 'true');
         
         $(this).off('dragstart').on('dragstart', function(e) {
@@ -2524,96 +2652,62 @@ function initTriggerDragAndDrop($modal, $resultContainer) {
             e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify({
                 type: 'trigger-token',
                 value: $(this).data('value'),
-                html: $(this)[0].outerHTML
+                html: $(this)[0].outerHTML,
+                tokenClass: $(this).attr('class')
             }));
             
             // Добавляем класс перетаскивания
             $(this).addClass('dragging');
-            
-            return true;
         });
         
         // При завершении перетаскивания
-        $(this).off('dragend').on('dragend', function(e) {
+        $(this).off('dragend').on('dragend', function() {
             $(this).removeClass('dragging');
             window.draggedTriggerElement = null;
         });
     });
 
-    // Настраиваем перетаскивание полей из панели
-    $modal.find('.trigger-field-btn').on('dragstart', function(e) {
+    // Настраиваем перетаскивание полей из панели в триггер-контейнер
+    $modal.find('.field-btn, .universal-field-btn').off('dragstart').on('dragstart', function(e) {
         const fieldname = $(this).data('fieldname');
         const label = $(this).data('label');
-        const group = $(this).data('group');
+        const fieldType = $(this).hasClass('universal-field-btn') ? 'universal' : 'field';
         
         const fieldData = {
             type: 'trigger-field',
             fieldname: fieldname,
             label: label,
-            group: group
+            fieldType: fieldType
         };
         
         e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify(fieldData));
     });
 
-    // Обработка dragover
-    $resultContainer.on('dragover', function(e) {
+    // Обработка dragover для триггер-контейнера
+    $triggerContainer.on('dragover', function(e) {
         e.preventDefault();
         e.stopPropagation();
         $(this).addClass('drag-hover');
         
-        const x = e.originalEvent.clientX;
-        const y = e.originalEvent.clientY;
-        
-        let position = { element: null, position: 'after' };
-        
-        // Проходим по всем дочерним элементам контейнера
-        $resultContainer.contents().each(function() {
-            if (this.nodeType === Node.TEXT_NODE) return;
-            
-            const rect = this.getBoundingClientRect();
-            
-            // Если курсор находится над элементом
-            if (x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom) {
-                position.element = this;
-                
-                // Определяем, до или после элемента
-                if (x < rect.left + rect.width / 2) {
-                    position.position = 'before';
-                } else {
-                    position.position = 'after';
-                }
-                
-                return false; // Прерываем перебор
-            }
-        });
-        
-        $resultContainer.find('.trigger-drop-marker').remove();
-        
-        if (position.element) {
-            const $marker = $('<span class="trigger-drop-marker" style="display:inline-block;width:2px;height:18px;background-color:#4285f4;vertical-align:middle;"></span>');
-            
-            if (position.position === 'before') {
-                $(position.element).before($marker);
-            } else {
-                $(position.element).after($marker);
-            }
-        }
+        // Обновляем маркер сброса
+        updateDropMarker(e, $(this));
     });
 
-    // Обработка dragleave
-    $resultContainer.on('dragleave', function(e) {
+    // Обработка dragleave для триггер-контейнера
+    $triggerContainer.on('dragleave', function(e) {
+        e.preventDefault();
         $(this).removeClass('drag-hover');
-        $(this).find('.trigger-drop-marker').remove();
+        $(this).find('.drop-marker').remove();
     });
 
-    // Обработка drop
-    $resultContainer.on('drop', function(e) {
+    // Обработка drop для триггер-контейнера
+    $triggerContainer.on('drop', function(e) {
         e.preventDefault();
         e.stopPropagation();
         $(this).removeClass('drag-hover');
-        $(this).find('.trigger-drop-marker').remove();
+        $(this).find('.drop-marker').remove();
         
+        // Обрабатываем сброшенные данные
         handleTriggerDrop(e, $(this));
     });
 }
@@ -2622,9 +2716,9 @@ function handleTriggerDrop(e, $container) {
     try {
         const data = JSON.parse(e.originalEvent.dataTransfer.getData('text/plain'));
         
+        // Получаем позицию сброса
         const x = e.originalEvent.clientX;
         const y = e.originalEvent.clientY;
-        
         let position = findDropPosition(x, y, $container);
         
         // Обработка перетаскивания существующих токенов
@@ -2648,63 +2742,48 @@ function handleTriggerDrop(e, $container) {
             return;
         }
         
-        // Создание нового элемента для поля
-        if (data.type === 'trigger-field') {
+        // Обработка перетаскивания полей из панели
+        if (data.type === 'field' || data.type === 'trigger-field') {
             // Проверяем, не добавлено ли уже это поле
-            const existingTokens = $container.find(`.trigger-token[data-value="${data.fieldname}"]`);
+            const fieldname = data.fieldname;
+            const existingTokens = $container.find(`.trigger-token[data-value="${fieldname}"]`);
             if (existingTokens.length > 0) {
                 return; // Если поле уже добавлено, не добавляем его снова
             }
             
-            // Определяем, является ли это предопределенным событием
-            const isPredefined = data.group === 'predefined-events';
-            const tokenClass = isPredefined ? "trigger-token field highlight-event" : "trigger-token field";
+            // Определяем тип поля и создаем соответствующий токен
+            let fieldType = 'field';
+            if (data.fieldType === 'universal') {
+                fieldType = 'universal';
+            } else if (data.fieldType === 'table') {
+                fieldType = 'table';
+            } else if (data.fieldType === 'table-row') {
+                fieldType = 'table-row';
+            } else if (data.fieldType === 'event') {
+                fieldType = 'event';
+            }
             
-            const $newElement = $(`<span class="${tokenClass}" data-value="${data.fieldname}" draggable="true" contenteditable="false">${data.fieldname}<span class="token-remove">×</span></span>`);
+            // Создаем токен
+            const $token = createTriggerToken(fieldname, fieldType);
             
-            // Вставляем новый элемент
+            // Вставляем токен в нужную позицию
             if (position.element) {
                 if (position.position === 'before') {
-                    $(position.element).before($newElement);
+                    $(position.element).before($token);
                     $(position.element).before(' ');
                 } else {
-                    $(position.element).after($newElement);
+                    $(position.element).after($token);
                     $(position.element).after(' ');
                 }
             } else {
-                $container.append($newElement);
+                $container.append($token);
                 $container.append(' ');
             }
             
-            // Инициализируем события для нового элемента
-            $newElement.find('.token-remove').on('click', function(e) {
-                e.stopPropagation();
-                $(this).parent().remove();
-            });
-            
-            // Добавляем обработчики для перетаскивания
-            $newElement.attr('draggable', 'true');
-            
-            $newElement.off('dragstart').on('dragstart', function(e) {
-                window.draggedTriggerElement = this;
-                
-                e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify({
-                    type: 'trigger-token',
-                    value: $(this).data('value'),
-                    html: $(this)[0].outerHTML
-                }));
-                
-                $(this).addClass('dragging');
-                return true;
-            });
-            
-            $newElement.off('dragend').on('dragend', function(e) {
-                $(this).removeClass('dragging');
-                window.draggedTriggerElement = null;
-            });
+            // Инициализируем события для нового токена
+            initTriggerTokenEvents($token);
         }
     } catch (error) {
-        console.error("❌ Ошибка при обработке drop для триггера:", error);
     }
 }
 
@@ -2716,16 +2795,25 @@ function parseAndRenderTriggers($container, triggers) {
     
     // Создаем токены для каждого поля
     triggerFields.forEach(field => {
-        // Определяем, является ли это предопределенным событием
-        const isPredefined = isPredefinedEvent(field);
-        const tokenClass = isPredefined ? "trigger-token field highlight-event" : "trigger-token field";
+        // Определяем тип триггера
+        let fieldType = 'field';
         
-        const $token = $(`<span class="${tokenClass}" data-value="${field}" contenteditable="false">${field}<span class="token-remove">×</span></span>`);
-        $container.append($token).append(' ');
+        if (isPredefinedEvent(field)) {
+            fieldType = 'event';
+        } else if (field.startsWith('univ(')) {
+            fieldType = 'universal';
+        } else if (field.includes('_') && !field.includes('_row_')) {
+            // Проверяем, является ли это полем табличной части
+            const parts = field.split('_');
+            if (parts.length >= 2) {
+                fieldType = 'table';
+            }
+        } else if (field.includes('_row_')) {
+            fieldType = 'table-row';
+        }
+        
+        addTokenToTriggers(field, $container, fieldType);
     });
-    
-    // Добавляем обработчики для токенов
-    attachTriggerTokenEvents($container);
 }
 
 function getTriggerFieldsText($container) {
@@ -2772,7 +2860,7 @@ function setupTriggerEditableContainer($container) {
         return true;
     });
 
-    // Обработчик вставки текста
+// Обработчик вставки текста
     $container.off('paste').on('paste', function(e) {
         e.preventDefault();
         
@@ -2789,18 +2877,29 @@ function setupTriggerEditableContainer($container) {
             const fields = text.split(',').map(field => field.trim()).filter(field => field);
             
             fields.forEach(field => {
+                // Определяем тип триггера
+                let fieldType = 'field';
+                
+                if (isPredefinedEvent(field)) {
+                    fieldType = 'event';
+                } else if (field.startsWith('univ(')) {
+                    fieldType = 'universal';
+                } else if (field.includes('_') && !field.includes('_row_')) {
+                    // Проверяем, является ли это полем табличной части
+                    const parts = field.split('_');
+                    if (parts.length >= 2) {
+                        fieldType = 'table';
+                    }
+                } else if (field.includes('_row_')) {
+                    fieldType = 'table-row';
+                }
+                
+                // Проверяем, не добавлено ли уже это поле
                 const existingTokens = $container.find(`.trigger-token[data-value="${field}"]`);
                 if (existingTokens.length === 0) {
-                    const $token = $(`<span class="trigger-token field" data-value="${field}" contenteditable="false">${field}<span class="token-remove">×</span></span>`);
-                    $container.append($token).append(' ');
+                    addTokenToTriggers(field, $container, fieldType);
                 }
             });
-            
-            // Обновляем обработчики
-            $container.find('.token-remove').off('click').on('click', function(e) {
-                e.stopPropagation();
-                $(this).parent().remove();
-            });
         }
     });
 }
@@ -3101,11 +3200,9 @@ function openUniversalFieldModal(frm, fieldId = null) {
 }
 
 function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
-    console.log("🔄 handleFilterFieldChange вызван для поля:", fieldInfo);
     
     // Проверяем, что у нас есть все необходимые объекты
     if (!dialog || !grid_row || !fieldInfo) {
-        console.error("❌ Отсутствуют необходимые параметры для handleFilterFieldChange");
         return;
     }
     
@@ -3116,9 +3213,7 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
             currentValue = grid_row.doc.value;
         }
     } catch (error) {
-        console.warn("⚠️ Не удалось получить текущее значение:", error);
     }
-    console.log("🔹 Текущее значение:", currentValue);
     
     // Определяем новый тип поля в зависимости от типа выбранного поля
     let fieldtype = 'Data';
@@ -3128,18 +3223,15 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
         case 'Select':
             fieldtype = 'Select';
             options = fieldInfo.options;
-            console.log("🔹 Установка типа Select с опциями:", options);
             break;
             
         case 'Link':
             fieldtype = 'Link';
             options = fieldInfo.options;
-            console.log("🔹 Установка типа Link с опциями:", options);
             break;
             
         case 'Check':
             fieldtype = 'Check';
-            console.log("🔹 Установка типа Check");
             break;
             
         case 'Date':
@@ -3149,7 +3241,6 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
             const target_doctype = cur_frm.doc.target_doctype;
             
             if (target_doctype) {
-                console.log("🔹 Target DocType для полей даты:", target_doctype);
                 
                 // Загружаем поля целевого DocType
                 try {
@@ -3162,7 +3253,6 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
                                 field.fieldname === 'ay' || 
                                 field.fieldname === 'il'
                             );
-                            console.log("🔹 Найденные поля Date и ay/il в target_doctype:", targetDateFields);
                             
                             // Проверяем, есть ли специальные поля ay и il одновременно
                             const hasAyField = targetDateFields.some(field => field.fieldname === 'ay');
@@ -3189,8 +3279,6 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
                                     value: 'custom'
                                 });
                                 
-                                console.log("🔹 Созданы опции для полей даты из target_doctype:", options);
-                                
                                 // Обновляем свойства поля значения
                                 if (dialog.fields_dict.filters && dialog.fields_dict.filters.grid) {
                                     dialog.fields_dict.filters.grid.update_docfield_property('value', 'fieldtype', fieldtype);
@@ -3203,42 +3291,33 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
                                 }
                             } else {
                                 fieldtype = 'Date'; // Если нет полей с датой, используем обычный Date
-                                console.log("⚠️ Нет полей даты в target_doctype, используем обычный Date");
                             }
                         } else {
                             fieldtype = 'Date'; // Если не удалось получить метаданные, используем обычный Date
-                            console.log("⚠️ Не удалось получить метаданные target_doctype, используем обычный Date");
                         }
                     });
                 } catch (error) {
                     fieldtype = 'Date'; // В случае ошибки используем обычный Date
-                    console.error("❌ Ошибка при загрузке полей target_doctype:", error);
                 }
             } else {
                 fieldtype = 'Date'; // Если target_doctype не указан, используем обычный Date
-                console.log("⚠️ target_doctype не указан, используем обычный Date");
             }
             break;
             
         case 'Datetime':
             fieldtype = 'Datetime';
-            console.log("🔹 Установка типа Datetime");
             break;
             
         case 'Int':
         case 'Float':
         case 'Currency':
             fieldtype = 'Float';
-            console.log("🔹 Установка числового типа:", fieldtype);
             break;
             
         default:
             fieldtype = 'Data';
-            console.log("🔹 Установка типа по умолчанию: Data");
     }
     
-    console.log("🔄 Обновляем свойства поля значения: тип =", fieldtype, "опции =", options);
-    
     try {
         // Обновляем свойства поля значения (только для не-Date полей, для Date это делается в асинхронном колбэке)
         if (fieldInfo.fieldtype !== 'Date' && dialog.fields_dict.filters && dialog.fields_dict.filters.grid) {
@@ -3268,10 +3347,7 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
                                     value = grid_row.doc.value;
                                 }
                                 
-                                console.log("🔄 Изменение значения даты:", value);
-                                
                                 if (value === 'custom') {
-                                    console.log("🔄 Переключение на ручной ввод даты");
                                     // Переключаем на ручной ввод даты
                                     dialog.fields_dict.filters.grid.update_docfield_property('value', 'fieldtype', 'Date');
                                     dialog.fields_dict.filters.grid.update_docfield_property('value', 'options', '');
@@ -3282,7 +3358,6 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
                                     }
                                 } 
                                 else if (value === 'doc.ay') {
-                                    console.log("🔄 Выбрано специальное поле месяца (Ay)");
                                     
                                     // Для doc.ay не меняем тип поля, только запоминаем в grid_row, что это специальный случай
                                     if (grid_row && grid_row.doc) {
@@ -3290,24 +3365,20 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
                                     }
                                 }
                             } catch (error) {
-                                console.error("❌ Ошибка при обработке изменения значения даты:", error);
                             }
                         };
                     }
                 }
             } catch (error) {
-                console.error("❌ Ошибка при настройке обработчика изменения поля даты:", error);
             }
         }
     } catch (error) {
-        console.error("❌ Ошибка при обновлении свойств поля:", error);
     }
     
     try {
         // Пересоздаем контрол (только для не-Date полей, для Date это делается в асинхронном колбэке)
         if (fieldInfo.fieldtype !== 'Date' && grid_row && typeof grid_row.refresh === 'function') {
             grid_row.refresh();
-            console.log("🔄 Контрол обновлен");
         }
         
         // Устанавливаем значение обратно
@@ -3316,13 +3387,9 @@ function handleFilterFieldChange(dialog, grid_row, fieldInfo) {
             if (typeof grid_row.refresh_field === 'function') {
                 grid_row.refresh_field('value');
             }
-            console.log("✅ Значение восстановлено:", currentValue);
         }
     } catch (error) {
-        console.error("❌ Ошибка при обновлении контрола:", error);
     }
-    
-    console.log("✅ handleFilterFieldChange завершен");
 }
 
 function loadDoctypes() {
@@ -3536,24 +3603,17 @@ function updateFilterValueField($filterRow, fieldInfo) {
     const $valueContainer = $filterRow.find('.filter-value-container');
     const $operator = $filterRow.find('.filter-operator');
     
-    console.log("⚙️ updateFilterValueField вызван для поля:", fieldInfo);
-    
     // Если информация о поле отсутствует, возвращаем обычное текстовое поле
     if (!fieldInfo) {
-        console.log("❌ Отсутствует информация о поле, использую текстовое поле");
         $valueContainer.html('<input type="text" class="form-control filter-value" placeholder="Значение">');
         return;
     }
     
-    console.log("🔍 Определение типа ввода для поля типа:", fieldInfo.fieldtype);
-    
     // В зависимости от типа поля создаем соответствующий элемент ввода
     switch (fieldInfo.fieldtype) {
         case 'Date':
-            console.log("🔍 Обрабатываю поле типа Date");
             // Получаем target_doctype из основной формы
             const target_doctype = cur_frm.doc.target_doctype;
-            console.log("🔹 Target DocType для полей даты:", target_doctype);
             
             if (target_doctype) {
                 // Загружаем поля целевого DocType
@@ -3566,14 +3626,12 @@ function updateFilterValueField($filterRow, fieldInfo) {
                             field.fieldname === 'ay' || 
                             field.fieldname === 'il'
                         );
-                        console.log("🔹 Найденные поля Date и ay/il в target_doctype:", targetDateFields);
                         
                         // Проверяем, есть ли специальные поля ay и il одновременно
                         const hasAyField = targetDateFields.some(field => field.fieldname === 'ay');
                         const hasIlField = targetDateFields.some(field => field.fieldname === 'il');
                         
                         if (targetDateFields.length > 0) {
-                            console.log("✅ Создаю селект с полями даты из target_doctype");
                             // Создаем селект с опциями из полей с датой
                             let selectHtml = '<select class="form-control filter-value">';
                             selectHtml += '<option value="">Выберите поле даты</option>';
@@ -3601,40 +3659,32 @@ function updateFilterValueField($filterRow, fieldInfo) {
                             // Добавляем обработчик для опции "Указать дату..."
                             $valueContainer.find('.filter-value').on('change', function() {
                                 const selectedValue = $(this).val();
-                                console.log("🔄 Изменение значения поля даты:", selectedValue);
                                 
                                 if (selectedValue === 'custom') {
-                                    console.log("🔄 Переключение на ручной ввод даты");
                                     $valueContainer.html('<input type="date" class="form-control filter-value">');
                                 }
                                 else if (selectedValue === 'doc.ay') {
-                                    console.log("🔄 Выбрано специальное поле месяца (Ay)");
                                     // Помечаем в data-атрибуте, что это специальное поле ay
                                     $(this).attr('data-is-special-ay-field', 'true');
                                 }
                             });
                         } else {
-                            console.log("⚠️ Не найдено полей с типом Date в target_doctype, использую стандартный ввод даты");
                             $valueContainer.html('<input type="date" class="form-control filter-value">');
                         }
                     } else {
-                        console.log("⚠️ Не удалось получить метаданные target_doctype, использую стандартный ввод даты");
                         $valueContainer.html('<input type="date" class="form-control filter-value">');
                     }
                 });
             } else {
-                console.log("⚠️ target_doctype не указан, использую стандартный ввод даты");
                 $valueContainer.html('<input type="date" class="form-control filter-value">');
             }
             break;
             
         case 'Datetime':
-            console.log("🔍 Обрабатываю поле типа Datetime");
             $valueContainer.html('<input type="datetime-local" class="form-control filter-value">');
             break;
             
         case 'Select':
-            console.log("🔍 Обрабатываю поле типа Select с опциями:", fieldInfo.options);
             if (fieldInfo.options) {
                 let selectHtml = '<select class="form-control filter-value">';
                 selectHtml += '<option value="">Выберите значение</option>';
@@ -3661,7 +3711,6 @@ function updateFilterValueField($filterRow, fieldInfo) {
             break;
             
         case 'Link':
-            console.log("🔍 Обрабатываю поле типа Link с целью:", fieldInfo.options);
             if (fieldInfo.options) {
                 const targetDoctype = fieldInfo.options;
                 $valueContainer.html(`
@@ -3679,7 +3728,6 @@ function updateFilterValueField($filterRow, fieldInfo) {
             break;
             
         case 'Check':
-            console.log("🔍 Обрабатываю поле типа Check");
             $valueContainer.html(`
                 <select class="form-control filter-value">
                     <option value="">Выберите значение</option>
@@ -3690,18 +3738,15 @@ function updateFilterValueField($filterRow, fieldInfo) {
             break;
             
         case 'Int':
-            console.log("🔍 Обрабатываю поле типа Int");
             $valueContainer.html('<input type="number" step="1" class="form-control filter-value" placeholder="Значение">');
             break;
             
         case 'Float':
         case 'Currency':
-            console.log("🔍 Обрабатываю числовое поле типа:", fieldInfo.fieldtype);
             $valueContainer.html('<input type="number" step="0.01" class="form-control filter-value" placeholder="Значение">');
             break;
             
         default:
-            console.log("🔍 Обрабатываю поле с типом по умолчанию:", fieldInfo.fieldtype);
             $valueContainer.html('<input type="text" class="form-control filter-value" placeholder="Значение">');
     }
     
@@ -3804,7 +3849,8 @@ function validateUniversalFieldForm($modal) {
 }
 
 function saveUniversalField(frm, values, fieldId = null) {
-    const newFieldId = fieldId || frappe.utils.get_random(10);
+    // Используем имя поля в качестве идентификатора вместо случайной строки
+    const newFieldId = fieldId || values.name.toLowerCase().replace(/[^a-z0-9_]/g, '_');
     
     try {
         let universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
@@ -3840,12 +3886,11 @@ function saveUniversalField(frm, values, fieldId = null) {
             values.filters.forEach(filter => {
                 if (typeof filter.value === 'string' && filter.value === 'doc.ay') {
                     filter.__is_special_ay_field = true;
-                    console.log("🔹 Обнаружен фильтр с использованием специального поля ay:", filter);
                 }
             });
         }
         
-        // Создаем объект универсального поля
+        // Сохраняем информацию о поле в идентификатор, соответствующий имени поля
         universalFields[newFieldId] = {
             name: values.name,
             doctype: values.doctype,
@@ -3863,7 +3908,6 @@ function saveUniversalField(frm, values, fieldId = null) {
         
         renderUniversalFields(frm);
     } catch (error) {
-        console.error("Ошибка при сохранении универсального поля:", error);
         frappe.msgprint({
             title: __('Ошибка'),
             message: __('Не удалось сохранить универсальное поле.'),
@@ -3980,7 +4024,6 @@ function editUniversalField(frm, fieldId) {
 
 // Функция для преобразования выражений формул
 function transform_expression(expression, for_child_table = false, table_name = null) {
-    console.log("🔄 Исходная формула:", expression, "для табличной части:", for_child_table, "таблица:", table_name);
     
     let transformed = expression;
     
@@ -4007,7 +4050,6 @@ function transform_expression(expression, for_child_table = false, table_name =
         // Проверяем использование val() для табличных полей (должны использоваться sum())
         const valTablePattern = new RegExp(`val\\(${tablePrefix}_([^)]+)\\)`, 'g');
         transformed = transformed.replace(valTablePattern, (match, fieldName) => {
-            console.warn(`⚠️ Использование val() для табличного поля. Заменено на sum(): ${match}`);
             return `(frm.doc["${tablePrefix}"] && frm.doc["${tablePrefix}"].reduce((sum, row) => sum + (parseFloat(row["${fieldName}"]) || 0), 0) || 0)`;
         });
     });
@@ -4038,18 +4080,14 @@ function transform_expression(expression, for_child_table = false, table_name =
         
         // Предупреждение, если row() используется вне таблицы
         transformed = transformed.replace(/row\(([^)]+)\)/g, (match, field) => {
-            console.warn("⚠️ Функция row() используется вне контекста табличной части");
             return `0 /* ERROR: row() вне табличной части */`;
         });
     }
     
     // Обработка процентов
     transformed = transformed.replace(/(frm\.doc\["[^"]+"\]|\d+|row\["[^"]+"\])\s*([+\-])\s*(\d+(\.\d+)?)%/g, (match, base, operator, percent) => {
-        console.log("✅ Обнаружен процент в выражении:", match);
         return `${base} ${operator} ((${base} * ${percent}) / 100)`;
     });
-    
-    console.log("🔄 Трансформированная формула:", transformed);
     return transformed;
 }
 
@@ -4080,7 +4118,6 @@ function getTablePrefixes() {
         // Объединяем найденные префиксы с известными
         return [...new Set([...knownPrefixes, ...domPrefixes])];
     } catch (e) {
-        console.warn("⚠️ Ошибка при получении префиксов таблиц из DOM:", e);
         return knownPrefixes;
     }
 }
@@ -4302,7 +4339,6 @@ function processAzerbayjanDateField(docValues) {
         
         // Получаем год из поля il или используем текущий год
         let year = docValues.il || new Date().getFullYear();
-        console.log(`🔹 Обработка специальных полей: ay=${docValues.ay} (${monthNum}), il=${year}`);
         
         // Определяем первый день месяца (1-е число)
         const firstDay = new Date(year, monthNum - 1, 1);
@@ -4314,8 +4350,6 @@ function processAzerbayjanDateField(docValues) {
         const firstDayStr = `${year}.${String(monthNum).padStart(2, '0')}.01`;
         const lastDayStr = `${year}.${String(monthNum).padStart(2, '0')}.${String(lastDay.getDate()).padStart(2, '0')}`;
         
-        console.log(`🔹 Диапазон дат для ${docValues.ay} ${year}: ${firstDayStr} - ${lastDayStr}`);
-        
         // Возвращаем объект с диапазоном дат
         return {
             start: firstDayStr,
@@ -4339,8 +4373,2120 @@ function mapEventToHandler(trigger) {
 
 function isPredefinedEvent(trigger) {
     const predefinedEvents = [
-        "При открытии документа"
+        "При открытии документа",
+        "when_document_opens",
+        "document_opens"
     ];
     
     return predefinedEvents.includes(trigger);
+}
+
+function addTableRowFormulasSection(wrapper) {
+    const tableRowSection = $('<div class="table-row-formulas-section" style="width:100%;margin-top:20px;padding:10px;border:1px solid #ddd;border-radius:5px;"></div>');
+    tableRowSection.append('<h4 style="margin-bottom:10px;display:flex;justify-content:space-between;align-items:center;">Формулы для строк т.ч. <button class="btn btn-sm btn-primary add-table-row-formula"><i class="fa fa-plus"></i> Добавить формулу</button></h4>');
+    tableRowSection.append('<div class="table-row-formulas-list" style="width:100%;"></div>');
+    wrapper.append(tableRowSection);
+}
+
+function createTableRowFormulaModal() {
+    if ($("#table_row_formula_modal").length) {
+        return;
+    }
+
+    const modalHtml = `
+    <div id="table_row_formula_modal" class="modal fade" tabindex="-1" role="dialog">
+        <div class="modal-dialog modal-lg" role="document">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Формула для строки табличной части</h5>
+                    <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                        <span aria-hidden="true">&times;</span>
+                    </button>
+                </div>
+                <div class="modal-body">
+                    <div class="row mb-3">
+                        <div class="col-md-4">
+                            <label for="table_row_table">Табличная часть:</label>
+                            <select id="table_row_table" class="form-control"></select>
+                        </div>
+                        <div class="col-md-4">
+                            <label for="table_row_field">Поле:</label>
+                            <select id="table_row_field" class="form-control" disabled></select>
+                        </div>
+                        <div class="col-md-4">
+                            <label for="table_row_index">Номер строки:</label>
+                            <input type="number" id="table_row_index" class="form-control" min="1" value="1">
+                        </div>
+                    </div>
+                    <div class="formula-workspace">
+                        <div class="formula-result-container">
+                            <div class="formula-result-title">Формула:</div>
+                            <div class="formula-result table-row-formula" contenteditable="true"></div>
+                        </div>
+                        <div class="operators-panel">
+                            <div class="operators-title">Операторы:</div>
+                            <div class="operators-container">
+                                <button class="btn btn-sm operator-btn" data-operator="+">+</button>
+                                <button class="btn btn-sm operator-btn" data-operator="-">-</button>
+                                <button class="btn btn-sm operator-btn" data-operator="*">*</button>
+                                <button class="btn btn-sm operator-btn" data-operator="/">/</button>
+                                <button class="btn btn-sm operator-btn" data-operator="%">%</button>
+                                <button class="btn btn-sm operator-btn" data-operator="(">(</button>
+                                <button class="btn btn-sm operator-btn" data-operator=")">)</button>
+                            </div>
+                        </div>
+                        <div class="fields-panel">
+                            <div class="fields-title">Поля:</div>
+                            <div class="field-groups-container"></div>
+                        </div>
+                    </div>
+                    <div class="triggers-container mt-4">
+                        <div class="trigger-result-title">Обновлять при изменении:</div>
+                        <div class="trigger-result table-row-trigger" contenteditable="true"></div>
+                        <div class="trigger-actions mt-2">
+                            <button class="btn btn-sm btn-info add-predefined-event">
+                                <i class="fa fa-calendar"></i> При открытии документа
+                            </button>
+                            <button class="btn btn-primary btn-sm open-trigger-editor-in-row">
+                                <i class="fa fa-list"></i> Выбрать поле
+                            </button>
+                            <button class="btn btn-warning btn-sm select-table-row-trigger-field">
+                                <i class="fa fa-plus"></i> Выбрать поле строки т.ч.
+                            </button>
+                        </div>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-dismiss="modal">Отмена</button>
+                    <button type="button" class="btn btn-primary save-table-row-formula">Сохранить</button>
+                </div>
+            </div>
+        </div>
+    </div>
+    `;
+
+    $('body').append(modalHtml);
+
+    // Добавляем обработчики для селектов
+    $("#table_row_table").on('change', function() {
+        const selectedTable = $(this).val();
+        if (selectedTable) {
+            loadTableFields(selectedTable);
+            $("#table_row_field").prop('disabled', false);
+        } else {
+            $("#table_row_field").prop('disabled', true).empty().append('<option value="">Выберите поле</option>');
+        }
+    });
+    
+    // Добавляем обработчик для кнопки "При открытии документа"
+    $("#table_row_formula_modal").on('click', '.add-predefined-event', function() {
+        const $triggerContainer = $("#table_row_formula_modal").find(".table-row-trigger");
+        // Используем специальную функцию для добавления предопределенного события
+        addTokenToTriggers("При открытии документа", $triggerContainer, 'event');
+    });
+    
+    // Добавляем обработчик для кнопки "Выбрать поле"
+    $("#table_row_formula_modal").on('click', '.open-trigger-editor-in-row', function() {
+        const $triggerContainer = $("#table_row_formula_modal").find(".table-row-trigger");
+        const frm = cur_frm;
+        
+        // Открываем стандартный редактор триггеров, используя контейнер из модального окна строки таблицы
+        openTriggerFieldsEditorForTableRow(frm, $triggerContainer);
+    });
+}
+
+function loadTablesList(frm) {
+    const $tableSelect = $("#table_row_table");
+    $tableSelect.empty().append('<option value="">Выберите табличную часть</option>');
+    
+    // Получаем все табличные части DocType
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (!meta) return;
+        
+        const tableDoctypes = {};
+        
+        meta.fields.forEach(field => {
+            if (field.fieldtype === 'Table' && field.options) {
+                $tableSelect.append(`<option value="${field.fieldname}" data-doctype="${field.options}">${field.label || field.fieldname}</option>`);
+                tableDoctypes[field.fieldname] = field.options;
+            }
+        });
+        
+        // Сохраняем информацию о DocType для табличных частей
+        $("#table_row_formula_modal").data("table-doctypes", tableDoctypes);
+    });
+}
+
+function loadTableFields(tableName) {
+    const $fieldSelect = $("#table_row_field");
+    $fieldSelect.empty().append('<option value="">Выберите поле</option>');
+    
+    const tableDoctypes = $("#table_row_formula_modal").data("table-doctypes") || {};
+    const doctype = tableDoctypes[tableName];
+    
+    if (!doctype) return;
+    
+    // Получаем поля DocType табличной части
+    frappe.model.with_doctype(doctype, function() {
+        const meta = frappe.get_meta(doctype);
+        if (!meta) return;
+        
+        // Фильтруем только числовые поля для формул
+        const numericTypes = ['Int', 'Float', 'Currency'];
+        meta.fields.forEach(field => {
+            if (field.fieldname && numericTypes.includes(field.fieldtype)) {
+                $fieldSelect.append(`<option value="${field.fieldname}" data-fieldtype="${field.fieldtype}">${field.label || field.fieldname}</option>`);
+            }
+        });
+    });
+}
+
+function openTableRowFormulaModal(frm, formulaId = null) {
+    const $modal = $("#table_row_formula_modal");
+    const $resultContainer = $modal.find(".table-row-formula");
+    const $triggerContainer = $modal.find(".table-row-trigger");
+    
+    // Очистка предыдущих данных
+    $resultContainer.empty();
+    $triggerContainer.empty();
+    $modal.find(".field-groups-container").empty();
+    
+    // Показываем модальное окно с блокировкой контента
+    $modal.find(".modal-content").append('<div class="modal-overlay" style="position:absolute;top:0;left:0;right:0;bottom:0;background:rgba(255,255,255,0.8);z-index:1000;display:flex;align-items:center;justify-content:center;"><div class="text-center"><div class="spinner-border text-primary" role="status"></div><div class="mt-2">Загрузка данных...</div></div></div>');
+    $modal.modal('show');
+    
+    // Используем обещания для последовательной загрузки данных
+    new Promise((resolve) => {
+        // Шаг 1: Получаем информацию о DocType таблиц
+        const table_doctypes = {};
+        getTableDoctypesAsync(frm.doc.target_doctype, table_doctypes, () => {
+            // Сохраняем результат в глобальных данных модального окна
+            $modal.data("table_doctypes", table_doctypes);
+            resolve();
+        });
+    })
+    .then(() => {
+        return new Promise((resolve) => {
+            // Шаг 2: Загружаем список табличных частей
+            loadTablesListAsync(frm, $modal, () => {
+                resolve();
+            });
+        });
+    })
+    .then(() => {
+        // Шаг 3: Если редактируем существующую формулу, загружаем ее данные
+        if (formulaId) {
+            return new Promise((resolve) => {
+                const tableRowFormulas = JSON.parse(frm.doc.table_row_formulas_storage || "{}");
+                const formula = tableRowFormulas[formulaId];
+                
+                if (formula) {
+                    // Заполняем селекты
+                    $("#table_row_table").val(formula.table_name);
+                    
+                    // Загружаем поля выбранной таблицы
+                    loadTableFieldsAsync(formula.table_name, $modal, () => {
+                        $("#table_row_field").val(formula.field_name);
+                        $("#table_row_index").val(formula.row_index);
+                        
+                        // Заполняем формулу и триггеры
+                        parseAndRenderFormula($resultContainer, formula.formula, true);
+                        parseAndRenderTriggers($triggerContainer, formula.triggers);
+                        
+                        $modal.data("formula-id", formulaId);
+                        resolve();
+                    });
+                } else {
+                    resolve();
+                }
+            });
+        }
+    })
+    .then(() => {
+        // Шаг 4: Загружаем поля для формулы
+        return new Promise((resolve) => {
+            populateTableRowFormulaFieldsAsync(frm, $modal, () => {
+                resolve();
+            });
+        });
+    })
+    .then(() => {
+        // Шаг 5: Настраиваем обработчики событий
+        
+        // Обработчики для операторов
+        $modal.find('.operator-btn').off('click').on('click', function() {
+            const operator = $(this).data('operator');
+            addTokenToFormula(operator, 'operator', $resultContainer);
+        });
+        
+        // Обработчик для кнопки сохранения
+        $modal.find('.save-table-row-formula').off('click').on('click', function() {
+            const tableName = $("#table_row_table").val();
+            const fieldName = $("#table_row_field").val();
+            const rowIndex = $("#table_row_index").val();
+            
+            if (!tableName || !fieldName || !rowIndex) {
+                frappe.msgprint({
+                    title: __('Внимание'),
+                    message: __('Выберите табличную часть, поле и укажите номер строки'),
+                    indicator: 'orange'
+                });
+                return;
+            }
+            
+            const formula = getFormulaText($resultContainer);
+            const triggers = getTriggerFieldsText($triggerContainer);
+            
+            // Сохраняем формулу
+            saveTableRowFormula(frm, {
+                table_name: tableName,
+                field_name: fieldName,
+                row_index: rowIndex,
+                formula: formula,
+                triggers: triggers
+            }, $modal.data("formula-id"));
+            
+            $modal.modal('hide');
+        });
+        
+        // Настраиваем перетаскивание и редактирование
+        initDragAndDrop($modal, $resultContainer, true, frm);
+        setupEditableContainer($resultContainer);
+        
+        // Настраиваем drag and drop для триггеров
+        initTriggerDragAndDrop($modal, $triggerContainer);
+        setupTriggerEditableContainer($triggerContainer);
+        
+        // Удаляем блокирующий оверлей
+        $modal.find(".modal-overlay").remove();
+    })
+    .catch((error) => {
+        $modal.find(".modal-overlay").remove();
+        frappe.msgprint({
+            title: __('Ошибка'),
+            message: __('Не удалось загрузить данные для формулы строки таблицы'),
+            indicator: 'red'
+        });
+    });
+}
+
+// Асинхронная функция для получения информации о DocType таблиц с колбэком
+function getTableDoctypesAsync(target_doctype, result_object, callback) {
+    
+    frappe.call({
+        method: "frappe.client.get",
+        args: {
+            doctype: "DocType",
+            name: target_doctype
+        },
+        callback: function(r) {
+            if (r.message && r.message.fields) {
+                r.message.fields.forEach(field => {
+                    if (field.fieldtype === 'Table' && field.options) {
+                        result_object[field.fieldname] = field.options;
+                    }
+                });
+            }
+            
+            // Если данных нет, используем альтернативный способ через meta
+            if (Object.keys(result_object).length === 0) {
+                
+                const meta = frappe.get_meta(target_doctype);
+                if (meta && meta.fields) {
+                    meta.fields.forEach(field => {
+                        if (field.fieldtype === 'Table' && field.options) {
+                            result_object[field.fieldname] = field.options;
+                        }
+                    });
+                }
+            }
+            
+            // Проверяем результат
+            if (Object.keys(result_object).length === 0) {
+            } else {
+            }
+            
+            if (callback) callback();
+        }
+    });
+}
+
+// Асинхронная функция для загрузки списка таблиц с колбэком
+function loadTablesListAsync(frm, $modal, callback) {
+    const $tableSelect = $("#table_row_table");
+    $tableSelect.empty().append('<option value="">Выберите табличную часть</option>');
+    
+    // Получаем все табличные части DocType
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (!meta) {
+            if (callback) callback();
+            return;
+        }
+        
+        const table_doctypes = $modal.data("table_doctypes") || {};
+        
+        meta.fields.forEach(field => {
+            if (field.fieldtype === 'Table' && field.options) {
+                $tableSelect.append(`<option value="${field.fieldname}" data-doctype="${field.options}">${field.label || field.fieldname}</option>`);
+                table_doctypes[field.fieldname] = field.options;
+            }
+        });
+        
+        // Обновляем обработчик для выбора таблицы
+        $("#table_row_table").off('change').on('change', function() {
+            const selectedTable = $(this).val();
+            if (selectedTable) {
+                loadTableFieldsAsync(selectedTable, $modal, null);
+                $("#table_row_field").prop('disabled', false);
+            } else {
+                $("#table_row_field").prop('disabled', true).empty().append('<option value="">Выберите поле</option>');
+            }
+        });
+        
+        if (callback) callback();
+    });
+}
+
+// Асинхронная функция для загрузки полей таблицы с колбэком
+function loadTableFieldsAsync(tableName, $modal, callback) {
+    const $fieldSelect = $("#table_row_field");
+    $fieldSelect.empty().append('<option value="">Выберите поле</option>');
+    
+    if (!tableName) {
+        if (callback) callback();
+        return;
+    }
+    
+    const table_doctypes = $modal.data("table_doctypes") || {};
+    const doctype = table_doctypes[tableName];
+    
+    if (!doctype) {
+        if (callback) callback();
+        return;
+    }
+    
+    // Получаем поля DocType табличной части
+    frappe.model.with_doctype(doctype, function() {
+        const meta = frappe.get_meta(doctype);
+        if (!meta) {
+            if (callback) callback();
+            return;
+        }
+        
+        // Добавляем поля в селект
+        meta.fields.forEach(field => {
+            if (field.fieldname && ['Int', 'Float', 'Currency'].includes(field.fieldtype)) {
+                $fieldSelect.append(`<option value="${field.fieldname}" data-fieldtype="${field.fieldtype}">${field.label || field.fieldname}</option>`);
+            }
+        });
+        
+        // Загружаем поля строки для визуального редактора
+        populateRowFieldsAsync(tableName, $modal, doctype);
+        
+        if (callback) callback();
+    });
+}
+
+// Асинхронная функция для загрузки полей в модальное окно формулы строки таблицы с колбэком
+function populateTableRowFormulaFieldsAsync(frm, $modal, callback) {
+    const $container = $modal.find(".field-groups-container");
+    $container.empty();
+    
+    // Получаем контейнер для формулы
+    const $formulaContainer = $modal.find(".table-row-formula");
+    
+    // 1. Добавляем раздел с полями основного документа
+    const $documentFieldsGroup = $(`
+        <div class="field-group">
+            <div class="field-group-title">Поля документа</div>
+            <div class="field-buttons-container" data-group="document-fields"></div>
+        </div>
+    `);
+    
+    const $documentFieldsContainer = $documentFieldsGroup.find('.field-buttons-container');
+    
+    // Получаем все поля основного документа
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (meta && meta.fields) {
+            meta.fields.forEach(field => {
+                if (field.fieldname && ['Data', 'Int', 'Float', 'Currency', 'Percent'].includes(field.fieldtype)) {
+                    const $fieldBtn = $(`
+                        <button class="btn btn-sm field-btn document-field-btn draggable-item" 
+                            data-fieldname="${field.fieldname}" 
+                            data-label="${field.label || field.fieldname}"
+                            data-group="document-fields"
+                            data-fieldtype="${field.fieldtype}"
+                            draggable="true">
+                            val(${field.fieldname})
+                        </button>
+                    `);
+                    
+                    $documentFieldsContainer.append($fieldBtn);
+                }
+            });
+        }
+        
+        $container.append($documentFieldsGroup);
+        
+        // 2. Добавляем раздел с полями текущей строки таблицы
+        const $rowFieldsGroup = $(`
+            <div class="field-group">
+                <div class="field-group-title">Поля текущей строки</div>
+                <div class="field-buttons-container row-fields-container" data-group="row-fields"></div>
+            </div>
+        `);
+        
+        $container.append($rowFieldsGroup);
+        
+        // 3. Добавляем раздел с универсальными полями
+        if (frm.doc.universal_fields_storage) {
+            const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+            
+            if (Object.keys(universalFields).length > 0) {
+                const $universalFieldGroup = $(`
+                    <div class="field-group">
+                        <div class="field-group-title">Универсальные поля</div>
+                        <div class="field-buttons-container" data-group="universal-fields"></div>
+                    </div>
+                `);
+                
+                const $universalButtonsContainer = $universalFieldGroup.find('.field-buttons-container');
+                
+                Object.keys(universalFields).forEach(fieldId => {
+                    const field = universalFields[fieldId];
+                    
+                    if (!field || !field.name) return;
+                    
+                    const $fieldBtn = $(`
+                        <button class="btn btn-sm universal-field-btn draggable-item" 
+                            data-fieldname="univ(${field.name})" 
+                            data-label="${field.name}"
+                            data-group="universal-fields"
+                            data-field-id="${fieldId}"
+                            draggable="true">
+                            univ(${field.name})
+                        </button>
+                    `);
+                    
+                    $universalButtonsContainer.append($fieldBtn);
+                });
+                
+                $container.append($universalFieldGroup);
+            }
+        }
+        
+        // 4. Добавляем обработчики для кнопок полей
+        $modal.off('click', '.field-btn, .universal-field-btn').on('click', '.field-btn, .universal-field-btn', function() {
+            const fieldText = $(this).text().trim();
+            const fieldType = $(this).hasClass('universal-field-btn') ? 'universal-field' : 'field';
+            
+            // Добавляем в формулу
+            const $token = $(`<span class="formula-token ${fieldType}" data-value="${fieldText}" contenteditable="false" draggable="true">${fieldText}<span class="token-remove">×</span></span>`);
+            $formulaContainer.append($token).append(' ');
+            
+            // Добавляем обработчики к токену
+            addTokenHandlers($formulaContainer);
+        });
+        
+        if (callback) callback();
+    });
+}
+
+// Асинхронная функция для загрузки полей строки таблицы с колбэком
+function populateRowFieldsAsync(tableName, $modal, doctype) {
+    const $rowFieldsContainer = $modal.find('.row-fields-container');
+    $rowFieldsContainer.empty();
+    
+    if (!tableName || !doctype) return;
+    
+    frappe.model.with_doctype(doctype, function() {
+        const childMeta = frappe.get_meta(doctype);
+        if (childMeta && childMeta.fields) {
+            childMeta.fields.forEach(field => {
+                if (field.fieldname && ['Data', 'Int', 'Float', 'Currency', 'Percent'].includes(field.fieldtype)) {
+                    const $fieldBtn = $(`
+                        <button class="btn btn-sm field-btn row-field-btn draggable-item" 
+                            data-fieldname="${field.fieldname}" 
+                            data-label="${field.label || field.fieldname}"
+                            data-group="row-fields"
+                            data-fieldtype="${field.fieldtype}"
+                            draggable="true">
+                            row(${field.fieldname})
+                        </button>
+                    `);
+                    
+                    $rowFieldsContainer.append($fieldBtn);
+                }
+            });
+        }
+    });
+}
+
+// Функция для загрузки полей в модальное окно формулы строки таблицы
+function populateTableRowFormulaFields($modal, frm) {
+    const $container = $modal.find(".field-groups-container");
+    $container.empty();
+    
+    // Получаем контейнер для формулы
+    const $formulaContainer = $modal.find(".table-row-formula");
+    
+    // 1. Добавляем раздел с полями основного документа
+    const $documentFieldsGroup = $(`
+        <div class="field-group">
+            <div class="field-group-title">Поля документа</div>
+            <div class="field-buttons-container" data-group="document-fields"></div>
+        </div>
+    `);
+    
+    const $documentFieldsContainer = $documentFieldsGroup.find('.field-buttons-container');
+    
+    // Получаем все поля основного документа
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (meta && meta.fields) {
+            meta.fields.forEach(field => {
+                if (field.fieldname && ['Data', 'Int', 'Float', 'Currency', 'Percent'].includes(field.fieldtype)) {
+                    const $fieldBtn = $(`
+                        <button class="btn btn-sm field-btn document-field-btn draggable-item" 
+                            data-fieldname="${field.fieldname}" 
+                            data-label="${field.label || field.fieldname}"
+                            data-group="document-fields"
+                            data-fieldtype="${field.fieldtype}"
+                            draggable="true">
+                            val(${field.fieldname})
+                        </button>
+                    `);
+                    
+                    $documentFieldsContainer.append($fieldBtn);
+                }
+            });
+        }
+    });
+    
+    $container.append($documentFieldsGroup);
+    
+    // 2. Добавляем раздел с полями текущей строки таблицы
+    const $rowFieldsGroup = $(`
+        <div class="field-group">
+            <div class="field-group-title">Поля текущей строки</div>
+            <div class="field-buttons-container row-fields-container" data-group="row-fields"></div>
+        </div>
+    `);
+    
+    $container.append($rowFieldsGroup);
+    
+    // Обработчик для выбора таблицы, чтобы показать поля строки
+    $("#table_row_table").on('change', function() {
+        const selectedTable = $(this).val();
+        if (!selectedTable) return;
+        
+        const $rowFieldsContainer = $rowFieldsGroup.find('.field-buttons-container');
+        $rowFieldsContainer.empty();
+        
+        // Получаем DocType для выбранной таблицы
+        const table_doctypes = {};
+        getTableDoctypes(frm.doc.target_doctype, table_doctypes);
+        const childDoctype = table_doctypes[selectedTable];
+        
+        if (childDoctype) {
+            frappe.model.with_doctype(childDoctype, function() {
+                const childMeta = frappe.get_meta(childDoctype);
+                if (childMeta && childMeta.fields) {
+                    childMeta.fields.forEach(field => {
+                        if (field.fieldname && ['Data', 'Int', 'Float', 'Currency', 'Percent'].includes(field.fieldtype)) {
+                            const $fieldBtn = $(`
+                                <button class="btn btn-sm field-btn row-field-btn draggable-item" 
+                                    data-fieldname="${field.fieldname}" 
+                                    data-label="${field.label || field.fieldname}"
+                                    data-group="row-fields"
+                                    data-fieldtype="${field.fieldtype}"
+                                    draggable="true">
+                                    row(${field.fieldname})
+                                </button>
+                            `);
+                            
+                            $rowFieldsContainer.append($fieldBtn);
+                        }
+                    });
+                }
+            });
+        }
+    });
+    
+    // 3. Добавляем раздел с универсальными полями
+    if (frm.doc.universal_fields_storage) {
+        const universalFields = JSON.parse(frm.doc.universal_fields_storage || "{}");
+        
+        if (Object.keys(universalFields).length > 0) {
+            const $universalFieldGroup = $(`
+                <div class="field-group">
+                    <div class="field-group-title">Универсальные поля</div>
+                    <div class="field-buttons-container" data-group="universal-fields"></div>
+                </div>
+            `);
+            
+            const $universalButtonsContainer = $universalFieldGroup.find('.field-buttons-container');
+            
+            Object.keys(universalFields).forEach(fieldId => {
+                const field = universalFields[fieldId];
+                
+                if (!field || !field.name) return;
+                
+                const $fieldBtn = $(`
+                    <button class="btn btn-sm universal-field-btn draggable-item" 
+                        data-fieldname="univ(${field.name})" 
+                        data-label="${field.name}"
+                        data-group="universal-fields"
+                        data-field-id="${fieldId}"
+                        draggable="true">
+                        univ(${field.name})
+                    </button>
+                `);
+                
+                $universalButtonsContainer.append($fieldBtn);
+            });
+            
+            $container.append($universalFieldGroup);
+        }
+    }
+    
+    // 4. Добавляем обработчики для кнопок полей
+    $modal.off('click', '.field-btn, .universal-field-btn').on('click', '.field-btn, .universal-field-btn', function() {
+        const fieldText = $(this).text().trim();
+        const fieldType = $(this).hasClass('universal-field-btn') ? 'universal-field' : 'field';
+        
+        // Добавляем в формулу
+        const $token = $(`<span class="formula-token ${fieldType}" data-value="${fieldText}" contenteditable="false" draggable="true">${fieldText}<span class="token-remove">×</span></span>`);
+        $formulaContainer.append($token).append(' ');
+        
+        // Добавляем обработчики к токену
+        addTokenHandlers($formulaContainer);
+    });
+}
+
+function saveTableRowFormula(frm, formulaData, formulaId = null) {
+    const newFormulaId = formulaId || frappe.utils.get_random(10);
+    
+    try {
+        let tableRowFormulas = JSON.parse(frm.doc.table_row_formulas_storage || "{}");
+        
+        // Сохраняем формулу
+        tableRowFormulas[newFormulaId] = formulaData;
+        
+        // Обновляем значение в форме
+        frm.set_value("table_row_formulas_storage", JSON.stringify(tableRowFormulas));
+        
+        frappe.show_alert({
+            message: __('Формула для строки табличной части сохранена'),
+            indicator: 'green'
+        });
+        
+        // Обновляем список формул
+        renderTableRowFormulas(frm);
+    } catch (error) {
+        frappe.msgprint({
+            title: __('Ошибка'),
+            message: __('Не удалось сохранить формулу для строки табличной части.'),
+            indicator: 'red'
+        });
+    }
+}
+
+function renderTableRowFormulas(frm) {
+    const $container = $(frm.wrapper).find('.table-row-formulas-list');
+    $container.empty();
+    
+    try {
+        const tableRowFormulas = JSON.parse(frm.doc.table_row_formulas_storage || "{}");
+        
+        if (Object.keys(tableRowFormulas).length === 0) {
+            $container.append('<div class="text-muted">Нет формул для строк табличных частей. Нажмите "Добавить формулу" для создания.</div>');
+            return;
+        }
+        
+        // Создаем таблицу для списка формул
+        const $table = $(`
+            <table class="table table-bordered">
+                <thead>
+                    <tr>
+                        <th>Табличная часть</th>
+                        <th>Поле</th>
+                        <th>Строка</th>
+                        <th>Формула</th>
+                        <th>Обновлять при изменении</th>
+                        <th>Действия</th>
+                    </tr>
+                </thead>
+                <tbody></tbody>
+            </table>
+        `);
+        
+        const $tbody = $table.find('tbody');
+        
+        // Добавляем формулы в таблицу
+        Object.keys(tableRowFormulas).forEach(formulaId => {
+            const formula = tableRowFormulas[formulaId];
+            
+            const $row = $(`
+                <tr>
+                    <td>${formula.table_name}</td>
+                    <td>${formula.field_name}</td>
+                    <td>${formula.row_index}</td>
+                    <td>${formula.formula}</td>
+                    <td>${formula.triggers || '-'}</td>
+                    <td>
+                        <button class="btn btn-xs btn-primary edit-table-row-formula" data-formula-id="${formulaId}"><i class="fa fa-pencil"></i></button>
+                        <button class="btn btn-xs btn-danger delete-table-row-formula" data-formula-id="${formulaId}"><i class="fa fa-trash"></i></button>
+                    </td>
+                </tr>
+            `);
+            
+            $tbody.append($row);
+        });
+        
+        $container.append($table);
+    } catch (error) {
+        $container.append('<div class="text-danger">Ошибка при загрузке формул для строк табличных частей.</div>');
+    }
+}
+
+function deleteTableRowFormula(frm, formulaId) {
+    frappe.confirm(
+        'Вы уверены, что хотите удалить эту формулу для строки табличной части?',
+        function() {
+            try {
+                let tableRowFormulas = JSON.parse(frm.doc.table_row_formulas_storage || "{}");
+                delete tableRowFormulas[formulaId];
+                frm.set_value("table_row_formulas_storage", JSON.stringify(tableRowFormulas));
+                
+                // Перерисовываем список формул
+                renderTableRowFormulas(frm);
+                
+                frappe.show_alert({
+                    message: __('Формула для строки табличной части удалена'),
+                    indicator: 'green'
+                });
+            } catch (error) {
+                frappe.msgprint({
+                    title: __('Ошибка'),
+                    message: __('Не удалось удалить формулу для строки табличной части.'),
+                    indicator: 'red'
+                });
+            }
+        }
+    );
+}
+
+function initTableRowFormulas(frm) {
+    // Если хранилище формул не существует, создаем его
+    if (!frm.doc.table_row_formulas_storage) {
+        frm.set_value("table_row_formulas_storage", "{}");
+    }
+    
+    // Создаем модальное окно, если его еще нет
+    createTableRowFormulaModal();
+    
+    // Обработчик для кнопки добавления новой формулы
+    $(frm.wrapper).on('click', '.add-table-row-formula', function() {
+        openTableRowFormulaModal(frm);
+    });
+    
+    // Обработчик для кнопки редактирования формулы
+    $(frm.wrapper).on('click', '.edit-table-row-formula', function() {
+        const formulaId = $(this).data('formula-id');
+        openTableRowFormulaModal(frm, formulaId);
+    });
+    
+    // Обработчик для кнопки удаления формулы
+    $(frm.wrapper).on('click', '.delete-table-row-formula', function() {
+        const formulaId = $(this).data('formula-id');
+        deleteTableRowFormula(frm, formulaId);
+    });
+    
+    // Отображаем существующие формулы
+    renderTableRowFormulas(frm);
+}
+
+function populateTableRowFields($modal, frm) {
+    const $container = $modal.find(".field-groups-container");
+    
+    // Получаем информацию о табличных частях
+    const tableDoctypes = {};
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (!meta) return;
+        
+        meta.fields.forEach(field => {
+            if (field.fieldtype === 'Table' && field.options) {
+                tableDoctypes[field.fieldname] = field.options;
+            }
+        });
+        
+        // Для каждой табличной части создаем группу полей строк
+        Object.keys(tableDoctypes).forEach(tableName => {
+            const childDoctype = tableDoctypes[tableName];
+            
+            // Получаем поля дочернего DocType
+            frappe.model.with_doctype(childDoctype, function() {
+                const childMeta = frappe.get_meta(childDoctype);
+                if (!childMeta) return;
+                
+                // Максимальное количество строк для предпросмотра
+                const maxRows = 25;
+                
+                // Создаем группы для каждой строки
+                for (let rowIndex = 1; rowIndex <= maxRows; rowIndex++) {
+                    const groupName = `${tableName} (Строка ${rowIndex})`;
+                    
+                    const $fieldGroup = $(`
+                        <div class="field-group table-row-field-group">
+                            <div class="field-group-title" data-table="${tableName}" data-row="${rowIndex}">${groupName}</div>
+                            <div class="field-buttons-container" data-group="${groupName}" data-table="${tableName}" data-row="${rowIndex}"></div>
+                        </div>
+                    `);
+                    
+                    const $buttonsContainer = $fieldGroup.find('.field-buttons-container');
+                    
+                    // Добавляем поля для строки
+                    childMeta.fields.forEach(field => {
+                        if (field.fieldname && ['Int', 'Float', 'Currency', 'Data', 'Text', 'Date'].includes(field.fieldtype)) {
+                            const fieldId = `${tableName}_row_${rowIndex}_${field.fieldname}`;
+                            const $fieldBtn = $(`
+                                <button class="btn btn-sm field-btn draggable-item" 
+                                    data-fieldname="${fieldId}" 
+                                    data-label="${field.label || field.fieldname}"
+                                    data-group="${groupName}"
+                                    data-table="${tableName}"
+                                    data-row="${rowIndex}"
+                                    data-field="${field.fieldname}"
+                                    draggable="true">
+                                    ${field.label || field.fieldname}
+                                </button>
+                            `);
+                            
+                            $buttonsContainer.append($fieldBtn);
+                        }
+                    });
+                    
+                    // Добавляем группу только если есть хотя бы одно поле
+                    if ($buttonsContainer.children().length > 0) {
+                        // Изначально скрываем группу, будем показывать по клику на заголовок
+                        $buttonsContainer.hide();
+                        $container.append($fieldGroup);
+                        
+                        // Добавляем обработчик для отображения/скрытия полей по клику на заголовок
+                        $fieldGroup.find('.field-group-title').on('click', function() {
+                            $(this).siblings('.field-buttons-container').toggle();
+                        });
+                    }
+                }
+            });
+        });
+    });
+}
+
+function populateTableRowTriggerFields($modal, frm) {
+    const $container = $modal.find(".trigger-field-groups-container");
+    
+    // Получаем информацию о табличных частях
+    const tableDoctypes = {};
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (!meta) return;
+        
+        meta.fields.forEach(field => {
+            if (field.fieldtype === 'Table' && field.options) {
+                tableDoctypes[field.fieldname] = field.options;
+            }
+        });
+        
+        // Для каждой табличной части создаем группу полей строк
+        Object.keys(tableDoctypes).forEach(tableName => {
+            const childDoctype = tableDoctypes[tableName];
+            
+            // Получаем поля дочернего DocType
+            frappe.model.with_doctype(childDoctype, function() {
+                const childMeta = frappe.get_meta(childDoctype);
+                if (!childMeta) return;
+                
+                // Максимальное количество строк для предпросмотра
+                const maxRows = 25;
+                
+                // Создаем группы для каждой строки
+                for (let rowIndex = 1; rowIndex <= maxRows; rowIndex++) {
+                    const groupName = `${tableName} (Строка ${rowIndex})`;
+                    
+                    const $fieldGroup = $(`
+                        <div class="trigger-field-group table-row-field-group">
+                            <div class="trigger-field-group-title" data-table="${tableName}" data-row="${rowIndex}">${groupName}</div>
+                            <div class="trigger-field-buttons-container" data-group="${groupName}" data-table="${tableName}" data-row="${rowIndex}"></div>
+                        </div>
+                    `);
+                    
+                    const $buttonsContainer = $fieldGroup.find('.trigger-field-buttons-container');
+                    
+                    // Добавляем поля для строки
+                    childMeta.fields.forEach(field => {
+                        if (field.fieldname) {
+                            const fieldId = `${tableName}_row_${rowIndex}_${field.fieldname}`;
+                            const $fieldBtn = $(`
+                                <button class="btn btn-sm trigger-field-btn draggable-item" 
+                                    data-fieldname="${fieldId}" 
+                                    data-label="${field.label || field.fieldname}"
+                                    data-group="${groupName}"
+                                    data-table="${tableName}"
+                                    data-row="${rowIndex}"
+                                    data-field="${field.fieldname}"
+                                    draggable="true">
+                                    ${field.label || field.fieldname}
+                                </button>
+                            `);
+                            
+                            $buttonsContainer.append($fieldBtn);
+                        }
+                    });
+                    
+                    // Добавляем группу только если есть хотя бы одно поле
+                    if ($buttonsContainer.children().length > 0) {
+                        // Изначально скрываем группу, будем показывать по клику на заголовок
+                        $buttonsContainer.hide();
+                        $container.append($fieldGroup);
+                        
+                        // Добавляем обработчик для отображения/скрытия полей по клику на заголовок
+                        $fieldGroup.find('.trigger-field-group-title').on('click', function() {
+                            $(this).siblings('.trigger-field-buttons-container').toggle();
+                        });
+                    }
+                }
+            });
+        });
+    });
+}
+
+function addTableRowFieldsStyles() {
+    if ($('#table-row-fields-styles').length) return;
+    
+    const styles = `
+    <style id="table-row-fields-styles">
+        .table-row-field-group .field-group-title,
+        .table-row-field-group .trigger-field-group-title {
+            cursor: pointer;
+            background-color: #f8f9fa;
+            padding: 5px;
+            border-radius: 3px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .table-row-field-group .field-group-title:after,
+        .table-row-field-group .trigger-field-group-title:after {
+            content: '▼';
+            font-size: 10px;
+            margin-left: 5px;
+        }
+        
+        .table-row-field-group .field-group-title:hover,
+        .table-row-field-group .trigger-field-group-title:hover {
+            background-color: #e9ecef;
+        }
+    </style>`;
+    
+    $('head').append(styles);
+}
+
+function createTableRowFieldSelectorModal() {
+    if ($("#table_row_field_selector_modal").length) {
+        return;
+    }
+
+    const modalHtml = `
+    <div id="table_row_field_selector_modal" class="modal fade" tabindex="-1" role="dialog">
+        <div class="modal-dialog" role="document">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Выбор поля строки табличной части</h5>
+                    <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                        <span aria-hidden="true">&times;</span>
+                    </button>
+                </div>
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label for="row_field_table">Табличная часть:</label>
+                        <select id="row_field_table" class="form-control"></select>
+                    </div>
+                    <div class="form-group">
+                        <label for="row_field_name">Поле:</label>
+                        <select id="row_field_name" class="form-control" disabled></select>
+                    </div>
+                    <div class="form-group">
+                        <label for="row_field_index">Номер строки:</label>
+                        <input type="number" id="row_field_index" class="form-control" min="1" value="1">
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-dismiss="modal">Отмена</button>
+                    <button type="button" class="btn btn-primary add-table-row-field">Добавить поле</button>
+                </div>
+            </div>
+        </div>
+    </div>
+    `;
+
+    $('body').append(modalHtml);
+
+    // Обработчики для селекторов
+    $("#row_field_table").on('change', function() {
+        const selectedTable = $(this).val();
+        if (selectedTable) {
+            loadTableFieldsForSelector(selectedTable);
+            $("#row_field_name").prop('disabled', false);
+        } else {
+            $("#row_field_name").prop('disabled', true).empty().append('<option value="">Выберите поле</option>');
+        }
+    });
+}
+
+function loadTableFieldsForSelector(tableName) {
+    const $fieldSelect = $("#row_field_name");
+    $fieldSelect.empty().append('<option value="">Выберите поле</option>');
+    
+    const tableDoctypes = $("#table_row_field_selector_modal").data("table-doctypes") || {};
+    const doctype = tableDoctypes[tableName];
+    
+    if (!doctype) return;
+    
+    // Получаем поля DocType табличной части
+    frappe.model.with_doctype(doctype, function() {
+        const meta = frappe.get_meta(doctype);
+        if (!meta) return;
+        
+        // Добавляем все поля, которые могут быть использованы в формулах и триггерах
+        const validTypes = ['Int', 'Float', 'Currency', 'Data', 'Text', 'Date', 'Datetime', 'Check', 'Link', 'Select'];
+        meta.fields.forEach(field => {
+            if (field.fieldname && validTypes.includes(field.fieldtype)) {
+                $fieldSelect.append(`<option value="${field.fieldname}" data-fieldtype="${field.fieldtype}">${field.label || field.fieldname}</option>`);
+            }
+        });
+    });
+}
+
+function loadTablesListForSelector(frm) {
+    const $tableSelect = $("#row_field_table");
+    $tableSelect.empty().append('<option value="">Выберите табличную часть</option>');
+    
+    // Получаем все табличные части DocType
+    frappe.model.with_doctype(frm.doc.target_doctype, function() {
+        const meta = frappe.get_meta(frm.doc.target_doctype);
+        if (!meta) return;
+        
+        const tableDoctypes = {};
+        
+        meta.fields.forEach(field => {
+            if (field.fieldtype === 'Table' && field.options) {
+                $tableSelect.append(`<option value="${field.fieldname}" data-doctype="${field.options}">${field.label || field.fieldname}</option>`);
+                tableDoctypes[field.fieldname] = field.options;
+            }
+        });
+        
+        // Сохраняем информацию о DocType для табличных частей
+        $("#table_row_field_selector_modal").data("table-doctypes", tableDoctypes);
+    });
+}
+
+function openTableRowFieldSelector(frm, targetContainer, isForTrigger = false) {
+    const $modal = $("#table_row_field_selector_modal");
+    
+    // Сбрасываем форму
+    $("#row_field_table").val('');
+    $("#row_field_name").empty().append('<option value="">Выберите поле</option>').prop('disabled', true);
+    $("#row_field_index").val(1);
+    
+    // Загружаем список табличных частей
+    loadTablesListForSelector(frm);
+    
+    // Сохраняем информацию о целевом контейнере и типе (формула или триггер)
+    $modal.data("target-container", targetContainer);
+    $modal.data("is-trigger", isForTrigger);
+    $modal.data("frm", frm);
+    
+    // Обработчик для кнопки добавления
+    $modal.find('.add-table-row-field').off('click').on('click', function() {
+        const tableName = $("#row_field_table").val();
+        const fieldName = $("#row_field_name").val();
+        const rowIndex = $("#row_field_index").val();
+        
+        if (!tableName || !fieldName || !rowIndex) {
+            frappe.msgprint({
+                title: __('Внимание'),
+                message: __('Выберите табличную часть, поле и укажите номер строки'),
+                indicator: 'orange'
+            });
+            return;
+        }
+        
+        const fieldId = `${tableName}_row_${rowIndex}_${fieldName}`;
+        const $container = $($modal.data("target-container"));
+        const isForTrigger = $modal.data("is-trigger");
+        
+        if (isForTrigger) {
+            // Добавляем поле как триггер
+            addTokenToTriggers(fieldId, $container, 'table-row');
+        } else {
+            // Добавляем поле в формулу
+            addTokenToFormula(fieldId, 'field', $container);
+        }
+        
+        $modal.modal('hide');
+    });
+    
+    // Показываем модальное окно
+    $modal.modal('show');
+}
+
+function generateTableRowFormulasHandlers(table_row_formulas, functions, target_doctype, universal_fields) {
+    // Создаем функцию для инициализации формул строк табличных частей
+    let initFunction = `
+// Функция для инициализации формул строк табличных частей
+function initialize_table_row_formulas(frm) {
+    
+    // Получаем информацию о формулах для строк табличных частей
+    const formulas = ${JSON.stringify(table_row_formulas)};
+    
+    // Группируем формулы по табличным частям
+    const formulasByTable = {};
+    Object.keys(formulas).forEach(formulaId => {
+        const formula = formulas[formulaId];
+        const tableName = formula.table_name;
+        
+        if (!formulasByTable[tableName]) {
+            formulasByTable[tableName] = [];
+        }
+        
+        formulasByTable[tableName].push(formula);
+    });
+    
+    // Устанавливаем обработчики для каждой табличной части
+    Object.keys(formulasByTable).forEach(tableName => {
+        if (!frm.doc[tableName]) {
+            return;
+        }
+        
+        // Проходим по строкам табличной части
+        frm.doc[tableName].forEach((row, rowIndex) => {
+            // Находим формулы для данной строки с триггером "При открытии документа"
+            const rowFormulas = formulasByTable[tableName].filter(formula => 
+                parseInt(formula.row_index) === rowIndex + 1 &&
+                formula.triggers && formula.triggers.split(',').map(t => t.trim()).includes("При открытии документа")
+            );
+            
+            // Вычисляем формулы для строки только если у них есть триггер "При открытии документа"
+            rowFormulas.forEach(formula => {
+                try {
+                    
+                    calculate_table_row_field(frm, tableName, rowIndex, formula.field_name, formula.formula);
+                } catch (error) {
+                }
+            });
+        });
+    });
+}`;
+    
+    functions.push(initFunction);
+    
+    // Создаем функцию для расчета значения поля строки таблицы
+    let calculateFunction = `
+// Функция для расчета значения поля в строке табличной части
+function calculate_table_row_field(frm, tableName, rowIndex, fieldName, formula, triggerField) {
+    
+    try {
+        // Проверяем наличие таблицы и строки
+        if (!frm.doc[tableName]) {
+            return;
+        }
+        
+        if (!frm.doc[tableName][rowIndex]) {
+            return;
+        }
+        
+        // Получаем строку таблицы
+        const row = frm.doc[tableName][rowIndex];
+        
+        // Получаем сетевое имя cdt и cdn для Frappe
+        const cdt = frm.fields_dict[tableName].grid.doctype;
+        const cdn = row.name;
+        
+        // Заменяем val() для полей документа
+        let modifiedFormula = formula.replace(/val\\(([^)]+)\\)/g, (match, fieldName) => {
+            return \`(parseFloat(frm.doc["\${fieldName}"]) || 0)\`;
+        });
+        
+        // Заменяем row() для полей строки таблицы
+        modifiedFormula = modifiedFormula.replace(/row\\(([^)]+)\\)/g, (match, fieldName) => {
+            return \`(parseFloat(row["\${fieldName}"]) || 0)\`;
+        });
+        
+        // Проверяем наличие универсальных полей в документе
+        if (frm.doc.__universalFields) {
+            
+            // Для прямого доступа к данным универсальных полей
+            const universalFieldValues = frm.doc.__universalFields;
+            
+            // Получаем хранилище универсальных полей для имен полей
+            let universalFieldDefs = {};
+            try {
+                // Разбираем хранилище определений полей, если оно есть
+                if (frm.doc.universal_fields_storage && typeof frm.doc.universal_fields_storage === 'string') {
+                    universalFieldDefs = JSON.parse(frm.doc.universal_fields_storage);
+                } else {
+                }
+                
+                // Создаем карту соответствия имен полей и их ID
+                const fieldNameToId = {};
+                Object.keys(universalFieldDefs).forEach(fieldId => {
+                    const field = universalFieldDefs[fieldId];
+                    if (field && field.name) {
+                        fieldNameToId[field.name] = fieldId;
+                    }
+                });
+                
+                // Ищем univ() в формуле
+                const univPattern = /univ\\(([^)]+)\\)/g;
+                let match;
+                let resultFormula = modifiedFormula;
+                
+                // Для каждого найденного univ() в формуле
+                while ((match = univPattern.exec(formula)) !== null) {
+                    const fieldName = match[1]; // Имя поля внутри univ()
+                    const fullMatch = match[0]; // Полное совпадение univ(Name)
+                    
+                    // Сначала пытаемся найти поле по имени через карту
+                    let fieldId = fieldNameToId[fieldName];
+                    let fieldValue;
+                    
+                    // Если нашли ID и есть значение
+                    if (fieldId && universalFieldValues[fieldId] !== undefined) {
+                        fieldValue = universalFieldValues[fieldId];
+                    } else {
+                        // Проверяем, если имя поля используется напрямую как ID
+                        if (universalFieldValues[fieldName] !== undefined) {
+                            fieldValue = universalFieldValues[fieldName];
+                        } else {
+                            // Если не нашли ни через карту, ни напрямую, попробуем поискать по всем полям
+                            
+                            // Поиск ID по имени поля без учета регистра
+                            const lowerFieldName = fieldName.toLowerCase();
+                            for (const id in universalFieldDefs) {
+                                const field = universalFieldDefs[id];
+                                if (field && field.name && field.name.toLowerCase() === lowerFieldName) {
+                                    fieldId = id;
+                                    fieldValue = universalFieldValues[id];
+                                    break;
+                                }
+                            }
+                            
+                            // Если все еще не нашли, ищем первое доступное значение
+                            if (fieldValue === undefined && Object.keys(universalFieldValues).length > 0) {
+                                // Получаем первый доступный ID и его значение
+                                const firstId = Object.keys(universalFieldValues)[0];
+                                fieldValue = universalFieldValues[firstId];
+                            }
+                        }
+                        
+                        // Если все равно нет значения, используем 0
+                        if (fieldValue === undefined) {
+                            fieldValue = 0;
+                        }
+                    }
+                    
+                    // Заменяем в формуле
+                    resultFormula = resultFormula.replace(fullMatch, fieldValue);
+                }
+                
+                modifiedFormula = resultFormula;
+            } catch (error) {
+            }
+        } else {
+        }
+        
+        // После всех замен проверяем, остались ли необработанные univ()
+        if (modifiedFormula.includes("univ(")) {
+            
+            // Используем простую замену по регулярному выражению
+            modifiedFormula = modifiedFormula.replace(/univ\\([^)]+\\)/g, "0");
+        }
+        
+        // Выполняем формулу
+        let result = eval(modifiedFormula);
+        
+        // Убедимся, что результат - число, а не NaN
+        if (isNaN(result)) {
+            result = 0;
+        }
+        
+        // Обновляем значение поля в строке
+        row[fieldName] = result;
+        
+        // Обновляем отображение таблицы
+        frm.refresh_field(tableName);
+        
+        // Вызываем событие изменения поля для возможных цепочек зависимостей
+        if (frappe.ui.form.handlers[cdt] && frappe.ui.form.handlers[cdt][fieldName]) {
+            frappe.ui.form.handlers[cdt][fieldName].forEach(handler => {
+                handler.call(row, { frm: frm, cdt: cdt, cdn: cdn });
+            });
+        }
+    } catch (error) {
+    }
+}`;
+    
+    functions.push(calculateFunction);
+    
+    // Функция для получения индекса строки таблицы
+    let getRowIndexFunction = `
+// Функция для получения индекса строки по её имени
+function get_row_index(frm, tableName, rowName) {
+    
+    // Проверяем наличие таблицы
+    if (!frm.doc[tableName]) {
+        return -1;
+    }
+    
+    // Ищем индекс строки по имени
+    for (let i = 0; i < frm.doc[tableName].length; i++) {
+        if (frm.doc[tableName][i].name === rowName) {
+            return i;
+        }
+    }
+    return -1;
+}`;
+    
+    functions.push(getRowIndexFunction);
+    
+    return functions;
+}
+
+// Функция для добавления обработчиков событий табличных частей
+function addTableRowFormulaHandlers(main_script, table_row_formulas, table_doctypes) {
+    // Группируем формулы по таблицам и полям-триггерам
+    const handlers = {};
+    
+    // Специальное хранилище для триггеров в основном документе
+    const mainDocumentTriggers = {};
+    
+    Object.values(table_row_formulas).forEach(formula => {
+        const tableName = formula.table_name;
+        const rowIndex = parseInt(formula.row_index);
+        const usesUniversal = formula.formula && formula.formula.includes("univ(");
+        
+        if (!handlers[tableName]) {
+            handlers[tableName] = {
+                childDoctype: table_doctypes[tableName] || `Item`,
+                triggers: {}
+            };
+        }
+        
+// Если есть триггеры, добавляем их
+        if (formula.triggers) {
+            const triggers = formula.triggers.split(',').map(t => t.trim());
+            
+            triggers.forEach(trigger => {
+                if (!trigger || trigger === "При открытии документа") return;
+                
+                // Проверяем, если триггер уже существует в основном документе
+                if (trigger && !trigger.includes('_')) {
+                    // Это может быть поле основного документа
+                    if (!mainDocumentTriggers[trigger]) {
+                        mainDocumentTriggers[trigger] = [];
+                    }
+                    
+                    mainDocumentTriggers[trigger].push({
+                        tableName: tableName,
+                        rowIndex: rowIndex,
+                        fieldName: formula.field_name,
+                        formula: formula.formula,
+                        usesUniversal: usesUniversal
+                    });
+                } else {
+                    // Это обычный триггер табличной части
+                    if (!handlers[tableName].triggers[trigger]) {
+                        handlers[tableName].triggers[trigger] = [];
+                    }
+                    
+                    handlers[tableName].triggers[trigger].push({
+                        rowIndex: rowIndex,
+                        fieldName: formula.field_name,
+                        formula: formula.formula,
+                        usesUniversal: usesUniversal
+                    });
+                }
+            });
+        }
+    });
+    
+    // Добавляем обработчики для полей основного документа
+    Object.keys(mainDocumentTriggers).forEach(trigger => {
+        const hasUniversalField = mainDocumentTriggers[trigger].some(formula => formula.usesUniversal);
+        
+        main_script += `
+    "${trigger}": ${hasUniversalField ? 'async ' : ''}function(frm) {
+        
+        ${hasUniversalField ? 'await calculate_universal_fields(frm);' : '// Универсальные поля не используются'}
+        
+        // Обрабатываем формулы для строк табличных частей
+        ${mainDocumentTriggers[trigger].map(formula => `
+        // Проверяем строку ${formula.rowIndex} в таблице ${formula.tableName}
+        if (frm.doc.${formula.tableName} && frm.doc.${formula.tableName}.length >= ${formula.rowIndex}) {
+            try {
+                // Индекс строки на 1 меньше номера строки
+                const rowIndex = ${formula.rowIndex - 1};
+                const formula = "${formula.formula}";
+                
+                calculate_table_row_field(frm, "${formula.tableName}", rowIndex, "${formula.fieldName}", formula, "${trigger}");
+            } catch (error) {
+            }
+        } else {
+        }`).join('\n')}
+    },
+`;
+    });
+    
+    // Добавляем обработчики для событий add_row и remove_row для каждой таблицы
+    Object.keys(handlers).forEach(tableName => {
+        main_script += `
+    "${tableName}_add": function(frm, cdt, cdn) {
+        // Обновляем индексы строк после добавления новой строки
+        setTimeout(() => initialize_table_row_formulas(frm), 100);
+    },
+    
+    "${tableName}_remove": function(frm, cdt, cdn) {
+        // Обновляем индексы строк после удаления строки
+        setTimeout(() => initialize_table_row_formulas(frm), 100);
+    },
+`;
+    });
+    
+    return main_script;
+}
+
+// Функция для получения индекса строки в табличной части
+function generateTableRowAccessFunction() {
+    return `
+// Функция для получения индекса строки по её имени (name/cdn)
+function get_row_index(frm, tableName, rowName) {
+    
+    // Проверяем наличие таблицы
+    if (!frm.doc[tableName]) {
+        return -1;
+    }
+    
+    // Выводим все строки для отладки
+    frm.doc[tableName].forEach((row, idx) => {
+    });
+    
+    // Ищем индекс строки по имени
+    for (let i = 0; i < frm.doc[tableName].length; i++) {
+        if (frm.doc[tableName][i].name === rowName) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+// Функция для доступа к полям конкретных строк таблицы
+function table_row(tableName, rowIndex, fieldName) {
+    // Проверяем наличие необходимых аргументов
+    if (!tableName || rowIndex === undefined || !fieldName) {
+        return 0;
+    }
+    
+    // Преобразуем rowIndex в число (на случай, если передана строка)
+    const rowIdx = parseInt(rowIndex) - 1; // Индексация с 1 для пользователя, но с 0 в массиве
+    
+    try {
+        // Проверяем наличие таблицы и строки
+        if (!frm.doc[tableName] || !frm.doc[tableName][rowIdx]) {
+            return 0;
+        }
+        
+        // Получаем значение поля
+        const value = frm.doc[tableName][rowIdx][fieldName];
+        
+        // Проверяем на NaN и возвращаем значение или 0
+        const numValue = parseFloat(value);
+        if (isNaN(numValue)) {
+            return 0;
+        }
+        return numValue;
+    } catch (error) {
+        return 0;
+    }
+}
+
+// Функция для обновления значения поля конкретной строки таблицы
+function set_table_row(frm, tableName, rowIndex, fieldName, value) {
+    // Проверяем наличие необходимых аргументов
+    if (!frm || !tableName || rowIndex === undefined || !fieldName) {
+        return false;
+    }
+    
+    // Преобразуем rowIndex в число (на случай, если передана строка)
+    const rowIdx = parseInt(rowIndex) - 1; // Индексация с 1 для пользователя, но с 0 в массиве
+    
+    try {
+        // Проверяем наличие таблицы и строки
+        if (!frm.doc[tableName] || !frm.doc[tableName][rowIdx]) {
+            return false;
+        }
+        
+        // Получаем строку таблицы
+        const row = frm.doc[tableName][rowIdx];
+        
+        // Получаем сетевое имя cdt и cdn для Frappe
+        const cdt = frm.fields_dict[tableName].grid.doctype;
+        const cdn = row.name;
+        
+        // Проверяем, является ли значение NaN, и если да, заменяем его на 0
+        let finalValue = value;
+        if (typeof value === 'number' && isNaN(value)) {
+            finalValue = 0;
+        }
+        
+        // Обновляем значение поля
+        frappe.model.set_value(cdt, cdn, fieldName, finalValue);
+        
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+// Функция для поиска строки таблицы по значению поля
+function find_table_row(frm, tableName, fieldName, value) {
+    // Проверяем наличие необходимых аргументов
+    if (!frm || !tableName || !fieldName) {
+        return -1;
+    }
+    
+    try {
+        // Проверяем наличие таблицы
+        if (!frm.doc[tableName]) {
+            return -1;
+        }
+        
+        // Ищем строку с указанным значением поля
+        for (let i = 0; i < frm.doc[tableName].length; i++) {
+            if (frm.doc[tableName][i][fieldName] == value) {
+                // Возвращаем индекс строки (начиная с 1 для пользователя)
+                return i + 1;
+            }
+        }
+        
+        // Если строка не найдена
+        return -1;
+    } catch (error) {
+        return -1;
+    }
+}`;
+}
+
+function processFormulasForTriggersInClientScript(formula_data, table_row_formulas, universal_fields, functions) {
+    // Получаем все предопределенные события
+    let refreshHandlers = [];
+    
+    // Проходим по всем формулам и собираем информацию о триггерах
+    Object.keys(formula_data).forEach(fieldname => {
+        let field_info = formula_data[fieldname];
+        if (!field_info || !field_info.triggers) return;
+        
+        let triggers = field_info.triggers.split(',').map(t => t.trim());
+        
+        // Проверяем наличие предопределенных событий
+        const hasRefreshTrigger = triggers.some(trigger => isPredefinedEvent(trigger));
+        
+        if (hasRefreshTrigger) {
+            // Добавляем в список обработчиков refresh с информацией о типе формулы
+            refreshHandlers.push({
+                field: fieldname,
+                uses_universal: field_info.formula && field_info.formula.includes("univ("),
+                is_table_field: field_info.is_table_field
+            });
+        }
+    });
+    
+    // Проверяем, есть ли формулы строк таблиц с предопределенным событием
+    Object.keys(table_row_formulas).forEach(formulaId => {
+        const formula = table_row_formulas[formulaId];
+        if (!formula || !formula.triggers) return;
+        
+        const triggers = formula.triggers.split(',').map(t => t.trim());
+        
+        // Проверяем наличие предопределенных событий
+        const hasRefreshTrigger = triggers.some(trigger => isPredefinedEvent(trigger));
+        
+        if (hasRefreshTrigger) {
+            // Добавляем информацию о формуле строки таблицы
+            refreshHandlers.push({
+                type: 'table_row',
+                table_name: formula.table_name,
+                row_index: formula.row_index,
+                field_name: formula.field_name,
+                formula: formula.formula,
+                uses_universal: formula.formula && formula.formula.includes("univ(")
+            });
+        }
+    });
+    
+    // Обработка универсальных полей в триггерах
+    let fieldsUsingUniversal = [];
+    
+    // Проходим по всем триггерам и ищем использование универсальных полей
+    Object.keys(formula_data).forEach(fieldname => {
+        let field_info = formula_data[fieldname];
+        if (!field_info || !field_info.triggers) return;
+        
+        let triggers = field_info.triggers.split(',').map(t => t.trim());
+        
+        // Проверяем наличие универсальных полей в триггерах
+        const hasUniversalTrigger = triggers.some(trigger => trigger.startsWith('univ('));
+        
+        if (hasUniversalTrigger) {
+            // Добавляем в список полей с универсальными триггерами
+            fieldsUsingUniversal.push({
+                field: fieldname,
+                uses_universal_in_formula: field_info.formula && field_info.formula.includes("univ("),
+                is_table_field: field_info.is_table_field
+            });
+        }
+    });
+    
+    // Формируем функцию для обработки предопределенных событий и возвращаем её
+    if (refreshHandlers.length > 0 || fieldsUsingUniversal.length > 0) {
+        // Генерируем функцию обработки предопределенных событий и возвращаем её
+        return generateEventHandlersFunction(refreshHandlers, fieldsUsingUniversal, universal_fields);
+    }
+    
+    return null;
+}
+
+function generateEventHandlersFunction(refreshHandlers, fieldsUsingUniversal, universal_fields) {
+    // Создаем обработчик предопределенных событий
+    let eventHandlerFunction = `
+// Функция для обработки предопределенных событий
+async function handle_predefined_events(frm) {
+    try {
+        // Сначала вычисляем универсальные поля, если они используются
+        ${refreshHandlers.some(h => h.uses_universal) || fieldsUsingUniversal.some(f => f.uses_universal_in_formula) ? 
+            'await calculate_universal_fields(frm);' : 
+            '// Универсальные поля не используются'}
+        
+        // Обработка обычных полей с предопределенным событием
+        ${refreshHandlers.filter(h => h.type !== 'table_row').map(handler => {
+            if (handler.uses_universal) {
+                return `
+        // Расчет поля ${handler.field} (использует универсальные поля)
+        await calculate_${handler.field}(frm);`;
+            } else {
+                return `
+        // Расчет поля ${handler.field}
+        calculate_${handler.field}(frm);`;
+            }
+        }).join('')}
+        
+        // Обработка строк табличных частей с предопределенным событием
+        ${refreshHandlers.filter(h => h.type === 'table_row').map(handler => {
+            return `
+        // Расчет поля ${handler.field_name} в строке ${handler.row_index} таблицы ${handler.table_name}
+        try {
+            calculate_table_row_field(frm, "${handler.table_name}", ${parseInt(handler.row_index) - 1}, "${handler.field_name}", "${handler.formula}", "");
+        } catch (error) {
+        }`;
+        }).join('')}
+        
+        // Обработка полей, использующих универсальные поля в триггерах
+        ${fieldsUsingUniversal.map(field => {
+            // Для полей, которые используют универсальные поля в формуле, вызов уже был выше
+            if (field.uses_universal_in_formula) return '';
+            
+            if (field.is_table_field) {
+                const parts = field.field.split('_');
+                const table_name = parts[0];
+                const field_name = parts.slice(1).join('_');
+                
+                return `
+        // Обновление поля ${field_name} в таблице ${table_name} (триггер от универсального поля)
+        update_table_fields(frm, "${table_name}", "${field_name}");`;
+            } else {
+                return `
+        // Расчет поля ${field.field} (триггер от универсального поля)
+        calculate_${field.field}(frm);`;
+            }
+        }).join('')}
+    } catch (error) {
+    }
+}
+
+// Вспомогательная функция для обновления полей во всех строках таблицы
+function update_table_fields(frm, tableName, fieldName) {
+    if (!frm.doc[tableName] || !frm.doc[tableName].length) return;
+    
+    // Получаем doctype таблицы
+    const cdt = frm.fields_dict[tableName].grid.doctype;
+    
+    // Вычисляем значение для каждой строки таблицы
+    frm.doc[tableName].forEach(row => {
+        const cdn = row.name;
+        
+        try {
+            // Вызываем обработчик для поля, если он есть
+            if (frappe.ui.form.handlers[cdt] && frappe.ui.form.handlers[cdt][fieldName]) {
+                frappe.ui.form.handlers[cdt][fieldName].forEach(handler => {
+                    handler.call(row, { frm: frm, cdt: cdt, cdn: cdn });
+                });
+            }
+        } catch (error) {
+        }
+    });
+    
+    // Обновляем отображение таблицы
+    frm.refresh_field(tableName);
+}`;
+
+    return eventHandlerFunction;
+}
+
+function addTriggersToClientScript(main_script, formula_data, tableTriggersSet, refreshHandlers, universal_fields) {
+    // Обрабатываем все формулы для основного документа
+    Object.keys(formula_data).forEach(fieldname => {
+        let field_info = formula_data[fieldname];
+
+        if (!field_info || typeof field_info !== "object" || !field_info.formula || !field_info.triggers) {
+            return;
+        }
+
+        // Получаем информацию о поле
+        let is_table_field = field_info.is_table_field;
+        let formula = field_info.formula.trim();
+        let uses_universal = formula.includes("univ(");
+        
+        // Если это не поле табличной части, обрабатываем его триггеры
+        if (!is_table_field) {
+            let triggers = field_info.triggers.split(',').map(t => t.trim());
+            
+            // Проверяем наличие предопределенного события
+            const hasRefreshTrigger = triggers.some(trigger => isPredefinedEvent(trigger));
+            
+            if (hasRefreshTrigger) {
+                // Добавляем в список обработчиков refresh
+                refreshHandlers.push({
+                    field: fieldname,
+                    uses_universal: uses_universal
+                });
+                
+                // Удаляем предопределенное событие из списка триггеров
+                triggers = triggers.filter(trigger => !isPredefinedEvent(trigger));
+            }
+            
+            // Обрабатываем универсальные поля в триггерах
+            const hasUniversalTrigger = triggers.some(trigger => trigger.startsWith('univ('));
+            
+            if (hasUniversalTrigger) {
+                // Создаем специальный обработчик для универсальных полей в триггерах
+                main_script += `    "universal_fields_updated": ${uses_universal ? 'async ' : ''}function(frm) {
+        // Пересчитываем поле ${fieldname}, если изменились универсальные поля
+        ${uses_universal ? `await calculate_${fieldname}(frm);` : `calculate_${fieldname}(frm);`}
+    },\n`;
+                
+                // Удаляем универсальные поля из списка триггеров
+                triggers = triggers.filter(trigger => !trigger.startsWith('univ('));
+            }
+            
+            // Фильтруем триггеры, исключая те, что уже добавлены в table_field_triggers
+            const filteredTriggers = triggers.filter(trigger => !tableTriggersSet.has(trigger));
+            
+            // Удаляем дубликаты триггеров
+            const uniqueTriggers = [...new Set(filteredTriggers)];
+            
+            uniqueTriggers.forEach(trigger => {
+                if (trigger) {
+                    // Определяем, является ли это полем строки таблицы (table_row_...)
+                    const isTableRowField = trigger.includes('_row_');
+                    
+                    if (isTableRowField) {
+                        // Извлекаем информацию о таблице, строке и поле
+                        const match = trigger.match(/^([^_]+)_row_(\d+)_(.+)$/);
+                        if (match) {
+                            const tableName = match[1];
+                            const rowIndex = parseInt(match[2]);
+                            const fieldInRow = match[3];
+                            
+                            // Добавляем специальный обработчик для табличной части
+                            main_script += `    "${tableName}_on_form_rendered": function(frm) {
+        // Устанавливаем обработчик для поля ${fieldInRow} в строке ${rowIndex} таблицы ${tableName}
+        try {
+            if (frm.doc.${tableName} && frm.doc.${tableName}.length >= ${rowIndex}) {
+                const row = frm.doc.${tableName}[${rowIndex - 1}];
+                const cdt = frm.fields_dict.${tableName}.grid.doctype;
+                const cdn = row.name;
+                
+                // Устанавливаем обработчик для поля ${fieldInRow}
+                if (!frm.__row_handlers) frm.__row_handlers = {};
+                if (!frm.__row_handlers['${tableName}_${rowIndex}_${fieldInRow}']) {
+                    frm.__row_handlers['${tableName}_${rowIndex}_${fieldInRow}'] = function(doc, cdt, cdn) {
+                        if (doc.name === cdn) {
+                            ${uses_universal ? 'setTimeout(async function() { await calculate_' + fieldname + '(frm); }, 0);' : 'calculate_' + fieldname + '(frm);'}
+                        }
+                    };
+                    
+                    // Регистрируем обработчик
+                    frappe.ui.form.on(cdt, {
+                        "${fieldInRow}": frm.__row_handlers['${tableName}_${rowIndex}_${fieldInRow}']
+                    });
+                }
+            }
+        } catch (error) {
+        }
+    },\n`;
+                        }
+                    } else {
+                        // Добавляем обработчик для обычного поля
+                        if (uses_universal) {
+                            main_script += `    "${trigger}": async function(frm) { await calculate_${fieldname}(frm); },\n`;
+                        } else {
+                            main_script += `    "${trigger}": function(frm) { calculate_${fieldname}(frm); },\n`;
+                        }
+                    }
+                }
+            });
+        }
+    });
+    
+    return main_script;
+}
+
+function createTriggerToken(fieldname, fieldType) {
+    // Определяем класс токена в зависимости от типа поля
+    let tokenClass = "trigger-token field";
+    
+    switch (fieldType) {
+        case 'event':
+            tokenClass = "trigger-token field highlight-event";
+            break;
+        case 'universal':
+            tokenClass = "trigger-token field universal-field";
+            break;
+        case 'table':
+            tokenClass = "trigger-token field table-field";
+            break;
+        case 'table-row':
+            tokenClass = "trigger-token field table-row-field";
+            break;
+        default:
+            tokenClass = "trigger-token field";
+    }
+    
+    return $(`<span class="${tokenClass}" data-value="${fieldname}" draggable="true" contenteditable="false">${fieldname}<span class="token-remove">×</span></span>`);
+}
+
+function initTriggerTokenEvents($token) {
+    // Удаление токена
+    $token.find('.token-remove').on('click', function(e) {
+        e.stopPropagation();
+        $(this).parent().remove();
+    });
+    
+    // Перетаскивание токена
+    $token.attr('draggable', 'true');
+    
+    $token.off('dragstart').on('dragstart', function(e) {
+        window.draggedTriggerElement = this;
+        
+        e.originalEvent.dataTransfer.setData('text/plain', JSON.stringify({
+            type: 'trigger-token',
+            value: $(this).data('value'),
+            html: $(this)[0].outerHTML,
+            tokenClass: $(this).attr('class')
+        }));
+        
+        $(this).addClass('dragging');
+    });
+    
+    $token.off('dragend').on('dragend', function() {
+        $(this).removeClass('dragging');
+        window.draggedTriggerElement = null;
+    });
+}
+
+function addTokenStyles() {
+    if ($("#token-styles").length) return;
+    
+    const tokenStyles = `
+    <style id="token-styles">
+        /* Стили для токенов */
+        .formula-token, .trigger-token {
+            display: inline-block;
+            padding: 2px 5px;
+            margin: 2px;
+            border-radius: 3px;
+            cursor: move;
+            position: relative;
+            user-select: none;
+        }
+        
+        .formula-token .token-remove, 
+        .trigger-token .token-remove {
+            display: none;
+            position: absolute;
+            top: -8px;
+            right: -8px;
+            width: 16px;
+            height: 16px;
+            background-color: #ff5555;
+            color: white;
+            border-radius: 50%;
+            text-align: center;
+            line-height: 16px;
+            font-size: 10px;
+            cursor: pointer;
+        }
+        
+        .formula-token:hover .token-remove, 
+        .trigger-token:hover .token-remove {
+            display: block;
+        }
+        
+        /* Стили для обычных полей */
+        .formula-token.field, 
+        .trigger-token.field {
+            background-color: #e3efff;
+            border: 1px solid #abc9f5;
+        }
+        
+        /* Стили для операторов */
+        .formula-token.operator {
+            background-color: #ffe8e3;
+            border: 1px solid #f5c3b9;
+            font-weight: bold;
+        }
+        
+        /* Стили для универсальных полей */
+        .universal-field-btn, 
+        .trigger-token.universal-field,
+        .formula-token.universal-field {
+            background-color: #eff8e6 !important;
+            border-color: #b7d69d !important;
+        }
+        
+        /* Стили для полей строк */
+        .row-field-btn {
+            background-color: #fff3cd !important;
+            border-color: #ffeeba !important;
+        }
+        
+        /* Стили для контейнеров */
+        .formula-result, 
+        .trigger-result {
+            min-height: 30px;
+            padding: 5px;
+            background-color: white;
+            border: 1px solid #e0e0e0;
+            border-radius: 3px;
+            font-family: monospace;
+            line-height: 1.5;
+            overflow-x: auto;
+            white-space: pre-wrap;
+            word-break: break-word;
+        }
+    </style>`;
+    
+    $('head').append(tokenStyles);
+}
+
+// Обновляем функцию openTriggerFieldsEditorForTableRow
+function openTriggerFieldsEditorForTableRow(frm, $triggerContainer) {
+    const $modal = $("#trigger_fields_modal");
+    
+    // Очистка предыдущих обработчиков и данных
+    $modal.off('click', '.trigger-field-btn');
+    $modal.find(".trigger-result").empty();
+    $modal.find(".trigger-field-groups-container").empty();
+    
+    // Копируем текущие триггеры из контейнера строки таблицы
+    const currentTriggers = getTriggerFieldsText($triggerContainer);
+    
+    // Заполняем текущие триггеры в модальное окно триггеров
+    if (currentTriggers) {
+        parseAndRenderTriggers($modal.find(".trigger-result"), currentTriggers);
+    }
+    
+    // Заполняем панель с полями
+    populateTriggerFieldsPanel($modal, frm, frm.grouped_trigger_fields || {});
+    
+    // Помечаем, что это для контейнера строки таблицы
+    $modal.data("is-for-table-row", true);
+    $modal.data("table-row-container", $triggerContainer);
+    
+    // Обработчик для кнопки применения триггеров
+    $modal.find('.apply-triggers').off('click').on('click', function() {
+        const triggers = getTriggerFieldsText($modal.find(".trigger-result"));
+        
+        // Проверяем, для контейнера строки таблицы или обычного поля
+        if ($modal.data("is-for-table-row")) {
+            // Очищаем контейнер строки таблицы
+            $triggerContainer.empty();
+            
+            // Переносим триггеры из модального окна в контейнер строки таблицы
+            if (triggers) {
+                parseAndRenderTriggers($triggerContainer, triggers);
+            }
+        } else {
+            // Стандартное поведение для обычного поля
+            const targetFieldname = $modal.data("target-field");
+            const $targetInput = $(frm.wrapper).find(`.trigger-input[data-fieldname="${targetFieldname}_triggers"]`);
+            $targetInput.val(triggers);
+        }
+        
+        $modal.modal('hide');
+    });
+    
+    // Обработчики для кнопок полей
+    $modal.on('click', '.trigger-field-btn', function() {
+        const fieldname = $(this).data('fieldname');
+        
+        // Определяем тип поля по классу кнопки
+        let fieldType = 'field';
+        if ($(this).hasClass('highlight-event')) {
+            fieldType = 'event';
+        } else if ($(this).hasClass('universal-field-btn')) {
+            fieldType = 'universal';
+        } else if ($(this).hasClass('table-field-btn')) {
+            fieldType = 'table';
+        }
+        
+        addTokenToTriggers(fieldname, $modal.find(".trigger-result"), fieldType);
+    });
+    
+    // Увеличиваем z-index модального окна, чтобы оно было поверх других
+    $modal.css('z-index', 1100);
+    
+    // Настраиваем фон
+    $('.modal-backdrop').not(':first').css({
+        'z-index': 1050,
+        'opacity': 0.7
+    });
+    
+    // Показываем модальное окно
+    $modal.modal('show');
+    
+    // Инициализируем перетаскивание
+    initTriggerDragAndDrop($modal, $modal.find(".trigger-result"));
+    
+    // Настраиваем редактируемый контейнер
+    setupTriggerEditableContainer($modal.find(".trigger-result"));
+    
+    // Фокусируемся на редактируемом поле
+    $modal.find(".trigger-result").focus();
 }
\ No newline at end of file
diff --git a/formula_editor/formula_editor/doctype/formula_editor/formula_editor.json b/formula_editor/formula_editor/doctype/formula_editor/formula_editor.json
index 0dfd423..c970c1b 100644
--- a/formula_editor/formula_editor/doctype/formula_editor/formula_editor.json
+++ b/formula_editor/formula_editor/doctype/formula_editor/formula_editor.json
@@ -8,6 +8,7 @@
   "target_doctype",
   "formula_storage",
   "universal_fields_storage",
+  "table_row_formulas_storage",
   "formula_fields",
   "test"
  ],
@@ -20,7 +21,7 @@
   },
   {
    "fieldname": "formula_storage",
-   "fieldtype": "Text",
+   "fieldtype": "Long Text",
    "label": "formula_storage"
   },
   {
@@ -34,13 +35,18 @@
   },
   {
    "fieldname": "universal_fields_storage",
-   "fieldtype": "Text",
+   "fieldtype": "Long Text",
    "label": "universal_fields_storage"
+  },
+  {
+   "fieldname": "table_row_formulas_storage",
+   "fieldtype": "Long Text",
+   "label": "table_row_formulas_storage"
   }
  ],
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2025-03-06 13:11:19.311286",
+ "modified": "2025-04-03 16:25:00.731153",
  "modified_by": "Administrator",
  "module": "Formula Editor",
  "name": "Formula Editor",