Module.bsl

// ============================================================================
// INFATON MCP Server v2.1.0
// Модуль HTTP-сервиса MCP
// 
// Протокол: JSON-RPC 2.0 (MCP — Model Context Protocol)
// 41 инструмент для взаимодействия AI с базой 1С:Предприятие (v2.0)
//
// © 2024-2026 INFATON (infaton.ru)
// ============================================================================

#Область ОбработкаHTTPЗапросов

// Основной обработчик POST-запроса HTTP-сервиса.
// Имя функции должно совпадать с именем обработчика метода POST в Конфигураторе.
//
Функция ОбработатьЗапрос(Запрос)
        
        Попытка
                ТелоСтрока = Запрос.ПолучитьТелоКакСтроку(КодировкаТекста.UTF8);
        Исключение
                Возврат СформироватьОтветОшибки(-32700, "Parse error: не удалось прочитать тело запроса");
        КонецПопытки;
        
        Если ПустаяСтрока(ТелоСтрока) Тогда
                Возврат СформироватьОтветОшибки(-32700, "Parse error: пустое тело запроса");
        КонецЕсли;
        
        Попытка
                ЧтениеJSON = Новый ЧтениеJSON;
                ЧтениеJSON.УстановитьСтроку(ТелоСтрока);
                ДанныеЗапроса = ПрочитатьJSON(ЧтениеJSON, Истина);
                ЧтениеJSON.Закрыть();
        Исключение
                Возврат СформироватьОтветОшибки(-32700, "Parse error: некорректный JSON");
        КонецПопытки;
        
        Если ТипЗнч(ДанныеЗапроса) <> Тип("Соответствие") Тогда
                Возврат СформироватьОтветОшибки(-32600, "Invalid Request: ожидается JSON-объект");
        КонецЕсли;
        
        Метод = ДанныеЗапроса["method"];
        Если Метод = Неопределено Тогда
                Возврат СформироватьОтветОшибки(-32600, "Invalid Request: отсутствует поле method");
        КонецЕсли;
        
        ИдЗапроса = ДанныеЗапроса["id"];
        Параметры = ДанныеЗапроса["params"];
        Если Параметры = Неопределено Тогда
                Параметры = Новый Соответствие;
        КонецЕсли;
        
        // --- Диспетчеризация методов MCP ---
        
        Если Метод = "initialize" Тогда
                Возврат СформироватьОтветУспех(ИдЗапроса, ПолучитьИнфоСервера());
                
        ИначеЕсли Метод = "tools/list" Тогда
                Результат = Новый Соответствие;
                Результат.Вставить("tools", ПолучитьСписокИнструментов());
                Возврат СформироватьОтветУспех(ИдЗапроса, Результат);
                
        ИначеЕсли Метод = "tools/call" Тогда
                Возврат ОбработатьВызовИнструмента(ИдЗапроса, Параметры);
                
        ИначеЕсли Метод = "ping" Тогда
                Возврат СформироватьОтветУспех(ИдЗапроса, Новый Соответствие);
                
        Иначе
                Возврат СформироватьОтветОшибки(-32601, "Method not found: " + Метод, ИдЗапроса);
        КонецЕсли;
        
КонецФункции

Функция ПолучитьИнфоСервера()
        Результат = Новый Соответствие;
        Результат.Вставить("protocolVersion", "2024-11-05");
        
        Возможности = Новый Соответствие;
        Возможности.Вставить("tools", Новый Соответствие);
        Результат.Вставить("capabilities", Возможности);
        
        Инфо = Новый Соответствие;
        Инфо.Вставить("name", "infaton-1c-mcp");
        Инфо.Вставить("version", "2.3.0");
        Результат.Вставить("serverInfo", Инфо);
        
        Возврат Результат;
КонецФункции

Функция ОбработатьВызовИнструмента(ИдЗапроса, Параметры)
        
        ИмяИнструмента = Параметры["name"];
        Аргументы = Параметры["arguments"];
        Если Аргументы = Неопределено Тогда
                Аргументы = Новый Соответствие;
        КонецЕсли;
        
        Ошибка = Ложь;
        ТекстРезультата = "";
        
        Попытка
                // === Группа А: Метаданные ===
                Если ИмяИнструмента = "get_metadata_tree" Тогда
                        ТекстРезультата = Инструмент_GetMetadataTree(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_object_metadata" Тогда
                        ТекстРезультата = Инструмент_GetObjectMetadata(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_object_attributes" Тогда
                        ТекстРезультата = Инструмент_GetObjectAttributes(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_object_tabular_sections" Тогда
                        ТекстРезультата = Инструмент_GetObjectTabularSections(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_enum_values" Тогда
                        ТекстРезультата = Инструмент_GetEnumValues(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_register_dimensions" Тогда
                        ТекстРезультата = Инструмент_GetRegisterDimensions(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_document_movements" Тогда
                        ТекстРезультата = Инструмент_GetDocumentMovements(Аргументы);
                ИначеЕсли ИмяИнструмента = "analyze_impact" Тогда
                        ТекстРезультата = Инструмент_AnalyzeImpact(Аргументы);
                ИначеЕсли ИмяИнструмента = "search_metadata" Тогда
                        ТекстРезультата = Инструмент_SearchMetadata(Аргументы);
                
                // === Группа Б: Чтение данных ===
                ИначеЕсли ИмяИнструмента = "execute_query" Тогда
                        ТекстРезультата = Инструмент_ExecuteQuery(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_object_by_ref" Тогда
                        ТекстРезультата = Инструмент_GetObjectByRef(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_list" Тогда
                        ТекстРезультата = Инструмент_GetList(Аргументы);
                ИначеЕсли ИмяИнструмента = "find_by_code" Тогда
                        ТекстРезультата = Инструмент_FindByCode(Аргументы);
                ИначеЕсли ИмяИнструмента = "find_by_name" Тогда
                        ТекстРезультата = Инструмент_FindByName(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_register_records" Тогда
                        ТекстРезультата = Инструмент_GetRegisterRecords(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_document_list" Тогда
                        ТекстРезультата = Инструмент_GetDocumentList(Аргументы);
                
                // === Группа В: Запись данных ===
                ИначеЕсли ИмяИнструмента = "create_object" Тогда
                        ТекстРезультата = Инструмент_CreateObject(Аргументы);
                ИначеЕсли ИмяИнструмента = "update_object" Тогда
                        ТекстРезультата = Инструмент_UpdateObject(Аргументы);
                ИначеЕсли ИмяИнструмента = "delete_object" Тогда
                        ТекстРезультата = Инструмент_DeleteObject(Аргументы);
                ИначеЕсли ИмяИнструмента = "post_document" Тогда
                        ТекстРезультата = Инструмент_PostDocument(Аргументы);
                ИначеЕсли ИмяИнструмента = "unpost_document" Тогда
                        ТекстРезультата = Инструмент_UnpostDocument(Аргументы);
                ИначеЕсли ИмяИнструмента = "copy_object" Тогда
                        ТекстРезультата = Инструмент_CopyObject(Аргументы);
                ИначеЕсли ИмяИнструмента = "set_attribute" Тогда
                        ТекстРезультата = Инструмент_SetAttribute(Аргументы);
                
                // === Группа Г: Код и отчёты ===
                ИначеЕсли ИмяИнструмента = "execute_code" Тогда
                        ТекстРезультата = Инструмент_ExecuteCode(Аргументы);
                ИначеЕсли ИмяИнструмента = "evaluate_expression" Тогда
                        ТекстРезультата = Инструмент_EvaluateExpression(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_module_text" Тогда
                        ТекстРезультата = Инструмент_GetModuleText(Аргументы);
                ИначеЕсли ИмяИнструмента = "generate_report" Тогда
                        ТекстРезультата = Инструмент_GenerateReport(Аргументы);
                
                // === Группа Д: Администрирование ===
                ИначеЕсли ИмяИнструмента = "get_active_users" Тогда
                        ТекстРезультата = Инструмент_GetActiveUsers(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_event_log" Тогда
                        ТекстРезультата = Инструмент_GetEventLog(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_locks" Тогда
                        ТекстРезультата = Инструмент_GetLocks(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_server_info" Тогда
                        ТекстРезультата = Инструмент_GetServerInfo(Аргументы);
                ИначеЕсли ИмяИнструмента = "check_references" Тогда
                        ТекстРезультата = Инструмент_CheckReferences(Аргументы);
                ИначеЕсли ИмяИнструмента = "run_scheduled_job" Тогда
                        ТекстРезультата = Инструмент_RunScheduledJob(Аргументы);
                
                // === Группа Е: Интеграция ===
                ИначеЕсли ИмяИнструмента = "exchange_execute" Тогда
                        ТекстРезультата = Инструмент_ExchangeExecute(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_exchange_log" Тогда
                        ТекстРезультата = Инструмент_GetExchangeLog(Аргументы);
                ИначеЕсли ИмяИнструмента = "import_data" Тогда
                        ТекстРезультата = Инструмент_ImportData(Аргументы);
                
                // === Группа Ж: Новые инструменты v2.0 ===
                ИначеЕсли ИмяИнструмента = "fill_on_basis" Тогда
                        ТекстРезультата = Инструмент_FillOnBasis(Аргументы);
                ИначеЕсли ИмяИнструмента = "write_register_records" Тогда
                        ТекстРезультата = Инструмент_WriteRegisterRecords(Аргументы);
                ИначеЕсли ИмяИнструмента = "update_tabular_section" Тогда
                        ТекстРезультата = Инструмент_UpdateTabularSection(Аргументы);
                ИначеЕсли ИмяИнструмента = "subscribe_events" Тогда
                        ТекстРезультата = Инструмент_SubscribeEvents(Аргументы);
                ИначеЕсли ИмяИнструмента = "execute_batch" Тогда
                        ТекстРезультата = Инструмент_ExecuteBatch(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_changes_since" Тогда
                        ТекстРезультата = Инструмент_GetChangesSince(Аргументы);
                
                
                // === Группа З: Новые инструменты v2.1 ===
                ИначеЕсли ИмяИнструмента = "get_balance" Тогда
                        ТекстРезультата = Инструмент_GetBalance(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_register_totals" Тогда
                        ТекстРезультата = Инструмент_GetRegisterTotals(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_accounting_entries" Тогда
                        ТекстРезультата = Инструмент_GetAccountingEntries(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_related_documents" Тогда
                        ТекстРезультата = Инструмент_GetRelatedDocuments(Аргументы);
                ИначеЕсли ИмяИнструмента = "validate_document" Тогда
                        ТекстРезультата = Инструмент_ValidateDocument(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_form_structure" Тогда
                        ТекстРезультата = Инструмент_GetFormStructure(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_rights" Тогда
                        ТекстРезультата = Инструмент_GetRights(Аргументы);
                ИначеЕсли ИмяИнструмента = "find_duplicates" Тогда
                        ТекстРезультата = Инструмент_FindDuplicates(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_print_form" Тогда
                        ТекстРезультата = Инструмент_GetPrintForm(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_configuration_extensions" Тогда
                        ТекстРезультата = Инструмент_GetConfigurationExtensions(Аргументы);

                // === Группа И: Понимание и анализ (двойник) ===
                ИначеЕсли ИмяИнструмента = "get_object_usage" Тогда
                        ТекстРезультата = Инструмент_GetObjectUsage(Аргументы);
                ИначеЕсли ИмяИнструмента = "count_records" Тогда
                        ТекстРезультата = Инструмент_CountRecords(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_subsystems" Тогда
                        ТекстРезультата = Инструмент_GetSubsystems(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_functional_options" Тогда
                        ТекстРезультата = Инструмент_GetFunctionalOptions(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_constants" Тогда
                        ТекстРезультата = Инструмент_GetConstants(Аргументы);
                ИначеЕсли ИмяИнструмента = "get_predefined" Тогда
                        ТекстРезультата = Инструмент_GetPredefined(Аргументы);
                ИначеЕсли ИмяИнструмента = "list_reports" Тогда
                        ТекстРезультата = Инструмент_ListReports(Аргументы);

                Иначе
                        Возврат СформироватьОтветОшибки(-32602, "Unknown tool: " + ИмяИнструмента, ИдЗапроса);
                КонецЕсли;
                
        Исключение
                ТекстРезультата = "ОШИБКА: " + ОписаниеОшибки();
                Ошибка = Истина;
        КонецПопытки;
        
        // Формируем MCP-ответ
        Элемент = Новый Соответствие;
        Элемент.Вставить("type", "text");
        Элемент.Вставить("text", ТекстРезультата);
        
        Контент = Новый Массив;
        Контент.Добавить(Элемент);
        
        Результат = Новый Соответствие;
        Результат.Вставить("content", Контент);
        Если Ошибка Тогда
                Результат.Вставить("isError", Истина);
        КонецЕсли;
        
        Возврат СформироватьОтветУспех(ИдЗапроса, Результат);
        
КонецФункции

#КонецОбласти


// ============================================================================
#Область ФормированиеJSON
// ============================================================================

Функция СформироватьОтветУспех(ИдЗапроса, Результат)
        Ответ = Новый Соответствие;
        Ответ.Вставить("jsonrpc", "2.0");
        Ответ.Вставить("id", ИдЗапроса);
        Ответ.Вставить("result", Результат);
        Возврат HTTPОтвет(ОбъектВJSON(Ответ));
КонецФункции

Функция СформироватьОтветОшибки(КодОшибки, Сообщение, ИдЗапроса = Неопределено)
        Ошибка = Новый Соответствие;
        Ошибка.Вставить("code", КодОшибки);
        Ошибка.Вставить("message", Сообщение);
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("jsonrpc", "2.0");
        Ответ.Вставить("id", ИдЗапроса);
        Ответ.Вставить("error", Ошибка);
        Возврат HTTPОтвет(ОбъектВJSON(Ответ));
КонецФункции

Функция HTTPОтвет(ТелоJSON)
        Ответ = Новый HTTPСервисОтвет(200);
        Ответ.Заголовки.Вставить("Content-Type", "application/json; charset=utf-8");
        Ответ.УстановитьТелоИзСтроки(ТелоJSON, КодировкаТекста.UTF8, ИспользованиеByteOrderMark.НеИспользовать);
        Возврат Ответ;
КонецФункции

Функция ОбъектВJSON(Объект)
        ЗаписьJSON = Новый ЗаписьJSON;
        НастройкиСериализации = Новый ПараметрыЗаписиJSON(ПереносСтрокJSON.Нет, , , , , , , Истина);
        ЗаписьJSON.УстановитьСтроку(НастройкиСериализации);
        ЗаписатьJSON(ЗаписьJSON, Объект);
        Возврат ЗаписьJSON.Закрыть();
КонецФункции

Функция ОбъектВJSONКомпакт(Объект)
        ЗаписьJSON = Новый ЗаписьJSON;
        ЗаписьJSON.УстановитьСтроку();
        ЗаписатьJSON(ЗаписьJSON, Объект);
        Возврат ЗаписьJSON.Закрыть();
КонецФункции

#КонецОбласти


// ============================================================================
#Область ОписаниеИнструментов
// ============================================================================

Функция ПолучитьСписокИнструментов()
        
        Инструменты = Новый Массив;
        
        // ========================= ГРУППА А: МЕТАДАННЫЕ =========================
        
        ДобавитьИнструмент(Инструменты, "get_metadata_tree",
                "Получить дерево метаданных конфигурации 1С. Возвращает список всех объектов по типам: справочники, документы, регистры, перечисления и т.д. Используй для обзора структуры базы.",
                Новый Соответствие, Новый Массив);
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта метаданных, например: Справочник.Номенклатура, Документ.РеализацияТоваровУслуг"));
        ДобавитьИнструмент(Инструменты, "get_object_metadata",
                "Получить подробные метаданные объекта 1С: реквизиты, табличные части, формы, макеты, движения. Используй для анализа структуры конкретного объекта.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта, например: Справочник.Контрагенты"));
        ДобавитьИнструмент(Инструменты, "get_object_attributes",
                "Получить список реквизитов объекта с типами, синонимами и длиной. Используй для понимания полей при чтении/записи данных.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта, например: Документ.ПоступлениеТоваровУслуг"));
        ДобавитьИнструмент(Инструменты, "get_object_tabular_sections",
                "Получить табличные части объекта и их реквизиты. Используй для анализа строковых данных документов и справочников.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя перечисления, например: Перечисление.ВидыНоменклатуры"));
        ДобавитьИнструмент(Инструменты, "get_enum_values",
                "Получить все значения перечисления с именами и синонимами.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя регистра, например: РегистрСведений.КурсыВалют, РегистрНакопления.ТоварыНаСкладах"));
        ДобавитьИнструмент(Инструменты, "get_register_dimensions",
                "Получить измерения, ресурсы и реквизиты регистра. Используй для понимания структуры регистров.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя документа, например: Документ.РеализацияТоваровУслуг"));
        ДобавитьИнструмент(Инструменты, "get_document_movements",
                "Получить список регистров, по которым документ делает движения (проводки). Ключевой инструмент для анализа учёта.",
                Св, СтрМассив("full_name"));

        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя документа ИЛИ регистра. Пример: Документ.РеализацияТоваровУслуг или РегистрНакопления.ТоварыНаСкладах"));
        ДобавитьИнструмент(Инструменты, "analyze_impact",
                "Обозреватель влияния. Показывает связи объекта учёта в обе стороны: для ДОКУМЕНТА — по каким регистрам он делает движения (что затронет проведение); для РЕГИСТРА — какие документы в него пишут (что повлияет на его данные). Используй, чтобы понять последствия изменений и зависимости между документами и регистрами.",
                Св, СтрМассив("full_name"));

        Св = Новый Соответствие;
        Св.Вставить("query", СвойствоСтрока("Строка поиска по имени или синониму объекта метаданных"));
        Св.Вставить("type_filter", СвойствоСтрока("Фильтр по типу: Справочник, Документ, Регистр, Перечисление, ПВХ, ПланСчетов (необязательно)"));
        ДобавитьИнструмент(Инструменты, "search_metadata",
                "Поиск объектов метаданных по подстроке в имени или синониме. Используй когда не знаешь точное имя объекта.",
                Св, СтрМассив("query"));
        
        // ======================== ГРУППА Б: ЧТЕНИЕ ДАННЫХ ========================
        
        Св = Новый Соответствие;
        Св.Вставить("query", СвойствоСтрока("Текст запроса на языке запросов 1С. Пример: ВЫБРАТЬ Код, Наименование ИЗ Справочник.Номенклатура ГДЕ ЭтоГруппа = ЛОЖЬ"));
        Св.Вставить("max_rows", СвойствоЧисло("Максимальное кол-во строк результата (по умолчанию 100, макс. 1000)"));
        ДобавитьИнструмент(Инструменты, "execute_query",
                "Выполнить произвольный запрос на языке запросов 1С. Самый мощный инструмент чтения данных. Поддерживает ВЫБРАТЬ, соединения, группировки, параметры виртуальных таблиц.",
                Св, СтрМассив("query"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта, например: Справочник.Номенклатура, Документ.РеализацияТоваровУслуг"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта (уникальный идентификатор)"));
        ДобавитьИнструмент(Инструменты, "get_object_by_ref",
                "Получить полные данные объекта по его типу и UUID: все реквизиты, табличные части, проведён ли, пометка удаления.",
                Св, СтрМассив("full_name", "guid"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта, например: Справочник.Контрагенты"));
        Св.Вставить("top", СвойствоЧисло("Кол-во записей (по умолчанию 50, макс. 500)"));
        Св.Вставить("skip", СвойствоЧисло("Пропустить записей (для пагинации, по умолчанию 0)"));
        Св.Вставить("filter", СвойствоСтрока("Условие фильтрации в формате запроса 1С, например: НЕ ПометкаУдаления"));
        ДобавитьИнструмент(Инструменты, "get_list",
                "Получить список объектов заданного типа с пагинацией и фильтром. Возвращает код, наименование и UUID.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта, например: Справочник.Номенклатура"));
        Св.Вставить("code", СвойствоСтрока("Код для поиска"));
        ДобавитьИнструмент(Инструменты, "find_by_code",
                "Найти объект по коду. Возвращает данные найденного элемента или сообщение что не найден.",
                Св, СтрМассив("full_name", "code"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта, например: Справочник.Контрагенты"));
        Св.Вставить("name", СвойствоСтрока("Наименование для поиска (точное совпадение)"));
        ДобавитьИнструмент(Инструменты, "find_by_name",
                "Найти объект по наименованию. Возвращает данные найденного элемента.",
                Св, СтрМассив("full_name", "name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя регистра, например: РегистрСведений.КурсыВалют"));
        Св.Вставить("filter", СвойствоСтрока("Условие отбора в формате запроса 1С (необязательно)"));
        Св.Вставить("period_from", СвойствоСтрока("Начало периода в формате YYYYMMDD (необязательно)"));
        Св.Вставить("period_to", СвойствоСтрока("Конец периода в формате YYYYMMDD (необязательно)"));
        Св.Вставить("max_rows", СвойствоЧисло("Максимальное кол-во записей (по умолчанию 100)"));
        ДобавитьИнструмент(Инструменты, "get_register_records",
                "Получить записи регистра с фильтрацией по измерениям и периоду. Работает с регистрами сведений, накопления и бухгалтерии.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип документа, например: Документ.ПоступлениеТоваровУслуг"));
        Св.Вставить("period_from", СвойствоСтрока("Начало периода YYYYMMDD (необязательно)"));
        Св.Вставить("period_to", СвойствоСтрока("Конец периода YYYYMMDD (необязательно)"));
        Св.Вставить("posted_only", СвойствоБулево("Только проведённые (по умолчанию false)"));
        Св.Вставить("top", СвойствоЧисло("Кол-во документов (по умолчанию 50)"));
        ДобавитьИнструмент(Инструменты, "get_document_list",
                "Получить список документов заданного типа с фильтрацией по периоду и статусу проведения.",
                Св, СтрМассив("full_name"));
        
        // ======================== ГРУППА В: ЗАПИСЬ ДАННЫХ ========================
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип создаваемого объекта, например: Справочник.Контрагенты"));
		Св.Вставить("attributes", СвойствоОбъект("JSON-объект с реквизитами: {\""Наименование\"": \""ООО Ромашка\"", ...}"));
		Св.Вставить("tabular_sections", СвойствоОбъект("JSON-объект табличных частей: {\""Товары\"": [{\""Номенклатура_guid\"": \""...\"", ...}]} (необязательно)"));
        ДобавитьИнструмент(Инструменты, "create_object",
                "Создать новый элемент справочника или документ. Для ссылочных реквизитов передавай UUID со суффиксом _guid.",
                Св, СтрМассив("full_name", "attributes"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта, например: Справочник.Номенклатура"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта для обновления"));
        Св.Вставить("attributes", СвойствоОбъект("JSON-объект с обновляемыми реквизитами"));
        ДобавитьИнструмент(Инструменты, "update_object",
                "Обновить реквизиты существующего объекта. Передавай только изменяемые поля.",
                Св, СтрМассив("full_name", "guid", "attributes"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта"));
        Св.Вставить("unmark", СвойствоБулево("Если true — снять пометку удаления (по умолчанию false)"));
        ДобавитьИнструмент(Инструменты, "delete_object",
                "Установить/снять пометку удаления объекта. Физическое удаление НЕ выполняется.",
                Св, СтрМассив("full_name", "guid"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип документа, например: Документ.РеализацияТоваровУслуг"));
        Св.Вставить("guid", СвойствоСтрока("UUID документа"));
        ДобавитьИнструмент(Инструменты, "post_document",
                "Провести документ. Формирует движения по регистрам.",
                Св, СтрМассив("full_name", "guid"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип документа"));
        Св.Вставить("guid", СвойствоСтрока("UUID документа"));
        ДобавитьИнструмент(Инструменты, "unpost_document",
                "Отменить проведение документа. Удаляет движения по регистрам.",
                Св, СтрМассив("full_name", "guid"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта-источника"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта-источника"));
        ДобавитьИнструмент(Инструменты, "copy_object",
                "Создать копию объекта. Копирует все реквизиты и табличные части. Возвращает UUID нового объекта.",
                Св, СтрМассив("full_name", "guid"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта"));
        Св.Вставить("attribute_name", СвойствоСтрока("Имя реквизита для изменения"));
        Св.Вставить("value", СвойствоСтрока("Новое значение (строка, число или UUID ссылки)"));
        ДобавитьИнструмент(Инструменты, "set_attribute",
                "Быстро изменить один реквизит объекта. Удобно для массовых точечных правок.",
                Св, СтрМассив("full_name", "guid", "attribute_name", "value"));
        
        // ====================== ГРУППА Г: КОД И ОТЧЁТЫ ========================
        
        Св = Новый Соответствие;
        Св.Вставить("code", СвойствоСтрока("Код на языке 1С для выполнения. Результат должен быть в переменной Результат."));
        ДобавитьИнструмент(Инструменты, "execute_code",
                "Выполнить произвольный код на языке 1С. МОЩНЫЙ ИНСТРУМЕНТ. Код выполняется в привилегированном режиме. Результат должен быть в переменной Результат (строка). Используй когда другие инструменты не подходят.",
                Св, СтрМассив("code"));
        
        Св = Новый Соответствие;
		Св.Вставить("expression", СвойствоСтрока("Выражение на языке 1С для вычисления, например: Формат(ТекущаяДата(), \""ДФ=dd.MM.yyyy\"")"));
        ДобавитьИнструмент(Инструменты, "evaluate_expression",
                "Вычислить выражение на языке 1С и вернуть результат. Для простых вычислений и проверок.",
                Св, СтрМассив("expression"));
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта, например: Справочник.Номенклатура"));
        Св.Вставить("module_type", СвойствоСтрока("Тип модуля: ОбъектМодуль, МодульМенеджера, МодульФормы (по умолчанию ОбъектМодуль)"));
        ДобавитьИнструмент(Инструменты, "get_module_text",
                "Получить исходный текст модуля объекта конфигурации. Работает только если расширение имеет доступ к основной конфигурации.",
                Св, СтрМассив("full_name"));
        
        Св = Новый Соответствие;
        Св.Вставить("query", СвойствоСтрока("Текст запроса для отчёта"));
        Св.Вставить("format", СвойствоСтрока("Формат вывода: text (по умолчанию) или json"));
        ДобавитьИнструмент(Инструменты, "generate_report",
                "Сформировать простой отчёт по произвольному запросу. Возвращает табличные данные.",
                Св, СтрМассив("query"));
        
        // ==================== ГРУППА Д: АДМИНИСТРИРОВАНИЕ ======================
        
        ДобавитьИнструмент(Инструменты, "get_active_users",
                "Получить список активных сеансов пользователей в информационной базе.",
                Новый Соответствие, Новый Массив);
        
        Св = Новый Соответствие;
        Св.Вставить("period_from", СвойствоСтрока("Начало периода YYYYMMDD (по умолчанию сегодня)"));
        Св.Вставить("period_to", СвойствоСтрока("Конец периода YYYYMMDD (по умолчанию сегодня)"));
        Св.Вставить("event_filter", СвойствоСтрока("Фильтр по типу события, например: _$Data$_.Post (необязательно)"));
        Св.Вставить("user_filter", СвойствоСтрока("Фильтр по имени пользователя (необязательно)"));
        Св.Вставить("max_rows", СвойствоЧисло("Максимальное кол-во записей (по умолчанию 200)"));
        ДобавитьИнструмент(Инструменты, "get_event_log",
                "Получить записи журнала регистрации с фильтрацией по периоду, событию и пользователю. Ключевой инструмент диагностики.",
                Св, Новый Массив);
        
        ДобавитьИнструмент(Инструменты, "get_locks",
                "Получить текущие блокировки данных в информационной базе. Помогает диагностировать зависания и конфликты.",
                Новый Соответствие, Новый Массив);
        
        ДобавитьИнструмент(Инструменты, "get_server_info",
                "Получить информацию о сервере: версия платформы, режим, имя базы, текущая дата/время.",
                Новый Соответствие, Новый Массив);
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта, например: Справочник.Номенклатура"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта для поиска ссылок"));
        ДобавитьИнструмент(Инструменты, "check_references",
                "Найти все ссылки на объект в базе данных. Показывает где используется данный объект. Необходимо перед удалением.",
                Св, СтрМассив("full_name", "guid"));
        
        Св = Новый Соответствие;
        Св.Вставить("job_name", СвойствоСтрока("Имя регламентного задания для запуска"));
        ДобавитьИнструмент(Инструменты, "run_scheduled_job",
                "Запустить регламентное задание по имени. Выполняется немедленно в текущем сеансе.",
                Св, СтрМассив("job_name"));
        
        // ======================== ГРУППА Е: ИНТЕГРАЦИЯ ==========================
        
        Св = Новый Соответствие;
        Св.Вставить("exchange_plan", СвойствоСтрока("Имя плана обмена, например: ОбменСУправляющейОрганизацией"));
        Св.Вставить("node_code", СвойствоСтрока("Код узла плана обмена"));
        ДобавитьИнструмент(Инструменты, "exchange_execute",
                "Выполнить обмен данными по указанному плану обмена и узлу.",
                Св, СтрМассив("exchange_plan"));
        
        Св = Новый Соответствие;
        Св.Вставить("period_from", СвойствоСтрока("Начало периода YYYYMMDD (по умолчанию за последние 7 дней)"));
        Св.Вставить("max_rows", СвойствоЧисло("Максимальное кол-во записей (по умолчанию 50)"));
        ДобавитьИнструмент(Инструменты, "get_exchange_log",
                "Получить журнал обменов данными: дата, план обмена, направление, результат.",
                Св, Новый Массив);
        
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Тип объекта для импорта, например: Справочник.Номенклатура"));
		Св.Вставить("data", СвойствоОбъект("Массив JSON-объектов для импорта: [{\""Наименование\"": \""Товар1\"", ...}, ...]"));
        Св.Вставить("update_existing", СвойствоБулево("Обновлять существующие по коду (по умолчанию false)"));
        ДобавитьИнструмент(Инструменты, "import_data",
                "Массовый импорт данных из JSON-массива. Создаёт или обновляет объекты.",
                Св, СтрМассив("full_name", "data"));
        
        // ========================= ГРУППА Ж: НОВЫЕ ИНСТРУМЕНТЫ v2.0 =========================
        
        // G1: Заполнение на основании
        Св = Новый Соответствие;
        Св.Вставить("target_type", СвойствоСтрока("Полное имя целевого объекта, например: Документ.РеализацияТоваровУслуг"));
        Св.Вставить("base_type", СвойствоСтрока("Полное имя объекта-основания, например: Документ.ЗаказКлиента"));
        Св.Вставить("base_guid", СвойствоСтрока("UUID объекта-основания"));
        Св.Вставить("attributes", СвойствоОбъект("Дополнительные реквизиты для переопределения (необязательно)"));
        ДобавитьИнструмент(Инструменты, "fill_on_basis",
                "Создать новый документ/справочник на основании существующего объекта. Вызывает типовой механизм ЗаполнитьНаОсновании(). Ключевой инструмент для цепочек документов: ЗаказКлиента → Реализация → СчётФактура.",
                Св, СтрМассив("target_type", "base_type", "base_guid"));
        
        // G2: Запись в регистры
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя регистра, например: РегистрСведений.КурсыВалют, РегистрСведений.КонтактнаяИнформация"));
        Св.Вставить("records", СвойствоМассив("Массив записей для регистра. Каждая запись — объект с измерениями, ресурсами и реквизитами"));
        Св.Вставить("replace", СвойствоБулево("Режим замены: true — заменить существующие записи по ключу, false — добавить (по умолчанию false)"));
        Св.Вставить("period", СвойствоСтрока("Период записей для периодических регистров (формат: YYYYMMDD или YYYY-MM-DDTHH:MM:SS)"));
        ДобавитьИнструмент(Инструменты, "write_register_records",
                "Записать данные в регистр сведений напрямую. Поддерживает периодические и непериодические регистры. Используй для контактной информации, курсов валют, цен, штрихкодов, настроек.",
                Св, СтрМассив("full_name", "records"));
        
        // G3: Обновление табличных частей
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта, например: Документ.ЗаказКлиента"));
        Св.Вставить("guid", СвойствоСтрока("UUID объекта"));
        Св.Вставить("tabular_section", СвойствоСтрока("Имя табличной части, например: Товары, Услуги"));
        Св.Вставить("rows", СвойствоМассив("Массив строк ТЧ. Каждая строка — объект с реквизитами"));
        Св.Вставить("mode", СвойствоСтрока("Режим: replace (очистить и заполнить заново, по умолчанию), append (добавить строки), update_by_index (обновить по НомерСтроки)"));
        ДобавитьИнструмент(Инструменты, "update_tabular_section",
                "Обновить табличную часть существующего объекта (документа/справочника). Три режима: полная замена, добавление строк, точечное обновление по номеру строки. Критичен для работы с документами.",
                Св, СтрМассив("full_name", "guid", "tabular_section", "rows"));
        
        // G4: Подписка на события (polling-based)
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя типа объекта для отслеживания, например: Документ.ЗаказКлиента (необязательно — без фильтра = все объекты)"));
        Св.Вставить("event_types", СвойствоСтрока("Типы событий через запятую: _ОбъектЗапись,_ОбъектПроведение,_ОбъектУдаление (необязательно, по умолчанию все)"));
        Св.Вставить("since", СвойствоСтрока("Метка времени начала (ISO 8601), например: 2026-05-14T00:00:00. По умолчанию — последние 5 минут"));
        Св.Вставить("max_events", СвойствоЧисло("Максимальное кол-во событий (по умолчанию 100, макс. 1000)"));
        ДобавитьИнструмент(Инструменты, "subscribe_events",
                "Получить новые события (изменения) из журнала регистрации 1С с момента указанной метки. Используется для polling-синхронизации двойников. Возвращает: время, тип события, объект, пользователь, watermark для следующего запроса.",
                Св, Новый Массив);
        
        // G5: Пакетное выполнение
        Св = Новый Соответствие;
        Св.Вставить("operations", СвойствоМассив("Массив операций. Каждая операция: {tool: 'имя_инструмента', arguments: {...}}. Выполняются последовательно."));
        Св.Вставить("stop_on_error", СвойствоБулево("Остановить выполнение при первой ошибке (по умолчанию true)"));
        Св.Вставить("transactional", СвойствоБулево("Выполнить все операции в одной транзакции. При ошибке — откат всех (по умолчанию false)"));
        ДобавитьИнструмент(Инструменты, "execute_batch",
                "Выполнить пакет операций за один вызов. Поддерживает любые инструменты MCP. Режимы: последовательный, stop-on-error, транзакционный. Критичен для атомарных операций: создать документ + провести + записать связанные.",
                Св, СтрМассив("operations"));
        
        // G6: Получение изменений (CDC)
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя типа объекта, например: Справочник.Номенклатура, Документ.ЗаказКлиента"));
        Св.Вставить("since", СвойствоСтрока("Метка времени ISO 8601, с которой искать изменения. Например: 2026-05-14T10:00:00"));
        Св.Вставить("include_data", СвойствоБулево("Включить полные данные изменённых объектов (по умолчанию false — только GUID и тип изменения)"));
        Св.Вставить("max_results", СвойствоЧисло("Максимальное кол-во результатов (по умолчанию 500, макс. 5000)"));
        ДобавитьИнструмент(Инструменты, "get_changes_since",
                "Получить список объектов, изменённых после указанной метки времени. Change Data Capture для синхронизации двойников. Возвращает: GUID, тип изменения (создание/обновление/удаление/проведение), время, watermark.",
                Св, СтрМассив("full_name", "since"));

        

        // === Группа З: Новые инструменты v2.1 ===
        
        // Z1: Остатки/обороты регистров бухгалтерии
        Св = Новый Соответствие;
        Св.Вставить("register_name", СвойствоСтрока("Имя регистра бухгалтерии (например: Хозрасчетный, Международный, Налоговый). Если не указано — используется Хозрасчетный."));
        Св.Вставить("account_code", СвойствоСтрока("Код счёта бухгалтерского учёта (например: 41.01, 60.01, 90.01.1)"));
        Св.Вставить("period_from", СвойствоСтрока("Начало периода ISO 8601 (например: 2026-01-01T00:00:00)"));
        Св.Вставить("period_to", СвойствоСтрока("Конец периода ISO 8601 (например: 2026-03-31T23:59:59)"));
        Св.Вставить("dimensions", СвойствоОбъект("Отбор по измерениям/субконто: {ИмяИзмерения: Значение}. Например: {Организация: 'ООО Рога'}"));
        Св.Вставить("balance_type", СвойствоСтрока("Тип: balance (остатки), turnovers (обороты), balance_and_turnovers. По умолчанию balance"));
        ДобавитьИнструмент(Инструменты, "get_balance",
                "Получить остатки и/или обороты регистра бухгалтерии. Работает с любым планом счетов. Поддерживает фильтрацию по счёту, периоду, организации и субконто. Возвращает: Дебет/Кредит остатки и обороты.",
                Св, СтрМассив("account_code"));
        
        // Z2: Остатки/обороты регистров накопления
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя регистра накопления (например: РегистрНакопления.ТоварыНаСкладах)"));
        Св.Вставить("period_from", СвойствоСтрока("Начало периода ISO 8601"));
        Св.Вставить("period_to", СвойствоСтрока("Конец периода ISO 8601"));
        Св.Вставить("dimensions", СвойствоОбъект("Отбор по измерениям: {ИмяИзмерения: Значение}"));
        Св.Вставить("resources", СвойствоСтрока("Список ресурсов через запятую (например: Количество,Стоимость). Если пусто — все ресурсы"));
        Св.Вставить("balance_type", СвойствоСтрока("Тип: balance, turnovers, balance_and_turnovers. По умолчанию balance"));
        ДобавитьИнструмент(Инструменты, "get_register_totals",
                "Получить итоги регистра накопления (остатки, обороты или и то и другое). Поддерживает отбор по измерениям и выбор ресурсов.",
                Св, СтрМассив("full_name"));
        
        // Z3: Проводки документа
        Св = Новый Соответствие;
        Св.Вставить("document_ref", СвойствоСтрока("Ссылка на документ (GUID или представление)"));
        Св.Вставить("register_name", СвойствоСтрока("Имя регистра бухгалтерии (по умолчанию Хозрасчетный)"));
        ДобавитьИнструмент(Инструменты, "get_accounting_entries",
                "Получить бухгалтерские проводки (движения) документа. Возвращает: счёт Дт, счёт Кт, сумма, количество, субконто, содержание.",
                Св, СтрМассив("document_ref"));
        
        // Z4: Связанные документы
        Св = Новый Соответствие;
        Св.Вставить("document_ref", СвойствоСтрока("Ссылка на документ (GUID)"));
        Св.Вставить("direction", СвойствоСтрока("Направление поиска: forward (на основании этого), backward (этот на основании), both. По умолчанию both"));
        Св.Вставить("max_depth", СвойствоЧисло("Глубина поиска связей (по умолчанию 1, максимум 5)"));
        ДобавитьИнструмент(Инструменты, "get_related_documents",
                "Найти документы, связанные с указанным через цепочки 'Ввод на основании'. Показывает: тип, номер, дата, направление, глубину вложенности.",
                Св, СтрМассив("document_ref"));
        
        // Z5: Проверка заполнения документа
        Св = Новый Соответствие;
        Св.Вставить("document_ref", СвойствоСтрока("Ссылка на документ (GUID)"));
        ДобавитьИнструмент(Инструменты, "validate_document",
                "Проверить корректность заполнения документа без проведения. Вызывает стандартную процедуру проверки заполнения. Возвращает список ошибок или подтверждение корректности.",
                Св, СтрМассив("document_ref"));
        
        // Z6: Структура формы
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта метаданных (например: Документ.РеализацияТоваровУслуг)"));
        Св.Вставить("form_name", СвойствоСтрока("Имя формы (например: ФормаДокумента). Если не указано — основная форма."));
        ДобавитьИнструмент(Инструменты, "get_form_structure",
                "Получить структуру управляемой формы: реквизиты формы, команды, элементы (дерево). Полезно для понимания пользовательского интерфейса объекта.",
                Св, СтрМассив("full_name"));
        
        // Z7: Права доступа
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта метаданных для проверки прав (например: Документ.ЗаказКлиента)"));
        ДобавитьИнструмент(Инструменты, "get_rights",
                "Получить права доступа текущего пользователя к указанному объекту метаданных. Возвращает: чтение, добавление, изменение, удаление, проведение и другие применимые права.",
                Св, СтрМассив("full_name"));
        
        // Z8: Поиск дублей
        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя справочника (например: Справочник.Контрагенты)"));
        Св.Вставить("attributes", СвойствоСтрока("Реквизиты для сравнения через запятую (например: ИНН,Наименование)"));
        Св.Вставить("threshold", СвойствоЧисло("Порог совпадения для нечёткого сравнения строк (0-100, по умолчанию 90)"));
        Св.Вставить("max_results", СвойствоЧисло("Максимум пар дублей (по умолчанию 100)"));
        ДобавитьИнструмент(Инструменты, "find_duplicates",
                "Найти потенциальные дубли в справочнике по указанным реквизитам. Поддерживает точное и нечёткое сравнение строк. Возвращает пары элементов с процентом совпадения.",
                Св, СтрМассив("full_name", "attributes"));
        
        // Z9: Печатная форма
        Св = Новый Соответствие;
        Св.Вставить("document_ref", СвойствоСтрока("Ссылка на документ (GUID)"));
        Св.Вставить("print_form_id", СвойствоСтрока("Идентификатор печатной формы (например: Счёт, ТОРГ12, СчётФактура). Если пусто — список доступных форм"));
        Св.Вставить("format", СвойствоСтрока("Формат вывода: info (описание полей), mxl_text (текст табличного документа). По умолчанию info"));
        ДобавитьИнструмент(Инструменты, "get_print_form",
                "Получить печатную форму документа через подсистему УправлениеПечатью. Без параметра print_form_id — возвращает список доступных печатных форм для документа. С параметром — генерирует указанную печатную форму.",
                Св, СтрМассив("document_ref"));
        
        // Z10: Расширения конфигурации
        Св = Новый Соответствие;
        Св.Вставить("active_only", СвойствоБулево("Только активные расширения (по умолчанию true)"));
        ДобавитьИнструмент(Инструменты, "get_configuration_extensions",
                "Получить список расширений конфигурации (CFE). Возвращает: имя, синоним, версия, назначение, активность, область действия, безопасный режим.",
                Св);

        // ============ ГРУППА И: ПОНИМАНИЕ И АНАЛИЗ (для цифрового двойника) ============

        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя документа ИЛИ регистра. Пример: Документ.РеализацияТоваровУслуг или РегистрНакопления.ТоварыНаСкладах"));
        ДобавитьИнструмент(Инструменты, "get_object_usage",
                "Где используется объект: какие документы, справочники и регистры ссылаются на данный объект через свои реквизиты, измерения, ресурсы и табличные части. Отвечает на вопрос «что сломается, если изменить этот объект». Используй для оценки зависимостей перед изменением справочника или документа.",
                Св, СтрМассив("full_name"));

        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя объекта или регистра, например: Справочник.Номенклатура, Документ.РеализацияТоваровУслуг, РегистрНакопления.ТоварыНаСкладах"));
        Св.Вставить("filter", СвойствоСтрока("Условие отбора в формате запроса 1С (необязательно), например: НЕ ПометкаУдаления"));
        ДобавитьИнструмент(Инструменты, "count_records",
                "Быстро подсчитать количество записей объекта или регистра (с необязательным фильтром). Используй для оценки объёма данных без выгрузки самих записей.",
                Св, СтрМассив("full_name"));

        ДобавитьИнструмент(Инструменты, "get_subsystems",
                "Получить дерево подсистем конфигурации (функциональные блоки: продажи, закупки, склад, финансы и т.д.) с вложенностью. Используй для обзора функциональной структуры базы.",
                Новый Соответствие, Новый Массив);

        ДобавитьИнструмент(Инструменты, "get_functional_options",
                "Получить список функциональных опций конфигурации и их текущее состояние (включено/выключено). Показывает, какая функциональность реально активна в этой базе. Ключ к пониманию того, что доступно пользователю.",
                Новый Соответствие, Новый Массив);

        Св = Новый Соответствие;
        Св.Вставить("include_values", СвойствоБулево("Читать текущие значения констант (по умолчанию false — только список)"));
        ДобавитьИнструмент(Инструменты, "get_constants",
                "Получить список констант конфигурации (имя, синоним, тип) и, по запросу, их текущие значения. Константы хранят глобальные настройки базы.",
                Св, Новый Массив);

        Св = Новый Соответствие;
        Св.Вставить("full_name", СвойствоСтрока("Полное имя справочника, плана видов характеристик или плана счетов, например: Справочник.ВалютыДокументов"));
        ДобавитьИнструмент(Инструменты, "get_predefined",
                "Получить имена предопределённых элементов объекта (справочника, ПВХ, плана счетов). Предопределённые элементы зашиты в конфигурацию и используются в коде (например, статусы, виды операций).",
                Св, СтрМассив("full_name"));

        Св = Новый Соответствие;
        Св.Вставить("query", СвойствоСтрока("Подстрока для фильтра по имени/синониму отчёта (необязательно)"));
        ДобавитьИнструмент(Инструменты, "list_reports",
                "Получить список отчётов конфигурации (имя и синоним). Используй, чтобы узнать, какие готовые отчёты можно построить через generate_report.",
                Св, Новый Массив);

        Возврат Инструменты;
        
КонецФункции

// --- Вспомогательные функции для описания инструментов ---

Процедура ДобавитьИнструмент(Инструменты, Имя, Описание, Свойства, Обязательные = Неопределено)
        Схема = Новый Соответствие;
        Схема.Вставить("type", "object");
        Схема.Вставить("properties", Свойства);
        Если Обязательные <> Неопределено И Обязательные.Количество() > 0 Тогда
                Схема.Вставить("required", Обязательные);
        КонецЕсли;
        
        Инструмент = Новый Соответствие;
        Инструмент.Вставить("name", Имя);
        Инструмент.Вставить("description", Описание);
        Инструмент.Вставить("inputSchema", Схема);
        Инструменты.Добавить(Инструмент);
КонецПроцедуры

Функция СвойствоСтрока(Описание)
        Св = Новый Соответствие;
        Св.Вставить("type", "string");
        Св.Вставить("description", Описание);
        Возврат Св;
КонецФункции

Функция СвойствоЧисло(Описание)
        Св = Новый Соответствие;
        Св.Вставить("type", "integer");
        Св.Вставить("description", Описание);
        Возврат Св;
КонецФункции

Функция СвойствоБулево(Описание)
        Св = Новый Соответствие;
        Св.Вставить("type", "boolean");
        Св.Вставить("description", Описание);
        Возврат Св;
КонецФункции

Функция СвойствоОбъект(Описание)
        Св = Новый Соответствие;
        Св.Вставить("type", "object");
        Св.Вставить("description", Описание);
        Возврат Св;
КонецФункции

Функция СтрМассив(Зн1, Зн2 = Неопределено, Зн3 = Неопределено, Зн4 = Неопределено)
        Массив = Новый Массив;
        Массив.Добавить(Зн1);
        Если Зн2 <> Неопределено Тогда Массив.Добавить(Зн2); КонецЕсли;
        Если Зн3 <> Неопределено Тогда Массив.Добавить(Зн3); КонецЕсли;
        Если Зн4 <> Неопределено Тогда Массив.Добавить(Зн4); КонецЕсли;
        Возврат Массив;
КонецФункции

#КонецОбласти


// ============================================================================
#Область ГруппаА_Метаданные
// ============================================================================

Функция Инструмент_GetMetadataTree(Аргументы)
        
        Дерево = Новый Соответствие;
        
        // Справочники
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.Справочники Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "Справочник." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("Справочники", Список);
        
        // Документы
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.Документы Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "Документ." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("Документы", Список);
        
        // Регистры сведений
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.РегистрыСведений Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "РегистрСведений." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("РегистрыСведений", Список);
        
        // Регистры накопления
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.РегистрыНакопления Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "РегистрНакопления." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("РегистрыНакопления", Список);
        
        // Регистры бухгалтерии
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.РегистрыБухгалтерии Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "РегистрБухгалтерии." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("РегистрыБухгалтерии", Список);
        
        // Перечисления
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.Перечисления Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "Перечисление." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("Перечисления", Список);
        
        // Планы видов характеристик
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.ПланыВидовХарактеристик Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "ПланВидовХарактеристик." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("ПланыВидовХарактеристик", Список);
        
        // Планы счетов
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.ПланыСчетов Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "ПланСчетов." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("ПланыСчетов", Список);
        
        // Планы обмена
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.ПланыОбмена Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "ПланОбмена." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("ПланыОбмена", Список);
        
        // Обработки
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.Обработки Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "Обработка." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("Обработки", Список);
        
        // Отчёты
        Список = Новый Массив;
        Для Каждого МД Из Метаданные.Отчеты Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", МД.Имя);
                Эл.Вставить("synonym", МД.Синоним);
                Эл.Вставить("full_name", "Отчет." + МД.Имя);
                Список.Добавить(Эл);
        КонецЦикла;
        Дерево.Вставить("Отчеты", Список);
        
        Возврат ОбъектВJSONКомпакт(Дерево);
        
КонецФункции

Функция Инструмент_GetObjectMetadata(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        Результат = Новый Соответствие;
        Результат.Вставить("full_name", ПолноеИмя);
        Результат.Вставить("name", МДОбъект.Имя);
        Результат.Вставить("synonym", МДОбъект.Синоним);
        Результат.Вставить("comment", МДОбъект.Комментарий);
        
        // Реквизиты
        Попытка
                Реквизиты = Новый Массив;
                Для Каждого Рекв Из МДОбъект.Реквизиты Цикл
                        Реквизиты.Добавить(ОписаниеРеквизита(Рекв));
                КонецЦикла;
                Результат.Вставить("attributes", Реквизиты);
        Исключение
        КонецПопытки;
        
        // Стандартные реквизиты
        Попытка
                Стандартные = Новый Массив;
                Для Каждого Рекв Из МДОбъект.СтандартныеРеквизиты Цикл
                        СР = Новый Соответствие;
                        СР.Вставить("name", Рекв.Имя);
                        СР.Вставить("synonym", Рекв.Синоним);
                        Стандартные.Добавить(СР);
                КонецЦикла;
                Результат.Вставить("standard_attributes", Стандартные);
        Исключение
        КонецПопытки;
        
        // Табличные части
        Попытка
                ТЧ = Новый Массив;
                Для Каждого ТабЧасть Из МДОбъект.ТабличныеЧасти Цикл
                        ТЧОписание = Новый Соответствие;
                        ТЧОписание.Вставить("name", ТабЧасть.Имя);
                        ТЧОписание.Вставить("synonym", ТабЧасть.Синоним);
                        ТЧРеквизиты = Новый Массив;
                        Для Каждого Рекв Из ТабЧасть.Реквизиты Цикл
                                ТЧРеквизиты.Добавить(ОписаниеРеквизита(Рекв));
                        КонецЦикла;
                        ТЧОписание.Вставить("attributes", ТЧРеквизиты);
                        ТЧ.Добавить(ТЧОписание);
                КонецЦикла;
                Результат.Вставить("tabular_sections", ТЧ);
        Исключение
        КонецПопытки;
        
        // Движения (для документов)
        Попытка
                Движения = Новый Массив;
                Для Каждого Рег Из МДОбъект.Движения Цикл
                        Движения.Добавить(Рег.ПолноеИмя());
                КонецЦикла;
                Результат.Вставить("movements", Движения);
        Исключение
        КонецПопытки;
        
        // Формы
        Попытка
                Формы = Новый Массив;
                Для Каждого Форма Из МДОбъект.Формы Цикл
                        Формы.Добавить(Форма.Имя);
                КонецЦикла;
                Результат.Вставить("forms", Формы);
        Исключение
        КонецПопытки;
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_GetObjectAttributes(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        Реквизиты = Новый Массив;
        
        // Стандартные реквизиты
        Попытка
                Для Каждого Рекв Из МДОбъект.СтандартныеРеквизиты Цикл
                        РА = Новый Соответствие;
                        РА.Вставить("name", Рекв.Имя);
                        РА.Вставить("synonym", Рекв.Синоним);
                        РА.Вставить("is_standard", Истина);
                        Реквизиты.Добавить(РА);
                КонецЦикла;
        Исключение
        КонецПопытки;
        
        // Пользовательские реквизиты
        Попытка
                Для Каждого Рекв Из МДОбъект.Реквизиты Цикл
                        Реквизиты.Добавить(ОписаниеРеквизита(Рекв));
                КонецЦикла;
        Исключение
        КонецПопытки;
        
        Возврат ОбъектВJSONКомпакт(Реквизиты);
        
КонецФункции

Функция Инструмент_GetObjectTabularSections(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        ТЧ = Новый Массив;
        Попытка
                Для Каждого ТабЧасть Из МДОбъект.ТабличныеЧасти Цикл
                        ТЧОписание = Новый Соответствие;
                        ТЧОписание.Вставить("name", ТабЧасть.Имя);
                        ТЧОписание.Вставить("synonym", ТабЧасть.Синоним);
                        Реквизиты = Новый Массив;
                        Для Каждого Рекв Из ТабЧасть.Реквизиты Цикл
                                Реквизиты.Добавить(ОписаниеРеквизита(Рекв));
                        КонецЦикла;
                        ТЧОписание.Вставить("attributes", Реквизиты);
                        ТЧ.Добавить(ТЧОписание);
                КонецЦикла;
        Исключение
                Возврат "У объекта " + ПолноеИмя + " нет табличных частей";
        КонецПопытки;
        
        Возврат ОбъектВJSONКомпакт(ТЧ);
        
КонецФункции

Функция Инструмент_GetEnumValues(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Перечисление не найдено: " + ПолноеИмя;
        КонецЕсли;
        
        Значения = Новый Массив;
        Для Каждого Зн Из МДОбъект.ЗначенияПеречисления Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", Зн.Имя);
                Эл.Вставить("synonym", Зн.Синоним);
                Значения.Добавить(Эл);
        КонецЦикла;
        
        Возврат ОбъектВJSONКомпакт(Значения);
        
КонецФункции

Функция Инструмент_GetRegisterDimensions(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Регистр не найден: " + ПолноеИмя;
        КонецЕсли;
        
        Результат = Новый Соответствие;
        
        // Измерения
        Измерения = Новый Массив;
        Попытка
                Для Каждого Изм Из МДОбъект.Измерения Цикл
                        Измерения.Добавить(ОписаниеРеквизита(Изм));
                КонецЦикла;
        Исключение
        КонецПопытки;
        Результат.Вставить("dimensions", Измерения);
        
        // Ресурсы
        Ресурсы = Новый Массив;
        Попытка
                Для Каждого Рес Из МДОбъект.Ресурсы Цикл
                        Ресурсы.Добавить(ОписаниеРеквизита(Рес));
                КонецЦикла;
        Исключение
        КонецПопытки;
        Результат.Вставить("resources", Ресурсы);
        
        // Реквизиты
        Реквизиты = Новый Массив;
        Попытка
                Для Каждого Рекв Из МДОбъект.Реквизиты Цикл
                        Реквизиты.Добавить(ОписаниеРеквизита(Рекв));
                КонецЦикла;
        Исключение
        КонецПопытки;
        Результат.Вставить("attributes", Реквизиты);
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_GetDocumentMovements(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Документ не найден: " + ПолноеИмя;
        КонецЕсли;
        
        Движения = Новый Массив;
        Попытка
                Для Каждого Рег Из МДОбъект.Движения Цикл
                        Инфо = Новый Соответствие;
                        Инфо.Вставить("full_name", Рег.ПолноеИмя());
                        Инфо.Вставить("name", Рег.Имя);
                        Инфо.Вставить("synonym", Рег.Синоним);
                        Движения.Добавить(Инфо);
                КонецЦикла;
        Исключение
                Возврат "У объекта " + ПолноеИмя + " нет движений (не документ?)";
        КонецПопытки;
        
        Возврат ОбъектВJSONКомпакт(Движения);

КонецФункции

Функция Инструмент_AnalyzeImpact(Аргументы)

        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект не найден: " + ПолноеИмя;
        КонецЕсли;

        Результат = Новый Соответствие;
        Результат.Вставить("object", ПолноеИмя);
        Результат.Вставить("object_synonym", МДОбъект.Синоним);

        // === ПРЯМОЕ ВЛИЯНИЕ: если это документ — по каким регистрам он делает движения ===
        ВлияетНаРегистры = Новый Массив;
        Попытка
                Для Каждого Рег Из МДОбъект.Движения Цикл
                        Инфо = Новый Соответствие;
                        Инфо.Вставить("full_name", Рег.ПолноеИмя());
                        Инфо.Вставить("name", Рег.Имя);
                        Инфо.Вставить("synonym", Рег.Синоним);
                        ВлияетНаРегистры.Добавить(Инфо);
                КонецЦикла;
        Исключение
                // У объекта нет свойства "Движения" (не документ) — это нормально
        КонецПопытки;
        Результат.Вставить("affects_registers", ВлияетНаРегистры);

        // === ОБРАТНОЕ ВЛИЯНИЕ: какие документы пишут движения в этот регистр ===
        ПишутДокументы = Новый Массив;
        Для Каждого МДДок Из Метаданные.Документы Цикл
                Попытка
                        Для Каждого Рег Из МДДок.Движения Цикл
                                Если Рег = МДОбъект Тогда
                                        Инфо = Новый Соответствие;
                                        Инфо.Вставить("full_name", МДДок.ПолноеИмя());
                                        Инфо.Вставить("name", МДДок.Имя);
                                        Инфо.Вставить("synonym", МДДок.Синоним);
                                        ПишутДокументы.Добавить(Инфо);
                                        Прервать;
                                КонецЕсли;
                        КонецЦикла;
                Исключение
                КонецПопытки;
        КонецЦикла;
        Результат.Вставить("written_by_documents", ПишутДокументы);

        Результат.Вставить("affects_count", ВлияетНаРегистры.Количество());
        Результат.Вставить("written_by_count", ПишутДокументы.Количество());

        Возврат ОбъектВJSONКомпакт(Результат);

КонецФункции

// ===================== ГРУППА И: ПОНИМАНИЕ И АНАЛИЗ (двойник) =====================

Функция Инструмент_GetObjectUsage(Аргументы)

        ПолноеИмя = Аргументы["full_name"];
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;

        ПрефиксСсылки = "";
        Если Части.Тип = "Справочник" Тогда ПрефиксСсылки = "СправочникСсылка";
        ИначеЕсли Части.Тип = "Документ" Тогда ПрефиксСсылки = "ДокументСсылка";
        ИначеЕсли Части.Тип = "Перечисление" Тогда ПрефиксСсылки = "ПеречислениеСсылка";
        ИначеЕсли Части.Тип = "ПланВидовХарактеристик" Тогда ПрефиксСсылки = "ПланВидовХарактеристикСсылка";
        ИначеЕсли Части.Тип = "ПланСчетов" Тогда ПрефиксСсылки = "ПланСчетовСсылка";
        ИначеЕсли Части.Тип = "ПланОбмена" Тогда ПрефиксСсылки = "ПланОбменаСсылка";
        Иначе
                Возврат "Поиск использования поддерживается для: Справочник, Документ, Перечисление, ПланВидовХарактеристик, ПланСчетов, ПланОбмена. Получено: " + Части.Тип;
        КонецЕсли;

        ИскомыйТип = Неопределено;
        Попытка
                ИскомыйТип = Тип(ПрефиксСсылки + "." + Части.Имя);
        Исключение
                Возврат "Не удалось построить ссылочный тип для: " + ПолноеИмя;
        КонецПопытки;

        Найдено = Новый Массив;

        Коллекции = Новый Соответствие;
        Коллекции.Вставить("Справочник", Метаданные.Справочники);
        Коллекции.Вставить("Документ", Метаданные.Документы);
        Коллекции.Вставить("РегистрСведений", Метаданные.РегистрыСведений);
        Коллекции.Вставить("РегистрНакопления", Метаданные.РегистрыНакопления);
        Коллекции.Вставить("РегистрБухгалтерии", Метаданные.РегистрыБухгалтерии);
        Коллекции.Вставить("ПланВидовХарактеристик", Метаданные.ПланыВидовХарактеристик);
        Коллекции.Вставить("ПланСчетов", Метаданные.ПланыСчетов);

        Для Каждого КЭ Из Коллекции Цикл
                Для Каждого МД Из КЭ.Значение Цикл
                        Попытка
                                ИспользованиеОбъекта_Сканировать(МД, ИскомыйТип, Найдено);
                        Исключение
                        КонецПопытки;
                КонецЦикла;
        КонецЦикла;

        Результат = Новый Соответствие;
        Результат.Вставить("object", ПолноеИмя);
        Результат.Вставить("used_in", Найдено);
        Результат.Вставить("count", Найдено.Количество());
        Возврат ОбъектВJSONКомпакт(Результат);

КонецФункции

Процедура ИспользованиеОбъекта_Сканировать(МД, ИскомыйТип, Найдено)

        ПолноеИмяВладельца = МД.ПолноеИмя();

        // Реквизиты
        Попытка
                Для Каждого Рекв Из МД.Реквизиты Цикл
                        Если Рекв.Тип.СодержитТип(ИскомыйТип) Тогда
                                ИспользованиеОбъекта_Добавить(Найдено, ПолноеИмяВладельца, "реквизит", Рекв.Имя);
                        КонецЕсли;
                КонецЦикла;
        Исключение КонецПопытки;

        // Измерения (для регистров)
        Попытка
                Для Каждого Изм Из МД.Измерения Цикл
                        Если Изм.Тип.СодержитТип(ИскомыйТип) Тогда
                                ИспользованиеОбъекта_Добавить(Найдено, ПолноеИмяВладельца, "измерение", Изм.Имя);
                        КонецЕсли;
                КонецЦикла;
        Исключение КонецПопытки;

        // Ресурсы (для регистров)
        Попытка
                Для Каждого Рес Из МД.Ресурсы Цикл
                        Если Рес.Тип.СодержитТип(ИскомыйТип) Тогда
                                ИспользованиеОбъекта_Добавить(Найдено, ПолноеИмяВладельца, "ресурс", Рес.Имя);
                        КонецЕсли;
                КонецЦикла;
        Исключение КонецПопытки;

        // Табличные части и их реквизиты
        Попытка
                Для Каждого ТЧ Из МД.ТабличныеЧасти Цикл
                        Для Каждого Рекв Из ТЧ.Реквизиты Цикл
                                Если Рекв.Тип.СодержитТип(ИскомыйТип) Тогда
                                        ИспользованиеОбъекта_Добавить(Найдено, ПолноеИмяВладельца, "реквизит ТЧ " + ТЧ.Имя, Рекв.Имя);
                                КонецЕсли;
                        КонецЦикла;
                КонецЦикла;
        Исключение КонецПопытки;

КонецПроцедуры

Процедура ИспользованиеОбъекта_Добавить(Найдено, ПолноеИмяВладельца, ВидРеквизита, ИмяРеквизита)
        Эл = Новый Соответствие;
        Эл.Вставить("owner", ПолноеИмяВладельца);
        Эл.Вставить("kind", ВидРеквизита);
        Эл.Вставить("attribute", ИмяРеквизита);
        Найдено.Добавить(Эл);
КонецПроцедуры

Функция Инструмент_CountRecords(Аргументы)

        ПолноеИмя = Аргументы["full_name"];
        Фильтр = Аргументы["filter"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект не найден: " + ПолноеИмя;
        КонецЕсли;

        Текст = "ВЫБРАТЬ КОЛИЧЕСТВО(*) КАК Кол ИЗ " + ПолноеИмя;
        Если ЗначениеЗаполнено(Фильтр) Тогда
                Текст = Текст + " ГДЕ " + Фильтр;
        КонецЕсли;

        Запрос = Новый Запрос(Текст);
        Выборка = Запрос.Выполнить().Выбрать();
        Кол = 0;
        Если Выборка.Следующий() Тогда
                Кол = Выборка.Кол;
        КонецЕсли;

        Результат = Новый Соответствие;
        Результат.Вставить("object", ПолноеИмя);
        Результат.Вставить("count", Кол);
        Возврат ОбъектВJSONКомпакт(Результат);

КонецФункции

Функция Инструмент_GetSubsystems(Аргументы)
        Возврат ОбъектВJSONКомпакт(СобратьПодсистемы(Метаданные.Подсистемы));
КонецФункции

Функция СобратьПодсистемы(Коллекция)
        Массив = Новый Массив;
        Для Каждого ПС Из Коллекция Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", ПС.Имя);
                Эл.Вставить("synonym", ПС.Синоним);
                Попытка
                        Если ПС.Подсистемы.Количество() > 0 Тогда
                                Эл.Вставить("children", СобратьПодсистемы(ПС.Подсистемы));
                        КонецЕсли;
                Исключение
                КонецПопытки;
                Массив.Добавить(Эл);
        КонецЦикла;
        Возврат Массив;
КонецФункции

Функция Инструмент_GetFunctionalOptions(Аргументы)

        Массив = Новый Массив;
        Для Каждого ФО Из Метаданные.ФункциональныеОпции Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("name", ФО.Имя);
                Эл.Вставить("synonym", ФО.Синоним);
                Значение = Неопределено;
                Попытка
                        Значение = ПолучитьФункциональнуюОпцию(ФО.Имя);
                Исключение
                        // Параметризованные опции читать без параметров нельзя — пропускаем значение
                КонецПопытки;
                Эл.Вставить("value", ЗначениеДляJSON(Значение));
                Массив.Добавить(Эл);
        КонецЦикла;
        Возврат ОбъектВJSONКомпакт(Массив);

КонецФункции

Функция Инструмент_GetConstants(Аргументы)

        ЧитатьЗначения = (Аргументы["include_values"] = Истина);
        Массив = Новый Массив;
        Для Каждого К Из Метаданные.Константы Цикл
                Эл = ОписаниеРеквизита(К);
                Если ЧитатьЗначения Тогда
                        Попытка
                                Эл.Вставить("value", ЗначениеДляJSON(Константы[К.Имя].Получить()));
                        Исключение
                        КонецПопытки;
                КонецЕсли;
                Массив.Добавить(Эл);
        КонецЦикла;
        Возврат ОбъектВJSONКомпакт(Массив);

КонецФункции

Функция Инструмент_GetPredefined(Аргументы)

        ПолноеИмя = Аргументы["full_name"];
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект не найден: " + ПолноеИмя;
        КонецЕсли;

        Имена = Неопределено;
        Попытка
                Имена = МДОбъект.ПолучитьИменаПредопределенных();
        Исключение
                Возврат "У объекта нет предопределённых элементов или тип не поддерживается: " + ПолноеИмя;
        КонецПопытки;

        Результат = Новый Массив;
        Для Каждого Имя Из Имена Цикл
                Результат.Добавить(Имя);
        КонецЦикла;
        Возврат ОбъектВJSONКомпакт(Результат);

КонецФункции

Функция Инструмент_ListReports(Аргументы)

        ЗапросПоиска = Аргументы["query"];
        СтрокаПоиска = ?(ЗапросПоиска = Неопределено, "", НРег(ЗапросПоиска));
        Массив = Новый Массив;
        Для Каждого Отч Из Метаданные.Отчеты Цикл
                Если ЗначениеЗаполнено(СтрокаПоиска)
                        И СтрНайти(НРег(Отч.Имя), СтрокаПоиска) = 0
                        И СтрНайти(НРег(Отч.Синоним), СтрокаПоиска) = 0 Тогда
                        Продолжить;
                КонецЕсли;
                Эл = Новый Соответствие;
                Эл.Вставить("full_name", Отч.ПолноеИмя());
                Эл.Вставить("name", Отч.Имя);
                Эл.Вставить("synonym", Отч.Синоним);
                Массив.Добавить(Эл);
        КонецЦикла;
        Возврат ОбъектВJSONКомпакт(Массив);

КонецФункции

Функция Инструмент_SearchMetadata(Аргументы)
        
        СтрокаПоиска = НРег(Аргументы["query"]);
        ФильтрТипа = Аргументы["type_filter"];
        
        Найденные = Новый Массив;
        
        // Массив коллекций метаданных для поиска
        Коллекции = Новый Соответствие;
        Если Не ЗначениеЗаполнено(ФильтрТипа) Или НРег(ФильтрТипа) = "справочник" Тогда
                Коллекции.Вставить("Справочник", Метаданные.Справочники);
        КонецЕсли;
        Если Не ЗначениеЗаполнено(ФильтрТипа) Или НРег(ФильтрТипа) = "документ" Тогда
                Коллекции.Вставить("Документ", Метаданные.Документы);
        КонецЕсли;
        Если Не ЗначениеЗаполнено(ФильтрТипа) Или НРег(ФильтрТипа) = "регистр" Тогда
                Коллекции.Вставить("РегистрСведений", Метаданные.РегистрыСведений);
                Коллекции.Вставить("РегистрНакопления", Метаданные.РегистрыНакопления);
                Коллекции.Вставить("РегистрБухгалтерии", Метаданные.РегистрыБухгалтерии);
        КонецЕсли;
        Если Не ЗначениеЗаполнено(ФильтрТипа) Или НРег(ФильтрТипа) = "перечисление" Тогда
                Коллекции.Вставить("Перечисление", Метаданные.Перечисления);
        КонецЕсли;
        Если Не ЗначениеЗаполнено(ФильтрТипа) Или НРег(ФильтрТипа) = "пвх" Тогда
                Коллекции.Вставить("ПланВидовХарактеристик", Метаданные.ПланыВидовХарактеристик);
        КонецЕсли;
        Если Не ЗначениеЗаполнено(ФильтрТипа) Или НРег(ФильтрТипа) = "плансчетов" Тогда
                Коллекции.Вставить("ПланСчетов", Метаданные.ПланыСчетов);
        КонецЕсли;
        
        Для Каждого КЭ Из Коллекции Цикл
                Для Каждого МД Из КЭ.Значение Цикл
                        Если СтрНайти(НРег(МД.Имя), СтрокаПоиска) > 0
                                Или СтрНайти(НРег(МД.Синоним), СтрокаПоиска) > 0 Тогда
                                Эл = Новый Соответствие;
                                Эл.Вставить("full_name", КЭ.Ключ + "." + МД.Имя);
                                Эл.Вставить("name", МД.Имя);
                                Эл.Вставить("synonym", МД.Синоним);
                                Эл.Вставить("type", КЭ.Ключ);
                                Найденные.Добавить(Эл);
                        КонецЕсли;
                КонецЦикла;
        КонецЦикла;
        
        Если Найденные.Количество() = 0 Тогда
                Возврат "Ничего не найдено по запросу: " + Аргументы["query"];
        КонецЕсли;
        
        Возврат ОбъектВJSONКомпакт(Найденные);
        
КонецФункции

#КонецОбласти


// ============================================================================
#Область ГруппаБ_ЧтениеДанных
// ============================================================================

Функция Инструмент_ExecuteQuery(Аргументы)
        
        ТекстЗапроса = Аргументы["query"];
        МаксСтрок = Аргументы["max_rows"];
        Если МаксСтрок = Неопределено Или МаксСтрок = 0 Тогда
                МаксСтрок = 100;
        КонецЕсли;
        Если МаксСтрок > 1000 Тогда
                МаксСтрок = 1000;
        КонецЕсли;
        
        Запрос = Новый Запрос;
        Запрос.Текст = ТекстЗапроса;
        
        РезультатЗапроса = Запрос.Выполнить();
        Колонки = РезультатЗапроса.Колонки;
        Выборка = РезультатЗапроса.Выбрать();
        
        Строки = Новый Массив;
        Счётчик = 0;
        Пока Выборка.Следующий() И Счётчик < МаксСтрок Цикл
                Строка = Новый Соответствие;
                Для Каждого Кол Из Колонки Цикл
                        Значение = Выборка[Кол.Имя];
                        Строка.Вставить(Кол.Имя, ЗначениеДляJSON(Значение));
                КонецЦикла;
                Строки.Добавить(Строка);
                Счётчик = Счётчик + 1;
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("rows", Строки);
        Результат.Вставить("count", Счётчик);
        Результат.Вставить("truncated", Счётчик >= МаксСтрок);
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_GetObjectByRef(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        Если Менеджер = Неопределено Тогда
                Возврат "Не удалось получить менеджер для: " + ПолноеИмя;
        КонецЕсли;
        
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        
	// v2.1: проверка существования только через ПолучитьОбъект
        
        Объект = Ссылка.ПолучитьОбъект();
        Если Объект = Неопределено Тогда
                Возврат "Объект не найден в базе: " + ПолноеИмя + " / " + СтрокаGUID;
        КонецЕсли;
        
        Возврат ОбъектВJSONКомпакт(СериализоватьОбъект(Объект, ПолноеИмя));
        
КонецФункции

Функция Инструмент_GetList(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Топ = Аргументы["top"];
        Если Топ = Неопределено Или Топ = 0 Тогда Топ = 50; КонецЕсли;
        Если Топ > 500 Тогда Топ = 500; КонецЕсли;
        Пропустить = Аргументы["skip"];
        Если Пропустить = Неопределено Тогда Пропустить = 0; КонецЕсли;
        Фильтр = Аргументы["filter"];
        
        ТекстЗапроса = "ВЫБРАТЬ ПЕРВЫЕ " + Формат(Топ + Пропустить, "ЧГ=") + "
        |  Т.Ссылка КАК Ссылка,
        |  ВЫРАЗИТЬ(Т.Ссылка КАК СТРОКА(36)) КАК GUID";
        
        // Пробуем добавить Код и Наименование
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект <> Неопределено Тогда
                Попытка
                        Для Каждого СР Из МДОбъект.СтандартныеРеквизиты Цикл
                                Если СР.Имя = "Код" Тогда
                                        ТекстЗапроса = ТекстЗапроса + ",
                                        |  Т.Код КАК Код";
                                КонецЕсли;
                                Если СР.Имя = "Наименование" Тогда
                                        ТекстЗапроса = ТекстЗапроса + ",
                                        |  Т.Наименование КАК Наименование";
                                КонецЕсли;
                                Если СР.Имя = "Дата" Тогда
                                        ТекстЗапроса = ТекстЗапроса + ",
                                        |  Т.Дата КАК Дата";
                                КонецЕсли;
                                Если СР.Имя = "Номер" Тогда
                                        ТекстЗапроса = ТекстЗапроса + ",
                                        |  Т.Номер КАК Номер";
                                КонецЕсли;
                        КонецЦикла;
                Исключение
                КонецПопытки;
        КонецЕсли;
        
        ТекстЗапроса = ТекстЗапроса + "
        |ИЗ
        |  " + ПолноеИмя + " КАК Т";
        
        Если ЗначениеЗаполнено(Фильтр) Тогда
                ТекстЗапроса = ТекстЗапроса + "
                |ГДЕ " + Фильтр;
        КонецЕсли;
        
        Запрос = Новый Запрос;
        Запрос.Текст = ТекстЗапроса;
        
        РезультатЗапроса = Запрос.Выполнить();
        Выборка = РезультатЗапроса.Выбрать();
        
        Строки = Новый Массив;
        Счётчик = 0;
        Номер = 0;
        Пока Выборка.Следующий() Цикл
                Номер = Номер + 1;
                Если Номер <= Пропустить Тогда Продолжить; КонецЕсли;
                Если Счётчик >= Топ Тогда Прервать; КонецЕсли;
                
                Строка = Новый Соответствие;
                Для Каждого Кол Из РезультатЗапроса.Колонки Цикл
                        Строка.Вставить(Кол.Имя, ЗначениеДляJSON(Выборка[Кол.Имя]));
                КонецЦикла;
                Строки.Добавить(Строка);
                Счётчик = Счётчик + 1;
        КонецЦикла;
        
        Возврат ОбъектВJSONКомпакт(Строки);
        
КонецФункции

Функция Инструмент_FindByCode(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Код = Аргументы["code"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        Если Менеджер = Неопределено Тогда
                Возврат "Не удалось получить менеджер для: " + ПолноеИмя;
        КонецЕсли;
        
        Ссылка = Менеджер.НайтиПоКоду(Код);
        Если Не ЗначениеЗаполнено(Ссылка) Тогда
                Возврат "Объект с кодом '" + Код + "' не найден в " + ПолноеИмя;
        КонецЕсли;
        
        Объект = Ссылка.ПолучитьОбъект();
        Возврат ОбъектВJSONКомпакт(СериализоватьОбъект(Объект, ПолноеИмя));
        
КонецФункции

Функция Инструмент_FindByName(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Имя = Аргументы["name"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        Если Менеджер = Неопределено Тогда
                Возврат "Не удалось получить менеджер для: " + ПолноеИмя;
        КонецЕсли;
        
        Ссылка = Менеджер.НайтиПоНаименованию(Имя, Истина);
        Если Не ЗначениеЗаполнено(Ссылка) Тогда
                Возврат "Объект с наименованием '" + Имя + "' не найден в " + ПолноеИмя;
        КонецЕсли;
        
        Объект = Ссылка.ПолучитьОбъект();
        Возврат ОбъектВJSONКомпакт(СериализоватьОбъект(Объект, ПолноеИмя));
        
КонецФункции

Функция Инструмент_GetRegisterRecords(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МаксСтрок = Аргументы["max_rows"];
        Если МаксСтрок = Неопределено Или МаксСтрок = 0 Тогда МаксСтрок = 100; КонецЕсли;
        ПериодС = Аргументы["period_from"];
        ПериодПо = Аргументы["period_to"];
        Фильтр = Аргументы["filter"];
        
        ТекстЗапроса = "ВЫБРАТЬ ПЕРВЫЕ " + Формат(МаксСтрок, "ЧГ=") + " *
        |ИЗ " + ПолноеИмя + " КАК Р";
        
        Условия = Новый Массив;
        
        Если ЗначениеЗаполнено(ПериодС) Тогда
                Условия.Добавить("Р.Период >= ДАТАВРЕМЯ(" + Лев(ПериодС,4) + "," + Сред(ПериодС,5,2) + "," + Прав(ПериодС,2) + ")");
        КонецЕсли;
        Если ЗначениеЗаполнено(ПериодПо) Тогда
                Условия.Добавить("Р.Период <= ДАТАВРЕМЯ(" + Лев(ПериодПо,4) + "," + Сред(ПериодПо,5,2) + "," + Прав(ПериодПо,2) + ",23,59,59)");
        КонецЕсли;
        Если ЗначениеЗаполнено(Фильтр) Тогда
                Условия.Добавить(Фильтр);
        КонецЕсли;
        
        Если Условия.Количество() > 0 Тогда
                ТекстЗапроса = ТекстЗапроса + "
                |ГДЕ " + СтрСоединить(Условия, " И ");
        КонецЕсли;
        
        Запрос = Новый Запрос;
        Запрос.Текст = ТекстЗапроса;
        РезультатЗапроса = Запрос.Выполнить();
        Выборка = РезультатЗапроса.Выбрать();
        
        Строки = Новый Массив;
        Пока Выборка.Следующий() Цикл
                Строка = Новый Соответствие;
                Для Каждого Кол Из РезультатЗапроса.Колонки Цикл
                        Строка.Вставить(Кол.Имя, ЗначениеДляJSON(Выборка[Кол.Имя]));
                КонецЦикла;
                Строки.Добавить(Строка);
        КонецЦикла;
        
        Возврат ОбъектВJSONКомпакт(Строки);
        
КонецФункции

Функция Инструмент_GetDocumentList(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Топ = Аргументы["top"];
        Если Топ = Неопределено Или Топ = 0 Тогда Топ = 50; КонецЕсли;
        ПериодС = Аргументы["period_from"];
        ПериодПо = Аргументы["period_to"];
        ТолькоПроведённые = Аргументы["posted_only"];
        
        ТекстЗапроса = "ВЫБРАТЬ ПЕРВЫЕ " + Формат(Топ, "ЧГ=") + "
        |  ВЫРАЗИТЬ(Т.Ссылка КАК СТРОКА(36)) КАК GUID,
        |  Т.Номер КАК Номер,
        |  Т.Дата КАК Дата,
        |  Т.Проведен КАК Проведен,
        |  Т.ПометкаУдаления КАК ПометкаУдаления
        |ИЗ " + ПолноеИмя + " КАК Т";
        
        Условия = Новый Массив;
        Если ЗначениеЗаполнено(ПериодС) Тогда
                Условия.Добавить("Т.Дата >= ДАТАВРЕМЯ(" + Лев(ПериодС,4) + "," + Сред(ПериодС,5,2) + "," + Прав(ПериодС,2) + ")");
        КонецЕсли;
        Если ЗначениеЗаполнено(ПериодПо) Тогда
                Условия.Добавить("Т.Дата <= ДАТАВРЕМЯ(" + Лев(ПериодПо,4) + "," + Сред(ПериодПо,5,2) + "," + Прав(ПериодПо,2) + ",23,59,59)");
        КонецЕсли;
        Если ТолькоПроведённые = Истина Тогда
                Условия.Добавить("Т.Проведен");
        КонецЕсли;
        
        Если Условия.Количество() > 0 Тогда
                ТекстЗапроса = ТекстЗапроса + "
                |ГДЕ " + СтрСоединить(Условия, " И ");
        КонецЕсли;
        
        ТекстЗапроса = ТекстЗапроса + "
        |УПОРЯДОЧИТЬ ПО Т.Дата УБЫВ";
        
        Запрос = Новый Запрос;
        Запрос.Текст = ТекстЗапроса;
        РезультатЗапроса = Запрос.Выполнить();
        Выборка = РезультатЗапроса.Выбрать();
        
        Строки = Новый Массив;
        Пока Выборка.Следующий() Цикл
                Строка = Новый Соответствие;
                Для Каждого Кол Из РезультатЗапроса.Колонки Цикл
                        Строка.Вставить(Кол.Имя, ЗначениеДляJSON(Выборка[Кол.Имя]));
                КонецЦикла;
                Строки.Добавить(Строка);
        КонецЦикла;
        
        Возврат ОбъектВJSONКомпакт(Строки);
        
КонецФункции

#КонецОбласти


// ============================================================================
#Область ГруппаВ_ЗаписьДанных
// ============================================================================

Функция Инструмент_CreateObject(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Реквизиты = Аргументы["attributes"];
        ТабличныеЧасти = Аргументы["tabular_sections"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        // Создаём объект
        Если Части.Тип = "Справочник" Тогда
                НовыйОбъект = Справочники[Части.Имя].СоздатьЭлемент();
        ИначеЕсли Части.Тип = "Документ" Тогда
                НовыйОбъект = Документы[Части.Имя].СоздатьДокумент();
        Иначе
                Возврат "Создание поддерживается только для справочников и документов";
        КонецЕсли;
        
        // Заполняем реквизиты
        Если ТипЗнч(Реквизиты) = Тип("Соответствие") Тогда
                ЗаполнитьРеквизитыОбъекта(НовыйОбъект, Реквизиты, ПолноеИмя);
        КонецЕсли;
        
        // Заполняем табличные части
        Если ТипЗнч(ТабличныеЧасти) = Тип("Соответствие") Тогда
                Для Каждого ТЧ Из ТабличныеЧасти Цикл
                        ИмяТЧ = ТЧ.Ключ;
                        СтрокиТЧ = ТЧ.Значение;
                        Если ТипЗнч(СтрокиТЧ) = Тип("Массив") Тогда
                                Для Каждого СтрокаДанных Из СтрокиТЧ Цикл
                                        НоваяСтрока = НовыйОбъект[ИмяТЧ].Добавить();
                                        Если ТипЗнч(СтрокаДанных) = Тип("Соответствие") Тогда
                                                Для Каждого Кол Из СтрокаДанных Цикл
                                                        Попытка
                                                                УстановитьЗначениеРеквизита(НоваяСтрока, Кол.Ключ, Кол.Значение);
                                                        Исключение
                                                        КонецПопытки;
                                                КонецЦикла;
                                        КонецЕсли;
                                КонецЦикла;
                        КонецЕсли;
                КонецЦикла;
        КонецЕсли;
        
        НовыйОбъект.Записать();
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("guid", Строка(НовыйОбъект.Ссылка.УникальныйИдентификатор()));
        Попытка
                Результат.Вставить("code", НовыйОбъект.Код);
        Исключение
        КонецПопытки;
        Попытка
                Результат.Вставить("number", НовыйОбъект.Номер);
        Исключение
        КонецПопытки;
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_UpdateObject(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        Реквизиты = Аргументы["attributes"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        Объект = Ссылка.ПолучитьОбъект();
        
        Если Объект = Неопределено Тогда
                Возврат "Объект не найден: " + СтрокаGUID;
        КонецЕсли;
        
        Если ТипЗнч(Реквизиты) = Тип("Соответствие") Тогда
                ЗаполнитьРеквизитыОбъекта(Объект, Реквизиты, ПолноеИмя);
        КонецЕсли;
        
        Объект.Записать();
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("guid", СтрокаGUID);
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_DeleteObject(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        СнятьПометку = Аргументы["unmark"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        Объект = Ссылка.ПолучитьОбъект();
        
        Если Объект = Неопределено Тогда
                Возврат "Объект не найден: " + СтрокаGUID;
        КонецЕсли;
        
        Объект.ПометкаУдаления = НЕ (СнятьПометку = Истина);
        Объект.Записать();
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("deletion_mark", Объект.ПометкаУдаления);
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_PostDocument(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части.Тип <> "Документ" Тогда
                Возврат "Проведение поддерживается только для документов";
        КонецЕсли;
        
        Менеджер = Документы[Части.Имя];
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        Док = Ссылка.ПолучитьОбъект();
        
        Если Док = Неопределено Тогда
                Возврат "Документ не найден: " + СтрокаGUID;
        КонецЕсли;
        
        Док.Записать(РежимЗаписиДокумента.Проведение);
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("posted", Истина);
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_UnpostDocument(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части.Тип <> "Документ" Тогда
                Возврат "Отмена проведения поддерживается только для документов";
        КонецЕсли;
        
        Док = Документы[Части.Имя].ПолучитьСсылку(
                Новый УникальныйИдентификатор(СтрокаGUID)).ПолучитьОбъект();
        
        Если Док = Неопределено Тогда
                Возврат "Документ не найден: " + СтрокаGUID;
        КонецЕсли;
        
        Док.Записать(РежимЗаписиДокумента.ОтменаПроведения);
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("posted", Ложь);
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_CopyObject(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        Объект = Ссылка.ПолучитьОбъект();
        
        Если Объект = Неопределено Тогда
                Возврат "Объект не найден: " + СтрокаGUID;
        КонецЕсли;
        
        Копия = Объект.Скопировать();
        Копия.Записать();
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("source_guid", СтрокаGUID);
        Результат.Вставить("new_guid", Строка(Копия.Ссылка.УникальныйИдентификатор()));
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_SetAttribute(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        ИмяРеквизита = Аргументы["attribute_name"];
        Значение = Аргументы["value"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        Объект = Ссылка.ПолучитьОбъект();
        
        Если Объект = Неопределено Тогда
                Возврат "Объект не найден: " + СтрокаGUID;
        КонецЕсли;
        
        УстановитьЗначениеРеквизита(Объект, ИмяРеквизита, Значение);
        Объект.Записать();
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("attribute", ИмяРеквизита);
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

#КонецОбласти


// ============================================================================
#Область ГруппаГ_КодИОтчёты
// ============================================================================

Функция Инструмент_ExecuteCode(Аргументы)
        
        Код = Аргументы["code"];
        
        // Логируем в журнал регистрации для аудита
        ЗаписьЖурналаРегистрации("INFATON.ExecuteCode",
                УровеньЖурналаРегистрации.Информация, , , Лев(Код, 500));
        
        Результат = "";
        
        // Код должен записать результат в переменную Результат
        Выполнить(Код);
        
        Если ТипЗнч(Результат) = Тип("Строка") Тогда
                Возврат Результат;
        Иначе
                Попытка
                        Возврат ОбъектВJSONКомпакт(Результат);
                Исключение
                        Возврат Строка(Результат);
                КонецПопытки;
        КонецЕсли;
        
КонецФункции

Функция Инструмент_EvaluateExpression(Аргументы)
        
        Выражение = Аргументы["expression"];
        Результат = Вычислить(Выражение);
        
        Если ТипЗнч(Результат) = Тип("Строка") Тогда
                Возврат Результат;
        Иначе
                Попытка
                        Возврат ОбъектВJSONКомпакт(Результат);
                Исключение
                        Возврат Строка(Результат);
                КонецПопытки;
        КонецЕсли;
        
КонецФункции

Функция Инструмент_GetModuleText(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        ТипМодуля = Аргументы["module_type"];
        Если Не ЗначениеЗаполнено(ТипМодуля) Тогда
                ТипМодуля = "ОбъектМодуль";
        КонецЕсли;
        
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                Возврат "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        // Попытка получить текст модуля через встроенные средства
        // Это работает только в привилегированном режиме с отключённым безопасным режимом
        Попытка
                ОбъектМД = РасширенияКонфигурации.Получить(МДОбъект);
                // Альтернативный способ через код
                Код = "
                |МДОбъект = Метаданные.НайтиПоПолномуИмени(""" + ПолноеИмя + """);
                |Результат = 'Получение текста модуля " + ТипМодуля + " для ' + МДОбъект.ПолноеИмя() + ' не поддерживается в runtime. Используйте Конфигуратор или EDT.'";
                Возврат "Получение текста модуля " + ТипМодуля + " для " + ПолноеИмя + " не поддерживается в runtime HTTP-сервиса. Используйте Конфигуратор или EDT для просмотра модулей.";
        Исключение
                Возврат "Получение текста модуля " + ТипМодуля + " для " + ПолноеИмя + " не поддерживается в runtime HTTP-сервиса. Используйте Конфигуратор или EDT для просмотра модулей. Ошибка: " + ОписаниеОшибки();
        КонецПопытки;
        
КонецФункции

Функция Инструмент_GenerateReport(Аргументы)
        
        ТекстЗапроса = Аргументы["query"];
        ФорматВывода = Аргументы["format"];
        Если Не ЗначениеЗаполнено(ФорматВывода) Тогда
                ФорматВывода = "text";
        КонецЕсли;
        
        Запрос = Новый Запрос;
        Запрос.Текст = ТекстЗапроса;
        РезультатЗапроса = Запрос.Выполнить();
        
        Если ФорматВывода = "json" Тогда
                Выборка = РезультатЗапроса.Выбрать();
                Строки = Новый Массив;
                Пока Выборка.Следующий() Цикл
                        Строка = Новый Соответствие;
                        Для Каждого Кол Из РезультатЗапроса.Колонки Цикл
                                Строка.Вставить(Кол.Имя, ЗначениеДляJSON(Выборка[Кол.Имя]));
                        КонецЦикла;
                        Строки.Добавить(Строка);
                КонецЦикла;
                Возврат ОбъектВJSONКомпакт(Строки);
        Иначе
                // Текстовый формат
                Выборка = РезультатЗапроса.Выбрать();
                Текст = "";
                
                // Заголовки
                Заголовки = Новый Массив;
                Для Каждого Кол Из РезультатЗапроса.Колонки Цикл
                        Заголовки.Добавить(Кол.Имя);
                КонецЦикла;
                Текст = СтрСоединить(Заголовки, " | ") + Символы.ПС;
                Текст = Текст + СтрПовторить("—", СтрДлина(Текст)) + Символы.ПС;
                
                // Данные
                Пока Выборка.Следующий() Цикл
                        Значения = Новый Массив;
                        Для Каждого Кол Из РезультатЗапроса.Колонки Цикл
                                Значения.Добавить(Строка(Выборка[Кол.Имя]));
                        КонецЦикла;
                        Текст = Текст + СтрСоединить(Значения, " | ") + Символы.ПС;
                КонецЦикла;
                
                Возврат Текст;
        КонецЕсли;
        
КонецФункции

#КонецОбласти


// ============================================================================
#Область ГруппаД_Администрирование
// ============================================================================

Функция Инструмент_GetActiveUsers(Аргументы)
        
        Сеансы = ПолучитьСеансыИнформационнойБазы();
        
        Список = Новый Массив;
        Для Каждого Сеанс Из Сеансы Цикл
		Попытка
			Инфо = Новый Соответствие;
			Инфо.Вставить("session_number", Сеанс.НомерСеанса);
			Попытка
				Инфо.Вставить("user_name", Строка(Сеанс.Пользователь));
			Исключение
				Инфо.Вставить("user_name", "<неизвестен>");
			КонецПопытки;
			Попытка
				Инфо.Вставить("computer_name", Сеанс.ИмяКомпьютера);
			Исключение
				Инфо.Вставить("computer_name", "");
			КонецПопытки;
			Инфо.Вставить("application", Строка(Сеанс.ИмяПриложения));
			Инфо.Вставить("started_at", Формат(Сеанс.НачалоСеанса, "ДФ=yyyy-MM-dd HH:mm:ss"));
			Инфо.Вставить("last_active", Формат(Сеанс.ПоследняяАктивность, "ДФ=yyyy-MM-dd HH:mm:ss"));
			Список.Добавить(Инфо);
		Исключение
			// Пропускаем проблемные сеансы
		КонецПопытки;
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("sessions", Список);
        Результат.Вставить("total", Список.Количество());
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_GetEventLog(Аргументы)
        
        МаксСтрок = Аргументы["max_rows"];
        Если МаксСтрок = Неопределено Или МаксСтрок = 0 Тогда МаксСтрок = 200; КонецЕсли;
        ПериодС = Аргументы["period_from"];
        ПериодПо = Аргументы["period_to"];
        ФильтрСобытий = Аргументы["event_filter"];
        ФильтрПользователя = Аргументы["user_filter"];
        
        Отбор = Новый Структура;
        
        // Период
        Если ЗначениеЗаполнено(ПериодС) Тогда
		ДатаНач = ПреобразоватьДату(ПериодС);
		Если ДатаНач <> Неопределено Тогда
			Отбор.Вставить("ДатаНачала", ДатаНач);
		Иначе
			Отбор.Вставить("ДатаНачала", НачалоДня(ТекущаяДата()));
		КонецЕсли;
        Иначе
                Отбор.Вставить("ДатаНачала", НачалоДня(ТекущаяДата()));
        КонецЕсли;
        
        Если ЗначениеЗаполнено(ПериодПо) Тогда
		ДатаКон = ПреобразоватьДату(ПериодПо);
		Если ДатаКон <> Неопределено Тогда
			Отбор.Вставить("ДатаОкончания", КонецДня(ДатаКон));
		Иначе
			Отбор.Вставить("ДатаОкончания", КонецДня(ТекущаяДата()));
		КонецЕсли;
        Иначе
                Отбор.Вставить("ДатаОкончания", КонецДня(ТекущаяДата()));
        КонецЕсли;
        
        // Фильтр по событиям
        Если ЗначениеЗаполнено(ФильтрСобытий) Тогда
                МассивСобытий = Новый Массив;
                МассивСобытий.Добавить(ФильтрСобытий);
                Отбор.Вставить("Событие", МассивСобытий);
        КонецЕсли;
        
        СобытияЖурнала = Новый ТаблицаЗначений;
        ВыгрузитьЖурналРегистрации(СобытияЖурнала, Отбор);
        
        // Ограничиваем кол-во
        Строки = Новый Массив;
        Количество = Мин(МаксСтрок, СобытияЖурнала.Количество());
        
        Для Инд = 0 По Количество - 1 Цикл
                СтрокаТЗ = СобытияЖурнала[Инд];
                Эл = Новый Соответствие;
                Эл.Вставить("date", Формат(СтрокаТЗ.Дата, "ДФ=yyyy-MM-dd HH:mm:ss"));
                Эл.Вставить("event", Строка(СтрокаТЗ.Событие));
                Эл.Вставить("level", Строка(СтрокаТЗ.Уровень));
                Эл.Вставить("user", Строка(СтрокаТЗ.ИмяПользователя));
                Эл.Вставить("computer", Строка(СтрокаТЗ.Компьютер));
                Эл.Вставить("comment", Строка(СтрокаТЗ.Комментарий));
			Попытка
				Если СтрокаТЗ.Метаданные <> Неопределено Тогда
					Эл.Вставить("metadata", СтрокаТЗ.Метаданные.ПолноеИмя());
				Иначе
					Эл.Вставить("metadata", "");
				КонецЕсли;
			Исключение
				Эл.Вставить("metadata", Строка(СтрокаТЗ.Метаданные));
			КонецПопытки;
                
                // Фильтр по пользователю (если задан)
                Если ЗначениеЗаполнено(ФильтрПользователя) Тогда
                        Если СтрНайти(НРег(Строка(СтрокаТЗ.ИмяПользователя)), НРег(ФильтрПользователя)) > 0 Тогда
                                Строки.Добавить(Эл);
                        КонецЕсли;
                Иначе
                        Строки.Добавить(Эл);
                КонецЕсли;
        КонецЦикла;
        
        Возврат ОбъектВJSONКомпакт(Строки);
        
КонецФункции

Функция Инструмент_GetLocks(Аргументы)
        
        Блокировки = Новый Массив;
        
        // Получаем блокировки через сеансы
        Сеансы = ПолучитьСеансыИнформационнойБазы();
        Для Каждого Сеанс Из Сеансы Цикл
                Попытка
                        БлокСеанса = Сеанс.ПолучитьБлокировкиСеанса();
                        Для Каждого Блок Из БлокСеанса Цикл
                                Инфо = Новый Соответствие;
                                Инфо.Вставить("session_number", Сеанс.НомерСеанса);
                                Инфо.Вставить("user_name", Строка(Сеанс.Пользователь));
                                Инфо.Вставить("object", Строка(Блок.Объект));
                                Инфо.Вставить("locked_at", Формат(Блок.НачалоУстановки, "ДФ=yyyy-MM-dd HH:mm:ss"));
                                Блокировки.Добавить(Инфо);
                        КонецЦикла;
                Исключение
                КонецПопытки;
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("locks", Блокировки);
        Результат.Вставить("total", Блокировки.Количество());
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_GetServerInfo(Аргументы)
        СистемнаяИнформация=Новый СистемнаяИнформация;
        Инфо = Новый Соответствие;
        Инфо.Вставить("platform_version", СистемнаяИнформация.ВерсияПриложения);
        Инфо.Вставить("current_date", Формат(ТекущаяДата(), "ДФ=yyyy-MM-dd HH:mm:ss"));
        Инфо.Вставить("session_date", Формат(ТекущаяДатаСеанса(), "ДФ=yyyy-MM-dd HH:mm:ss"));
        
        // Имя информационной базы
        Попытка
                СтрокаСоединения = СтрокаСоединенияИнформационнойБазы();
                Инфо.Вставить("connection_string", СтрокаСоединения);
        Исключение
        КонецПопытки;
        
        // Имя конфигурации
        Инфо.Вставить("configuration_name", Метаданные.Имя);
        Инфо.Вставить("configuration_synonym", Метаданные.Синоним);
        Инфо.Вставить("configuration_version", Метаданные.Версия);
        
        // Режим совместимости
        Инфо.Вставить("compatibility_mode", Строка(Метаданные.РежимСовместимости));
        
        // Статистика объектов
        Стат = Новый Соответствие;
        Стат.Вставить("catalogs", Метаданные.Справочники.Количество());
        Стат.Вставить("documents", Метаданные.Документы.Количество());
        Стат.Вставить("information_registers", Метаданные.РегистрыСведений.Количество());
        Стат.Вставить("accumulation_registers", Метаданные.РегистрыНакопления.Количество());
        Стат.Вставить("accounting_registers", Метаданные.РегистрыБухгалтерии.Количество());
        Стат.Вставить("enums", Метаданные.Перечисления.Количество());
        Инфо.Вставить("metadata_stats", Стат);
        
        // Текущий пользователь
        Инфо.Вставить("current_user", ИмяПользователя());
        
        Возврат ОбъектВJSONКомпакт(Инфо);
        
КонецФункции

Функция Инструмент_CheckReferences(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        
        МассивСсылок = Новый Массив;
        МассивСсылок.Добавить(Ссылка);
        
        ТаблицаСсылок = НайтиПоСсылкам(МассивСсылок);
        
        Найденные = Новый Массив;
        Для Каждого Строка Из ТаблицаСсылок Цикл
                Эл = Новый Соответствие;
                Эл.Вставить("referencing_object", Строка(Строка.Данные));
                Эл.Вставить("metadata", Строка.Метаданные.ПолноеИмя());
                Попытка
                        Эл.Вставить("guid", Строка(Строка.Данные.УникальныйИдентификатор()));
                Исключение
                КонецПопытки;
                Найденные.Добавить(Эл);
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("references", Найденные);
        Результат.Вставить("total", Найденные.Количество());
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_RunScheduledJob(Аргументы)
        
        ИмяЗадания = Аргументы["job_name"];
        
        // Находим метаданные регламентного задания
        МДЗадания = Метаданные.РегламентныеЗадания.Найти(ИмяЗадания);
        Если МДЗадания = Неопределено Тогда
                // Пробуем поиск по синониму
                Для Каждого МД Из Метаданные.РегламентныеЗадания Цикл
                        Если МД.Имя = ИмяЗадания Или МД.Синоним = ИмяЗадания Тогда
                                МДЗадания = МД;
                                Прервать;
                        КонецЕсли;
                КонецЦикла;
        КонецЕсли;
        
        Если МДЗадания = Неопределено Тогда
                // Выводим список доступных заданий
                Список = Новый Массив;
                Для Каждого МД Из Метаданные.РегламентныеЗадания Цикл
                        Список.Добавить(МД.Имя + " (" + МД.Синоним + ")");
                КонецЦикла;
                Возврат "Регламентное задание '" + ИмяЗадания + "' не найдено. Доступные задания: " + СтрСоединить(Список, ", ");
        КонецЕсли;
        
        // Получаем задание и выполняем
        Отбор = Новый Структура("Метаданные", МДЗадания);
        Задания = РегламентныеЗадания.ПолучитьРегламентныеЗадания(Отбор);
        
        Если Задания.Количество() = 0 Тогда
                Возврат "Экземпляр регламентного задания '" + ИмяЗадания + "' не найден";
        КонецЕсли;
        
        Задание = Задания[0];
        ФоновоеЗадание = Задание.ВыполнитьСейчас();
        ФоновоеЗадание.ОжидатьЗавершения(60); // таймаут 60 сек
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("job_name", ИмяЗадания);
        Результат.Вставить("state", Строка(ФоновоеЗадание.Состояние));
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

#КонецОбласти


// ============================================================================
#Область ГруппаЕ_Интеграция
// ============================================================================

Функция Инструмент_ExchangeExecute(Аргументы)
        
        ИмяПланаОбмена = Аргументы["exchange_plan"];
        КодУзла = Аргументы["node_code"];
        
        // Находим узел плана обмена
        МДПлана = Метаданные.ПланыОбмена.Найти(ИмяПланаОбмена);
        Если МДПлана = Неопределено Тогда
                // Выводим список доступных планов обмена
                Список = Новый Массив;
                Для Каждого МД Из Метаданные.ПланыОбмена Цикл
                        Список.Добавить(МД.Имя + " (" + МД.Синоним + ")");
                КонецЦикла;
                Возврат "План обмена '" + ИмяПланаОбмена + "' не найден. Доступные: " + СтрСоединить(Список, ", ");
        КонецЕсли;
        
        // Если указан код узла — находим конкретный узел
        Если ЗначениеЗаполнено(КодУзла) Тогда
                Узел = ПланыОбмена[ИмяПланаОбмена].НайтиПоКоду(КодУзла);
                Если Не ЗначениеЗаполнено(Узел) Тогда
                        Возврат "Узел с кодом '" + КодУзла + "' не найден в плане обмена " + ИмяПланаОбмена;
                КонецЕсли;
        Иначе
                // Берём первый не-ЭтотУзел
                Запрос = Новый Запрос;
                Запрос.Текст = "ВЫБРАТЬ ПЕРВЫЕ 1 Т.Ссылка ИЗ ПланОбмена." + ИмяПланаОбмена + " КАК Т ГДЕ Т.Ссылка <> &ЭтотУзел";
                Запрос.УстановитьПараметр("ЭтотУзел", ПланыОбмена[ИмяПланаОбмена].ЭтотУзел());
                Рез = Запрос.Выполнить();
                Если Рез.Пустой() Тогда
                        Возврат "В плане обмена " + ИмяПланаОбмена + " нет узлов-получателей";
                КонецЕсли;
                Выб = Рез.Выбрать();
                Выб.Следующий();
                Узел = Выб.Ссылка;
        КонецЕсли;
        
        Результат = Новый Соответствие;
        Результат.Вставить("exchange_plan", ИмяПланаОбмена);
        Результат.Вставить("node", Строка(Узел));
        Результат.Вставить("note", "Для полноценного выполнения обмена используйте execute_code с вызовом конкретных обработок обмена вашей конфигурации");
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

Функция Инструмент_GetExchangeLog(Аргументы)
        
        МаксСтрок = Аргументы["max_rows"];
        Если МаксСтрок = Неопределено Или МаксСтрок = 0 Тогда МаксСтрок = 50; КонецЕсли;
        ПериодС = Аргументы["period_from"];
        
        // Читаем журнал регистрации с фильтром по событиям обмена
        Отбор = Новый Структура;
        Если ЗначениеЗаполнено(ПериодС) Тогда
                Отбор.Вставить("ДатаНачала", Дата(ПериодС + "000000"));
        Иначе
                Отбор.Вставить("ДатаНачала", ТекущаяДата() - 7 * 86400); // 7 дней назад
        КонецЕсли;
        Отбор.Вставить("ДатаОкончания", КонецДня(ТекущаяДата()));
        
        МассивСобытий = Новый Массив;
        МассивСобытий.Добавить("_$Data$_.Post");
        МассивСобытий.Добавить("_$InfoBase$_.EraseData");
        Отбор.Вставить("Событие", МассивСобытий);
        
        СобытияЖурнала = Новый ТаблицаЗначений;
        ВыгрузитьЖурналРегистрации(СобытияЖурнала, Отбор);
        
        Строки = Новый Массив;
        Количество = Мин(МаксСтрок, СобытияЖурнала.Количество());
        Для Инд = 0 По Количество - 1 Цикл
                С = СобытияЖурнала[Инд];
                Эл = Новый Соответствие;
                Эл.Вставить("date", Формат(С.Дата, "ДФ=yyyy-MM-dd HH:mm:ss"));
                Эл.Вставить("event", Строка(С.Событие));
                Эл.Вставить("comment", Строка(С.Комментарий));
                Эл.Вставить("user", Строка(С.ИмяПользователя));
                Строки.Добавить(Эл);
        КонецЦикла;
        
        Возврат ОбъектВJSONКомпакт(Строки);
        
КонецФункции

Функция Инструмент_ImportData(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Данные = Аргументы["data"];
        ОбновлятьСуществующие = Аргументы["update_existing"];
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Если ТипЗнч(Данные) <> Тип("Массив") Тогда
                Возврат "Параметр data должен быть массивом JSON-объектов";
        КонецЕсли;
        
        Создано = 0;
        Обновлено = 0;
        Ошибок = 0;
        ОшибкиТекст = Новый Массив;
        
        Для Каждого ЭлементДанных Из Данные Цикл
                Попытка
                        Если ТипЗнч(ЭлементДанных) <> Тип("Соответствие") Тогда
                                Ошибок = Ошибок + 1;
                                Продолжить;
                        КонецЕсли;
                        
                        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
                        
                        // Пробуем найти существующий по коду
                        Объект = Неопределено;
                        Если ОбновлятьСуществующие = Истина И ЭлементДанных["Код"] <> Неопределено Тогда
                                Ссылка = Менеджер.НайтиПоКоду(ЭлементДанных["Код"]);
                                Если ЗначениеЗаполнено(Ссылка) Тогда
                                        Объект = Ссылка.ПолучитьОбъект();
                                КонецЕсли;
                        КонецЕсли;
                        
                        Если Объект = Неопределено Тогда
                                Если Части.Тип = "Справочник" Тогда
                                        Объект = Справочники[Части.Имя].СоздатьЭлемент();
                                ИначеЕсли Части.Тип = "Документ" Тогда
                                        Объект = Документы[Части.Имя].СоздатьДокумент();
                                КонецЕсли;
                                ЗаполнитьРеквизитыОбъекта(Объект, ЭлементДанных, ПолноеИмя);
                                Объект.Записать();
                                Создано = Создано + 1;
                        Иначе
                                ЗаполнитьРеквизитыОбъекта(Объект, ЭлементДанных, ПолноеИмя);
                                Объект.Записать();
                                Обновлено = Обновлено + 1;
                        КонецЕсли;
                        
                Исключение
                        Ошибок = Ошибок + 1;
                        ОшибкиТекст.Добавить(ОписаниеОшибки());
                КонецПопытки;
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("created", Создано);
        Результат.Вставить("updated", Обновлено);
        Результат.Вставить("errors", Ошибок);
        Если ОшибкиТекст.Количество() > 0 Тогда
                Результат.Вставить("error_details", ОшибкиТекст);
        КонецЕсли;
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

#КонецОбласти



// ============================================================================
#Область ГруппаЖ_НовыеИнструменты_v20
// ============================================================================

// G1: Создание объекта на основании другого (цепочки документов)
// Использует типовой механизм ЗаполнитьНаОсновании() платформы 1С
//
Функция Инструмент_FillOnBasis(Аргументы)
        
        ЦелевойТип = Аргументы["target_type"];
        ТипОснования = Аргументы["base_type"];
        GUIDОснования = Аргументы["base_guid"];
        ДопРеквизиты = Аргументы["attributes"];
        
        // Получаем ссылку на объект-основание
        ЧастиОснования = РазобратьПолноеИмя(ТипОснования);
        Если ЧастиОснования = Неопределено Тогда
                Возврат "Некорректное имя основания: " + ТипОснования;
        КонецЕсли;
        
        МенеджерОснования = ПолучитьМенеджерОбъекта(ЧастиОснования.Тип, ЧастиОснования.Имя);
        Если МенеджерОснования = Неопределено Тогда
                Возврат "Не удалось получить менеджер для: " + ТипОснования;
        КонецЕсли;
        
        УИДОснования = Новый УникальныйИдентификатор(GUIDОснования);
        СсылкаОснования = МенеджерОснования.ПолучитьСсылку(УИДОснования);
        
	// v2.1: ПолучитьСсылку() всегда непустая, проверяем реальное существование
	Если СсылкаОснования.ПолучитьОбъект() = Неопределено Тогда
		Возврат "Объект-основание не существует в базе: " + ТипОснования + " / " + GUIDОснования;
        КонецЕсли;

        // Создаём целевой объект
        ЧастиЦели = РазобратьПолноеИмя(ЦелевойТип);
        Если ЧастиЦели = Неопределено Тогда
                Возврат "Некорректное имя целевого типа: " + ЦелевойТип;
        КонецЕсли;
        
        Если ЧастиЦели.Тип = "Справочник" Тогда
                НовыйОбъект = Справочники[ЧастиЦели.Имя].СоздатьЭлемент();
        ИначеЕсли ЧастиЦели.Тип = "Документ" Тогда
                НовыйОбъект = Документы[ЧастиЦели.Имя].СоздатьДокумент();
        Иначе
                Возврат "Создание на основании поддерживается только для справочников и документов";
        КонецЕсли;
        
        // Вызываем типовой механизм заполнения на основании
        Попытка
                НовыйОбъект.Заполнить(СсылкаОснования);
        Исключение
                // Некоторые объекты не поддерживают Заполнить() — пробуем ЗаполнитьНаОсновании()
                Попытка
                        ДанныеЗаполнения = Новый Структура;
                        ДанныеЗаполнения.Вставить("Основание", СсылкаОснования);
                        НовыйОбъект.Заполнить(ДанныеЗаполнения);
                Исключение
                        Возврат "Ошибка заполнения на основании: " + ОписаниеОшибки();
                КонецПопытки;
        КонецПопытки;
        
        // Переопределяем реквизиты, если указаны
        Если ТипЗнч(ДопРеквизиты) = Тип("Соответствие") Тогда
                ЗаполнитьРеквизитыОбъекта(НовыйОбъект, ДопРеквизиты, ЦелевойТип);
        КонецЕсли;
        
        // Записываем
        НовыйОбъект.Записать();
        
        // Формируем результат
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("guid", Строка(НовыйОбъект.Ссылка.УникальныйИдентификатор()));
        Результат.Вставить("target_type", ЦелевойТип);
        Результат.Вставить("base_type", ТипОснования);
        Результат.Вставить("base_guid", GUIDОснования);
        Попытка Результат.Вставить("number", НовыйОбъект.Номер); Исключение КонецПопытки;
        Попытка Результат.Вставить("code", НовыйОбъект.Код); Исключение КонецПопытки;
        Попытка Результат.Вставить("date", Формат(НовыйОбъект.Дата, "ДФ=yyyy-MM-ddTHH:mm:ss")); Исключение КонецПопытки;
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции


// G2: Запись в регистр сведений напрямую
// Поддерживает периодические и непериодические регистры
//
Функция Инструмент_WriteRegisterRecords(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Записи = Аргументы["records"];
        Заменять = Аргументы["replace"];
        ПериодСтрока = Аргументы["period"];
        
        Если Заменять = Неопределено Тогда Заменять = Ложь; КонецЕсли;
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Если Части.Тип <> "РегистрСведений" Тогда
                Возврат "Инструмент поддерживает только РегистрСведений. Получено: " + Части.Тип;
        КонецЕсли;
        
        Если ТипЗнч(Записи) <> Тип("Массив") Тогда
                Возврат "Параметр records должен быть массивом";
        КонецЕсли;
        
        МенеджерЗаписей = РегистрыСведений[Части.Имя];
        МДРегистр = Метаданные.РегистрыСведений[Части.Имя];
        
        ЭтоПериодический = (МДРегистр.ПериодичностьРегистраСведений <> Метаданные.СвойстваОбъектов.ПериодичностьРегистраСведений.Непериодический);
        
        Записано = 0;
        Ошибок = 0;
        ОшибкиТекст = Новый Массив;
        
        Для Каждого ДанныеЗаписи Из Записи Цикл
                Попытка
                        НабЗап = МенеджерЗаписей.СоздатьНаборЗаписей();
                        
                        // Устанавливаем отбор по измерениям
                        Для Каждого Изм Из МДРегистр.Измерения Цикл
                                Если ДанныеЗаписи[Изм.Имя] <> Неопределено Тогда
                                        ЗначениеИзм = ПреобразоватьЗначениеДляРегистра(Изм, ДанныеЗаписи[Изм.Имя]);
                                        НабЗап.Отбор[Изм.Имя].Установить(ЗначениеИзм);
                                КонецЕсли;
                        КонецЦикла;
                        
                        // Период
                        Если ЭтоПериодический Тогда
                                ДатаПериода = Неопределено;
                                Если ДанныеЗаписи["Период"] <> Неопределено Тогда
                                        ДатаПериода = ПреобразоватьДату(ДанныеЗаписи["Период"]);
                                ИначеЕсли ПериодСтрока <> Неопределено И Не ПустаяСтрока(ПериодСтрока) Тогда
                                        ДатаПериода = ПреобразоватьДату(ПериодСтрока);
                                Иначе
                                        ДатаПериода = ТекущаяДатаСеанса();
                                КонецЕсли;
                                НабЗап.Отбор.Период.Установить(ДатаПериода);
                        КонецЕсли;
                        
                        // Читаем существующие записи если режим замены
                        Если Заменять Тогда
                                НабЗап.Прочитать();
                                НабЗап.Очистить();
                        КонецЕсли;
                        
                        // Добавляем новую запись
                        НоваяЗапись = НабЗап.Добавить();
                        
                        // Заполняем период
                        Если ЭтоПериодический И ДатаПериода <> Неопределено Тогда
                                НоваяЗапись.Период = ДатаПериода;
                        КонецЕсли;
                        
                        // Заполняем измерения, ресурсы и реквизиты
                        Для Каждого КЗ Из ДанныеЗаписи Цикл
                                Если КЗ.Ключ = "Период" Тогда Продолжить; КонецЕсли;
                                Попытка
                                        НоваяЗапись[КЗ.Ключ] = ПреобразоватьЗначениеПоМетаданным(МДРегистр, КЗ.Ключ, КЗ.Значение);
                                Исключение
                                        Попытка
                                                НоваяЗапись[КЗ.Ключ] = КЗ.Значение;
                                        Исключение
                                        КонецПопытки;
                                КонецПопытки;
                        КонецЦикла;
                        
                        НабЗап.Записать(Заменять);
                        Записано = Записано + 1;
                        
                Исключение
                        Ошибок = Ошибок + 1;
                        ОшибкиТекст.Добавить(ОписаниеОшибки());
                КонецПопытки;
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Ошибок = 0);
        Результат.Вставить("written", Записано);
        Результат.Вставить("errors", Ошибок);
        Если ОшибкиТекст.Количество() > 0 Тогда
                Результат.Вставить("error_details", ОшибкиТекст);
        КонецЕсли;
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции


// G3: Обновление табличной части существующего объекта
// Три режима: replace (полная замена), append (добавление), update_by_index (точечное обновление)
//
Функция Инструмент_UpdateTabularSection(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        СтрокаGUID = Аргументы["guid"];
        ИмяТЧ = Аргументы["tabular_section"];
        Строки = Аргументы["rows"];
        Режим = Аргументы["mode"];
        
        Если Режим = Неопределено Или ПустаяСтрока(Режим) Тогда Режим = "replace"; КонецЕсли;
        
        // Получаем объект
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
        Если Менеджер = Неопределено Тогда
                Возврат "Не удалось получить менеджер для: " + ПолноеИмя;
        КонецЕсли;
        
        УИД = Новый УникальныйИдентификатор(СтрокаGUID);
        Ссылка = Менеджер.ПолучитьСсылку(УИД);
        Объект = Ссылка.ПолучитьОбъект();
        
        Если Объект = Неопределено Тогда
                Возврат "Объект не найден: " + СтрокаGUID;
        КонецЕсли;
        
        // Проверяем существование ТЧ
        Попытка
                ТЧОбъекта = Объект[ИмяТЧ];
        Исключение
                Возврат "Табличная часть не найдена: " + ИмяТЧ;
        КонецПопытки;
        
        Если ТипЗнч(Строки) <> Тип("Массив") Тогда
                Возврат "Параметр rows должен быть массивом";
        КонецЕсли;
        
        // Режим replace — очищаем и заполняем заново
        Если Режим = "replace" Тогда
                Объект[ИмяТЧ].Очистить();
                Для Каждого СтрокаДанных Из Строки Цикл
                        НоваяСтрока = Объект[ИмяТЧ].Добавить();
                        Если ТипЗнч(СтрокаДанных) = Тип("Соответствие") Тогда
                                Для Каждого Кол Из СтрокаДанных Цикл
                                        Попытка
                                                УстановитьЗначениеРеквизита(НоваяСтрока, Кол.Ключ, Кол.Значение);
                                        Исключение
                                        КонецПопытки;
                                КонецЦикла;
                        КонецЕсли;
                КонецЦикла;
                
        // Режим append — только добавляем
        ИначеЕсли Режим = "append" Тогда
                Для Каждого СтрокаДанных Из Строки Цикл
                        НоваяСтрока = Объект[ИмяТЧ].Добавить();
                        Если ТипЗнч(СтрокаДанных) = Тип("Соответствие") Тогда
                                Для Каждого Кол Из СтрокаДанных Цикл
                                        Попытка
                                                УстановитьЗначениеРеквизита(НоваяСтрока, Кол.Ключ, Кол.Значение);
                                        Исключение
                                        КонецПопытки;
                                КонецЦикла;
                        КонецЕсли;
                КонецЦикла;
                
        // Режим update_by_index — обновляем конкретные строки по НомерСтроки
        ИначеЕсли Режим = "update_by_index" Тогда
                Для Каждого СтрокаДанных Из Строки Цикл
                        Если ТипЗнч(СтрокаДанных) <> Тип("Соответствие") Тогда Продолжить; КонецЕсли;
                        НомерСтроки = СтрокаДанных["НомерСтроки"];
                        Если НомерСтроки = Неопределено Тогда НомерСтроки = СтрокаДанных["row_index"]; КонецЕсли;
                        Если НомерСтроки = Неопределено Тогда Продолжить; КонецЕсли;
                        
                        Если НомерСтроки < 1 Или НомерСтроки > Объект[ИмяТЧ].Количество() Тогда Продолжить; КонецЕсли;
                        
                        ТекСтрока = Объект[ИмяТЧ][НомерСтроки - 1];
                        Для Каждого Кол Из СтрокаДанных Цикл
                                Если Кол.Ключ = "НомерСтроки" Или Кол.Ключ = "row_index" Тогда Продолжить; КонецЕсли;
                                Попытка
                                        УстановитьЗначениеРеквизита(ТекСтрока, Кол.Ключ, Кол.Значение);
                                Исключение
                                КонецПопытки;
                        КонецЦикла;
                КонецЦикла;
        Иначе
                Возврат "Неизвестный режим: " + Режим + ". Допустимые: replace, append, update_by_index";
        КонецЕсли;
        
        Объект.Записать();
        
        Результат = Новый Соответствие;
        Результат.Вставить("success", Истина);
        Результат.Вставить("guid", СтрокаGUID);
        Результат.Вставить("tabular_section", ИмяТЧ);
        Результат.Вставить("mode", Режим);
        Результат.Вставить("rows_count", Объект[ИмяТЧ].Количество());
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции


// G4: Получение событий из журнала регистрации (polling-based CDC)
// Возвращает события с watermark для следующего запроса
//
Функция Инструмент_SubscribeEvents(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        ТипыСобытий = Аргументы["event_types"];
        МеткаС = Аргументы["since"];
        МаксСобытий = Аргументы["max_events"];
        
        Если МаксСобытий = Неопределено Или МаксСобытий = 0 Тогда МаксСобытий = 100; КонецЕсли;
        Если МаксСобытий > 1000 Тогда МаксСобытий = 1000; КонецЕсли;
        
        // Определяем начальную дату
        ДатаНачала = Неопределено;
        Если МеткаС <> Неопределено И Не ПустаяСтрока(МеткаС) Тогда
                ДатаНачала = ПреобразоватьДату(МеткаС);
        КонецЕсли;
        
        Если ДатаНачала = Неопределено Тогда
                ДатаНачала = ТекущаяДатаСеанса() - 300; // 5 минут назад
        КонецЕсли;
        
        ДатаОкончания = ТекущаяДатаСеанса();
        
        // Фильтр по типам событий
        ОтборСобытий = Новый Массив;
        Если ТипыСобытий <> Неопределено И Не ПустаяСтрока(ТипыСобытий) Тогда
                Части = СтрРазделить(ТипыСобытий, ",");
                Для Каждого Ч Из Части Цикл
                        ОтборСобытий.Добавить(СокрЛП(Ч));
                КонецЦикла;
        КонецЕсли;
        
        // Фильтр журнала регистрации
        Отбор = Новый Структура;
        Отбор.Вставить("ДатаНачала", ДатаНачала);
        Отбор.Вставить("ДатаОкончания", ДатаОкончания);
        
        Если ОтборСобытий.Количество() > 0 Тогда
                Отбор.Вставить("Событие", ОтборСобытий);
        КонецЕсли;
        
        // Читаем журнал регистрации
        СобытияЖР = Новый ТаблицаЗначений;
        ВыгрузитьЖурналРегистрации(СобытияЖР, Отбор, , , МаксСобытий);
        
        // Фильтруем по типу объекта (если указан)
        СобытияМассив = Новый Массив;
        МаксДата = ДатаНачала;
        
        Для Каждого СтрокаЖР Из СобытияЖР Цикл
                
                // Фильтр по полному имени
                Если ПолноеИмя <> Неопределено И Не ПустаяСтрока(ПолноеИмя) Тогда
                        Попытка
                                МДОбъекта = СтрокаЖР.МетаданныеПредставление;
                                Если СтрНайти(МДОбъекта, ПолноеИмя) = 0 Тогда Продолжить; КонецЕсли;
                        Исключение
                                Продолжить;
                        КонецПопытки;
                КонецЕсли;
                
                Событие = Новый Соответствие;
                Событие.Вставить("timestamp", Формат(СтрокаЖР.Дата, "ДФ=yyyy-MM-ddTHH:mm:ss"));
                Событие.Вставить("event", Строка(СтрокаЖР.Событие));
                Событие.Вставить("metadata", СтрокаЖР.МетаданныеПредставление);
                Событие.Вставить("user", СтрокаЖР.ИмяПользователя);
                Событие.Вставить("comment", СтрокаЖР.Комментарий);
                
                Попытка
                        Событие.Вставить("data_presentation", СтрокаЖР.ДанныеПредставление);
                Исключение
                КонецПопытки;
                
                СобытияМассив.Добавить(Событие);
                
                Если СтрокаЖР.Дата > МаксДата Тогда
                        МаксДата = СтрокаЖР.Дата;
                КонецЕсли;
                
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("events", СобытияМассив);
        Результат.Вставить("count", СобытияМассив.Количество());
        Результат.Вставить("watermark", Формат(МаксДата + 1, "ДФ=yyyy-MM-ddTHH:mm:ss"));
        Результат.Вставить("period_from", Формат(ДатаНачала, "ДФ=yyyy-MM-ddTHH:mm:ss"));
        Результат.Вставить("period_to", Формат(ДатаОкончания, "ДФ=yyyy-MM-ddTHH:mm:ss"));
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции


// G5: Пакетное выполнение нескольких операций за один HTTP-вызов
// Поддерживает режимы: последовательный, stop-on-error, транзакционный
//
Функция Инструмент_ExecuteBatch(Аргументы)
        
        Операции = Аргументы["operations"];

	// v2.1: Защита от рекурсии и зависания
	Если ТипЗнч(Операции) = Тип("Массив") Тогда
		Для Каждого ОпПроверка Из Операции Цикл
			Если ОпПроверка["tool"] = "execute_batch" Тогда
				Возврат "Рекурсивный вызов execute_batch запрещён";
			КонецЕсли;
		 КонецЦикла;
	КонецЕсли;

        ОстановкаПоОшибке = Аргументы["stop_on_error"];
        Транзакционный = Аргументы["transactional"];
        
        Если ОстановкаПоОшибке = Неопределено Тогда ОстановкаПоОшибке = Истина; КонецЕсли;
        Если Транзакционный = Неопределено Тогда Транзакционный = Ложь; КонецЕсли;
        
        Если ТипЗнч(Операции) <> Тип("Массив") Тогда
                Возврат "Параметр operations должен быть массивом";
        КонецЕсли;
        
        Если Операции.Количество() = 0 Тогда
                Возврат "Пустой массив операций";
        КонецЕсли;
        
        Если Операции.Количество() > 50 Тогда
                Возврат "Максимальное кол-во операций в пакете: 50";
        КонецЕсли;
        
        Результаты = Новый Массив;
        Успешно = 0;
        Ошибок = 0;
        БылаОшибка = Ложь;
        
        Если Транзакционный Тогда
                НачатьТранзакцию();
        КонецЕсли;
        
        Попытка
                
                Для Каждого Операция Из Операции Цикл
                        
                        ИмяИнструмента = Операция["tool"];
                        АргументыОп = Операция["arguments"];
                        Если АргументыОп = Неопределено Тогда АргументыОп = Новый Соответствие; КонецЕсли;
                        
                        РезОперации = Новый Соответствие;
                        РезОперации.Вставить("tool", ИмяИнструмента);
                        
                        Если БылаОшибка И ОстановкаПоОшибке Тогда
                                РезОперации.Вставить("skipped", Истина);
                                Результаты.Добавить(РезОперации);
                                Продолжить;
                        КонецЕсли;
                        
                        Попытка
                                ТекстРезультата = ВыполнитьИнструментПоИмени(ИмяИнструмента, АргументыОп);
                                РезОперации.Вставить("success", Истина);
                                РезОперации.Вставить("result", ТекстРезультата);
                                Успешно = Успешно + 1;
                        Исключение
                                РезОперации.Вставить("success", Ложь);
                                РезОперации.Вставить("error", ОписаниеОшибки());
                                Ошибок = Ошибок + 1;
                                БылаОшибка = Истина;
                        КонецПопытки;
                        
                        Результаты.Добавить(РезОперации);
                        
                КонецЦикла;
                
                Если Транзакционный Тогда
                        Если БылаОшибка Тогда
                                ОтменитьТранзакцию();
                        Иначе
                                ЗафиксироватьТранзакцию();
                        КонецЕсли;
                КонецЕсли;
                
        Исключение
                Если Транзакционный И ТранзакцияАктивна() Тогда
                        ОтменитьТранзакцию();
                КонецЕсли;
                
                Возврат "Критическая ошибка batch: " + ОписаниеОшибки();
        КонецПопытки;
        
        Итог = Новый Соответствие;
        Итог.Вставить("total", Операции.Количество());
        Итог.Вставить("succeeded", Успешно);
        Итог.Вставить("failed", Ошибок);
        Итог.Вставить("transactional", Транзакционный);
        Итог.Вставить("results", Результаты);
        
        Возврат ОбъектВJSONКомпакт(Итог);
        
КонецФункции


// G6: Получение изменённых объектов с момента watermark (Change Data Capture)
// Использует журнал регистрации для определения изменений
//
Функция Инструмент_GetChangesSince(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        МеткаС = Аргументы["since"];
        ВключитьДанные = Аргументы["include_data"];
        МаксРезультатов = Аргументы["max_results"];
        
        Если ВключитьДанные = Неопределено Тогда ВключитьДанные = Ложь; КонецЕсли;
        Если МаксРезультатов = Неопределено Или МаксРезультатов = 0 Тогда МаксРезультатов = 500; КонецЕсли;
        Если МаксРезультатов > 5000 Тогда МаксРезультатов = 5000; КонецЕсли;
        
        ДатаС = ПреобразоватьДату(МеткаС);
        Если ДатаС = Неопределено Тогда
                Возврат "Некорректная дата since: " + МеткаС;
        КонецЕсли;
        
        // Определяем тип объекта
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если Части = Неопределено Тогда
                Возврат "Некорректное полное имя: " + ПолноеИмя;
        КонецЕсли;
        
        // Читаем журнал регистрации
        Отбор = Новый Структура;
        Отбор.Вставить("ДатаНачала", ДатаС);
        Отбор.Вставить("ДатаОкончания", ТекущаяДатаСеанса());
        
        // Фильтр по типам событий (запись, проведение, удаление)
        ТипыСобытий = Новый Массив;
        ТипыСобытий.Добавить("_ОбъектЗапись");
        ТипыСобытий.Добавить("_ОбъектПроведение");
        ТипыСобытий.Добавить("_ОбъектУдаление");
        ТипыСобытий.Добавить("_ОбъектОтменаПроведения");
        Отбор.Вставить("Событие", ТипыСобытий);
        
        ТЗ = Новый ТаблицаЗначений;
        ВыгрузитьЖурналРегистрации(ТЗ, Отбор, , , МаксРезультатов * 2); // берём с запасом для фильтрации
        
        // Фильтруем по типу объекта и группируем по GUID
        Изменения = Новый Соответствие; // GUID → последнее изменение
        МаксДата = ДатаС;
        
        Для Каждого СтрокаЖР Из ТЗ Цикл
                Попытка
                        МДПредставление = СтрокаЖР.МетаданныеПредставление;
                        Если СтрНайти(МДПредставление, ПолноеИмя) = 0 Тогда Продолжить; КонецЕсли;
                Исключение
                        Продолжить;
                КонецПопытки;
                
                // Извлекаем GUID из данных
                GUIDОбъекта = "";
                Попытка
                        Данные = СтрокаЖР.Данные;
                        Если ТипЗнч(Данные) <> Тип("Строка") Тогда
                                Попытка
                                        GUIDОбъекта = Строка(Данные.УникальныйИдентификатор());
                                Исключение
                                        GUIDОбъекта = Строка(Данные);
                                КонецПопытки;
                        Иначе
                                GUIDОбъекта = Данные;
                        КонецЕсли;
                Исключение
                        GUIDОбъекта = СтрокаЖР.ДанныеПредставление;
                КонецПопытки;
                
                Если ПустаяСтрока(GUIDОбъекта) Тогда Продолжить; КонецЕсли;
                
                // Определяем тип изменения
                ТипИзменения = "updated";
                Событие = Строка(СтрокаЖР.Событие);
                Если СтрНайти(Событие, "Удаление") > 0 Тогда
                        ТипИзменения = "deleted";
                ИначеЕсли СтрНайти(Событие, "Проведение") > 0 Тогда
                        ТипИзменения = "posted";
                ИначеЕсли СтрНайти(Событие, "ОтменаПроведения") > 0 Тогда
                        ТипИзменения = "unposted";
                КонецЕсли;
                
                Запись = Новый Соответствие;
                Запись.Вставить("guid", GUIDОбъекта);
                Запись.Вставить("change_type", ТипИзменения);
                Запись.Вставить("timestamp", Формат(СтрокаЖР.Дата, "ДФ=yyyy-MM-ddTHH:mm:ss"));
                Запись.Вставить("user", СтрокаЖР.ИмяПользователя);
                
                Изменения.Вставить(GUIDОбъекта, Запись); // последнее изменение по каждому GUID
                
                Если СтрокаЖР.Дата > МаксДата Тогда
                        МаксДата = СтрокаЖР.Дата;
                КонецЕсли;
        КонецЦикла;
        
        // Собираем массив изменений
        МассивИзменений = Новый Массив;
        Для Каждого КЗ Из Изменения Цикл
                
                Если МассивИзменений.Количество() >= МаксРезультатов Тогда Прервать; КонецЕсли;
                
                Запись = КЗ.Значение;
                
                // Включаем полные данные объекта если запрошено
                Если ВключитьДанные И Запись["change_type"] <> "deleted" Тогда
                        Попытка
                                Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
                                УИД = Новый УникальныйИдентификатор(КЗ.Ключ);
                                СсылкаОбъекта = Менеджер.ПолучитьСсылку(УИД);
                                ОбъектДанных = СсылкаОбъекта.ПолучитьОбъект();
                                Если ОбъектДанных <> Неопределено Тогда
                                        Запись.Вставить("data", СериализоватьОбъект(ОбъектДанных, ПолноеИмя));
                                КонецЕсли;
                        Исключение
                        КонецПопытки;
                КонецЕсли;
                
                МассивИзменений.Добавить(Запись);
                
        КонецЦикла;
        
        Результат = Новый Соответствие;
        Результат.Вставить("full_name", ПолноеИмя);
        Результат.Вставить("changes", МассивИзменений);
        Результат.Вставить("count", МассивИзменений.Количество());
        Результат.Вставить("watermark", Формат(МаксДата + 1, "ДФ=yyyy-MM-ddTHH:mm:ss"));
        Результат.Вставить("since", МеткаС);
        
        Возврат ОбъектВJSONКомпакт(Результат);
        
КонецФункции

#КонецОбласти


// ============================================================================


#Область ГруппаЗ_НовыеИнструменты_v21

// =========================================================================
// Группа З: Новые инструменты v2.1 (10 инструментов, #42–#51)
// =========================================================================

// #42 — get_balance: Остатки/обороты регистров бухгалтерии
Функция Инструмент_GetBalance(Аргументы)
        
        ИмяРегистра = Аргументы["register_name"];
        Если ИмяРегистра = Неопределено ИЛИ ИмяРегистра = "" Тогда
                ИмяРегистра = "Хозрасчетный";
        КонецЕсли;
        
        КодСчёта = Аргументы["account_code"];
        Если КодСчёта = Неопределено ИЛИ КодСчёта = "" Тогда
                ВызватьИсключение "Параметр account_code обязателен";
        КонецЕсли;
        
        ТипОстатков = Аргументы["balance_type"];
        Если ТипОстатков = Неопределено ИЛИ ТипОстатков = "" Тогда
                ТипОстатков = "balance";
        КонецЕсли;
        
        // Находим регистр бухгалтерии
        МДРегистр = Метаданные.РегистрыБухгалтерии.Найти(ИмяРегистра);
        Если МДРегистр = Неопределено Тогда
                ВызватьИсключение "Регистр бухгалтерии не найден: " + ИмяРегистра;
        КонецЕсли;
        
        Менеджер = РегистрыБухгалтерии[ИмяРегистра];
        
        // Определяем виртуальную таблицу
        Если ТипОстатков = "turnovers" Тогда
                ИмяВТ = "Обороты";
        ИначеЕсли ТипОстатков = "balance_and_turnovers" Тогда
                ИмяВТ = "ОстаткиИОбороты";
        Иначе
                ИмяВТ = "Остатки";
        КонецЕсли;
        
        // Строим текст запроса
        ТекстЗапроса = "ВЫБРАТЬ * ИЗ РегистрБухгалтерии." + ИмяРегистра + "." + ИмяВТ + "(";
        
        // Параметры виртуальной таблицы
        ПараметрыВТ = Новый Массив;
        
        // Период
        ПериодС = Аргументы["period_from"];
        ПериодПо = Аргументы["period_to"];
        Если ПериодС <> Неопределено И ПериодС <> "" Тогда
                ПараметрыВТ.Добавить("&ПериодС");
        Иначе
                ПараметрыВТ.Добавить("");
        КонецЕсли;
        Если ПериодПо <> Неопределено И ПериодПо <> "" Тогда
                ПараметрыВТ.Добавить("&ПериодПо");
        Иначе
                ПараметрыВТ.Добавить("");
        КонецЕсли;
        
        // Условие по счёту
        ПараметрыВТ.Добавить("Счёт = &Счёт");
        
        // Субконто — пока пустой
        ПараметрыВТ.Добавить("");
        
        ТекстЗапроса = ТекстЗапроса + СтрСоединить(ПараметрыВТ, ", ") + ")";
        
        // Дополнительные условия по измерениям
        ФильтрИзмерений = Аргументы["dimensions"];
        Если ФильтрИзмерений <> Неопределено И ТипЗнч(ФильтрИзмерений) = Тип("Соответствие") Тогда
                Условия = Новый Массив;
                Для Каждого КЗ Из ФильтрИзмерений Цикл
                        Условия.Добавить(КЗ.Ключ + " = &Изм_" + КЗ.Ключ);
                КонецЦикла;
                Если Условия.Количество() > 0 Тогда
                        ТекстЗапроса = ТекстЗапроса + " ГДЕ " + СтрСоединить(Условия, " И ");
                КонецЕсли;
        КонецЕсли;
        
        Запрос = Новый Запрос(ТекстЗапроса);
        
        // Параметры
        ПланСчетов = Метаданные.РегистрыБухгалтерии[ИмяРегистра].ПланСчетов;
        ИмяПланаСчетов = ПланСчетов.Имя;
        Счёт = ПланыСчетов[ИмяПланаСчетов].НайтиПоКоду(КодСчёта);
        Если Счёт.Пустая() Тогда
                ВызватьИсключение "Счёт не найден по коду: " + КодСчёта;
        КонецЕсли;
        Запрос.УстановитьПараметр("Счёт", Счёт);
        
        Если ПериодС <> Неопределено И ПериодС <> "" Тогда
                Запрос.УстановитьПараметр("ПериодС", ПреобразоватьДату(ПериодС));
        КонецЕсли;
        Если ПериодПо <> Неопределено И ПериодПо <> "" Тогда
                Запрос.УстановитьПараметр("ПериодПо", ПреобразоватьДату(ПериодПо));
        КонецЕсли;
        
        Если ФильтрИзмерений <> Неопределено И ТипЗнч(ФильтрИзмерений) = Тип("Соответствие") Тогда
                Для Каждого КЗ Из ФильтрИзмерений Цикл
                        Запрос.УстановитьПараметр("Изм_" + КЗ.Ключ, КЗ.Значение);
                КонецЦикла;
        КонецЕсли;
        
        Результат = Запрос.Выполнить();
        Если Результат.Пустой() Тогда
                СообщениеПусто = Новый Соответствие;
                СообщениеПусто.Вставить("message", "Нет данных по заданным параметрам");
                Возврат ОбъектВJSON(СообщениеПусто);
        КонецЕсли;
        
        Строки = Новый Массив;
        Выборка = Результат.Выбрать();
        Пока Выборка.Следующий() Цикл
                Стр = Новый Соответствие;
                Для Каждого Колонка Из Результат.Колонки Цикл
                        Стр.Вставить(Колонка.Имя, ЗначениеДляJSON(Выборка[Колонка.Имя]));
                КонецЦикла;
                Строки.Добавить(Стр);
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("register", ИмяРегистра);
        Ответ.Вставить("account", КодСчёта);
        Ответ.Вставить("balance_type", ТипОстатков);
        Ответ.Вставить("rows", Строки);
        Ответ.Вставить("count", Строки.Количество());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #43 — get_register_totals: Остатки/обороты регистров накопления
Функция Инструмент_GetRegisterTotals(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Если ПолноеИмя = Неопределено ИЛИ ПолноеИмя = "" Тогда
                ВызватьИсключение "Параметр full_name обязателен";
        КонецЕсли;
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        Если НРег(Части.Тип) <> "регистрнакопления" Тогда
                ВызватьИсключение "Ожидается РегистрНакопления, получен: " + Части.Тип;
        КонецЕсли;
        
        МДРегистр = Метаданные.РегистрыНакопления.Найти(Части.Имя);
        Если МДРегистр = Неопределено Тогда
                ВызватьИсключение "Регистр накопления не найден: " + Части.Имя;
        КонецЕсли;
        
        ТипОстатков = Аргументы["balance_type"];
        Если ТипОстатков = Неопределено ИЛИ ТипОстатков = "" Тогда
                ТипОстатков = "balance";
        КонецЕсли;
        
        // Виртуальная таблица
        Если ТипОстатков = "turnovers" Тогда
                ИмяВТ = "Обороты";
        ИначеЕсли ТипОстатков = "balance_and_turnovers" Тогда
                ИмяВТ = "ОстаткиИОбороты";
        Иначе
                Если МДРегистр.ВидРегистра = Метаданные.СвойстваОбъектов.ВидРегистраНакопления.Обороты Тогда
                        ИмяВТ = "Обороты";
                        ТипОстатков = "turnovers";
                Иначе
                        ИмяВТ = "Остатки";
                КонецЕсли;
        КонецЕсли;
        
        // Ресурсы
        Ресурсы = Аргументы["resources"];
        Если Ресурсы <> Неопределено И Ресурсы <> "" Тогда
                СписокПолей = Ресурсы;
        Иначе
                СписокПолей = "*";
        КонецЕсли;
        
        ТекстЗапроса = "ВЫБРАТЬ " + СписокПолей + " ИЗ РегистрНакопления." + Части.Имя + "." + ИмяВТ + "(";
        
        ПараметрыВТ = Новый Массив;
        ПериодС = Аргументы["period_from"];
        ПериодПо = Аргументы["period_to"];
        Если ПериодС <> Неопределено И ПериодС <> "" Тогда
                ПараметрыВТ.Добавить("&ПериодС");
        Иначе
                ПараметрыВТ.Добавить("");
        КонецЕсли;
        Если ПериодПо <> Неопределено И ПериодПо <> "" Тогда
                ПараметрыВТ.Добавить("&ПериодПо");
        Иначе
                ПараметрыВТ.Добавить("");
        КонецЕсли;
        
        // Условие по измерениям
        ФильтрИзмерений = Аргументы["dimensions"];
        Если ФильтрИзмерений <> Неопределено И ТипЗнч(ФильтрИзмерений) = Тип("Соответствие") Тогда
                Условия = Новый Массив;
                Для Каждого КЗ Из ФильтрИзмерений Цикл
                        Условия.Добавить(КЗ.Ключ + " = &Изм_" + КЗ.Ключ);
                КонецЦикла;
                ПараметрыВТ.Добавить(СтрСоединить(Условия, " И "));
        Иначе
                ПараметрыВТ.Добавить("");
        КонецЕсли;
        
        ТекстЗапроса = ТекстЗапроса + СтрСоединить(ПараметрыВТ, ", ") + ")";
        
        Запрос = Новый Запрос(ТекстЗапроса);
        Если ПериодС <> Неопределено И ПериодС <> "" Тогда
                Запрос.УстановитьПараметр("ПериодС", ПреобразоватьДату(ПериодС));
        КонецЕсли;
        Если ПериодПо <> Неопределено И ПериодПо <> "" Тогда
                Запрос.УстановитьПараметр("ПериодПо", ПреобразоватьДату(ПериодПо));
        КонецЕсли;
        Если ФильтрИзмерений <> Неопределено И ТипЗнч(ФильтрИзмерений) = Тип("Соответствие") Тогда
                Для Каждого КЗ Из ФильтрИзмерений Цикл
                        Запрос.УстановитьПараметр("Изм_" + КЗ.Ключ, КЗ.Значение);
                КонецЦикла;
        КонецЕсли;
        
        Результат = Запрос.Выполнить();
        Если Результат.Пустой() Тогда
                СообщениеПусто = Новый Соответствие;
                СообщениеПусто.Вставить("message", "Нет данных");
                Возврат ОбъектВJSON(СообщениеПусто);
        КонецЕсли;
        
        Строки = Новый Массив;
        Выборка = Результат.Выбрать();
        Пока Выборка.Следующий() Цикл
                Стр = Новый Соответствие;
                Для Каждого Колонка Из Результат.Колонки Цикл
                        Стр.Вставить(Колонка.Имя, ЗначениеДляJSON(Выборка[Колонка.Имя]));
                КонецЦикла;
                Строки.Добавить(Стр);
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("register", ПолноеИмя);
        Ответ.Вставить("balance_type", ТипОстатков);
        Ответ.Вставить("rows", Строки);
        Ответ.Вставить("count", Строки.Количество());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #44 — get_accounting_entries: Проводки документа
Функция Инструмент_GetAccountingEntries(Аргументы)
        
        СтрСсылка = Аргументы["document_ref"];
        Если СтрСсылка = Неопределено ИЛИ СтрСсылка = "" Тогда
                ВызватьИсключение "Параметр document_ref обязателен";
        КонецЕсли;
        
        ИмяРегистра = Аргументы["register_name"];
        Если ИмяРегистра = Неопределено ИЛИ ИмяРегистра = "" Тогда
                ИмяРегистра = "Хозрасчетный";
        КонецЕсли;
        
        МДРегистр = Метаданные.РегистрыБухгалтерии.Найти(ИмяРегистра);
        Если МДРегистр = Неопределено Тогда
                ВызватьИсключение "Регистр бухгалтерии не найден: " + ИмяРегистра;
        КонецЕсли;
        
        // Ищем ссылку как GUID
        Ссылка = XMLЗначение(Тип("УникальныйИдентификатор"), СтрСсылка);
        
        // Поиск документа по GUID через все типы документов
        НайденнаяСсылка = Неопределено;
        Для Каждого МДДок Из Метаданные.Документы Цикл
                Попытка
                        НайденнаяСсылка = Документы[МДДок.Имя].ПолучитьСсылку(Ссылка);
                        Если НайденнаяСсылка.ПолучитьОбъект() <> Неопределено Тогда
                                Прервать;
                        КонецЕсли;
                        НайденнаяСсылка = Неопределено;
                Исключение
                        НайденнаяСсылка = Неопределено;
                КонецПопытки;
        КонецЦикла;
        
        Если НайденнаяСсылка = Неопределено Тогда
                ВызватьИсключение "Документ не найден по GUID: " + СтрСсылка;
        КонецЕсли;
        
        // Запрос проводок
        ТекстЗапроса = "ВЫБРАТЬ
        |        СчётДт.Код КАК СчётДт,
        |        СчётКт.Код КАК СчётКт,
        |        Сумма,
        |        Количество,
        |        Содержание,
        |        Период
        |ИЗ РегистрБухгалтерии." + ИмяРегистра + "
        |ГДЕ Регистратор = &Регистратор
        |УПОРЯДОЧИТЬ ПО НомерСтроки";
        
        Запрос = Новый Запрос(ТекстЗапроса);
        Запрос.УстановитьПараметр("Регистратор", НайденнаяСсылка);
        
        Результат = Запрос.Выполнить();
        
        Строки = Новый Массив;
        Выборка = Результат.Выбрать();
        Пока Выборка.Следующий() Цикл
                Стр = Новый Соответствие;
                Стр.Вставить("debit_account", Выборка.СчётДт);
                Стр.Вставить("credit_account", Выборка.СчётКт);
                Стр.Вставить("amount", Выборка.Сумма);
                Стр.Вставить("quantity", Выборка.Количество);
                Стр.Вставить("description", Выборка.Содержание);
                Стр.Вставить("period", ЗначениеДляJSON(Выборка.Период));
                Строки.Добавить(Стр);
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("document", СтрСсылка);
        Ответ.Вставить("register", ИмяРегистра);
        Ответ.Вставить("entries", Строки);
        Ответ.Вставить("count", Строки.Количество());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #45 — get_related_documents: Связанные документы
Функция Инструмент_GetRelatedDocuments(Аргументы)
        
        СтрСсылка = Аргументы["document_ref"];
        Если СтрСсылка = Неопределено ИЛИ СтрСсылка = "" Тогда
                ВызватьИсключение "Параметр document_ref обязателен";
        КонецЕсли;
        
        Направление = Аргументы["direction"];
        Если Направление = Неопределено ИЛИ Направление = "" Тогда
                Направление = "both";
        КонецЕсли;
        
        МаксГлубина = Аргументы["max_depth"];
        Если МаксГлубина = Неопределено Тогда
                МаксГлубина = 1;
        КонецЕсли;
        Если МаксГлубина > 5 Тогда
                МаксГлубина = 5;
        КонецЕсли;
        
        // Ищем документ по GUID
        Ссылка = XMLЗначение(Тип("УникальныйИдентификатор"), СтрСсылка);
        НайденнаяСсылка = Неопределено;
        ТипДокумента = "";
        Для Каждого МДДок Из Метаданные.Документы Цикл
                Попытка
                        Кандидат = Документы[МДДок.Имя].ПолучитьСсылку(Ссылка);
                        Если Кандидат.ПолучитьОбъект() <> Неопределено Тогда
                                НайденнаяСсылка = Кандидат;
                                ТипДокумента = МДДок.ПолноеИмя();
                                Прервать;
                        КонецЕсли;
                Исключение
                КонецПопытки;
        КонецЦикла;
        
        Если НайденнаяСсылка = Неопределено Тогда
                ВызватьИсключение "Документ не найден по GUID: " + СтрСсылка;
        КонецЕсли;
        
        Связанные = Новый Массив;
        
        // Прямые связи: документы-основания (backward)
        Если Направление = "backward" ИЛИ Направление = "both" Тогда
                Попытка
                        Объект = НайденнаяСсылка.ПолучитьОбъект();
                        Для Каждого Реквизит Из Объект.Метаданные().Реквизиты Цикл
                                Значение = Объект[Реквизит.Имя];
                                Если ТипЗнч(Значение) <> Неопределено Тогда
                                        ОписаниеТипов = Реквизит.Тип;
                                        Для Каждого МДДок Из Метаданные.Документы Цикл
                                                Если ОписаниеТипов.СодержитТип(Тип("ДокументСсылка." + МДДок.Имя)) Тогда
                                                        Если ТипЗнч(Значение) = Тип("ДокументСсылка." + МДДок.Имя) И ЗначениеЗаполнено(Значение) Тогда
                                                                Элемент = Новый Соответствие;
                                                                Элемент.Вставить("ref", XMLСтрока(Значение.УникальныйИдентификатор()));
                                                                Элемент.Вставить("type", МДДок.ПолноеИмя());
                                                                Элемент.Вставить("presentation", Строка(Значение));
                                                                Элемент.Вставить("direction", "backward");
                                                                Элемент.Вставить("link_attribute", Реквизит.Имя);
                                                                Элемент.Вставить("depth", 1);
                                                                Связанные.Добавить(Элемент);
                                                        КонецЕсли;
                                                КонецЕсли;
                                        КонецЦикла;
                                КонецЕсли;
                        КонецЦикла;
                Исключение
                КонецПопытки;
        КонецЕсли;
        
        // Прямые связи: документы, введённые на основании (forward)
        Если Направление = "forward" ИЛИ Направление = "both" Тогда
                // Используем запрос: ищем документы, у которых реквизиты ссылаются на наш
                Для Каждого МДДок Из Метаданные.Документы Цикл
                        Для Каждого Реквизит Из МДДок.Реквизиты Цикл
                                Если Реквизит.Тип.СодержитТип(ТипЗнч(НайденнаяСсылка)) Тогда
                                        Попытка
                                                ТЗапроса = "ВЫБРАТЬ ПЕРВЫЕ 50 Ссылка ИЗ Документ." + МДДок.Имя 
                                                        + " ГДЕ " + Реквизит.Имя + " = &Основание";
                                                ЗапросСвязей = Новый Запрос(ТЗапроса);
                                                ЗапросСвязей.УстановитьПараметр("Основание", НайденнаяСсылка);
                                                РезультатСвязей = ЗапросСвязей.Выполнить();
                                                ВыборкаСвязей = РезультатСвязей.Выбрать();
                                                Пока ВыборкаСвязей.Следующий() Цикл
                                                        Элемент = Новый Соответствие;
                                                        Элемент.Вставить("ref", XMLСтрока(ВыборкаСвязей.Ссылка.УникальныйИдентификатор()));
                                                        Элемент.Вставить("type", МДДок.ПолноеИмя());
                                                        Элемент.Вставить("presentation", Строка(ВыборкаСвязей.Ссылка));
                                                        Элемент.Вставить("direction", "forward");
                                                        Элемент.Вставить("link_attribute", Реквизит.Имя);
                                                        Элемент.Вставить("depth", 1);
                                                        Связанные.Добавить(Элемент);
                                                КонецЦикла;
                                        Исключение
                                        КонецПопытки;
                                КонецЕсли;
                        КонецЦикла;
                КонецЦикла;
        КонецЕсли;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("document", СтрСсылка);
        Ответ.Вставить("document_type", ТипДокумента);
        Ответ.Вставить("direction", Направление);
        Ответ.Вставить("related", Связанные);
        Ответ.Вставить("count", Связанные.Количество());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #46 — validate_document: Проверка заполнения документа
Функция Инструмент_ValidateDocument(Аргументы)
        
        СтрСсылка = Аргументы["document_ref"];
        Если СтрСсылка = Неопределено ИЛИ СтрСсылка = "" Тогда
                ВызватьИсключение "Параметр document_ref обязателен";
        КонецЕсли;
        
        // Ищем документ по GUID
        Ссылка = XMLЗначение(Тип("УникальныйИдентификатор"), СтрСсылка);
        НайденнаяСсылка = Неопределено;
        ТипДокумента = "";
        Для Каждого МДДок Из Метаданные.Документы Цикл
                Попытка
                        Кандидат = Документы[МДДок.Имя].ПолучитьСсылку(Ссылка);
                        Если Кандидат.ПолучитьОбъект() <> Неопределено Тогда
                                НайденнаяСсылка = Кандидат;
                                ТипДокумента = МДДок.ПолноеИмя();
                                Прервать;
                        КонецЕсли;
                Исключение
                КонецПопытки;
        КонецЦикла;
        
        Если НайденнаяСсылка = Неопределено Тогда
                ВызватьИсключение "Документ не найден по GUID: " + СтрСсылка;
        КонецЕсли;
        
        Объект = НайденнаяСсылка.ПолучитьОбъект();
        
        // Проверка заполнения
        Отказ = Ложь;
        Ошибки = Новый Массив;
        
        // Проверяем обязательные реквизиты
        Для Каждого Реквизит Из Объект.Метаданные().Реквизиты Цикл
                Если Реквизит.ПроверкаЗаполнения = ПроверкаЗаполнения.ВыдаватьОшибку Тогда
                        Если НЕ ЗначениеЗаполнено(Объект[Реквизит.Имя]) Тогда
                                Отказ = Истина;
                                Элемент = Новый Соответствие;
                                Элемент.Вставить("field", Реквизит.Имя);
                                Элемент.Вставить("presentation", Реквизит.Представление());
                                Элемент.Вставить("error", "Поле не заполнено");
                                Ошибки.Добавить(Элемент);
                        КонецЕсли;
                КонецЕсли;
        КонецЦикла;
        
        // Проверяем обязательные реквизиты табличных частей
        Для Каждого МДТабЧасть Из Объект.Метаданные().ТабличныеЧасти Цикл
                ТабЧасть = Объект[МДТабЧасть.Имя];
                НомерСтроки = 0;
                Для Каждого Строка Из ТабЧасть Цикл
                        НомерСтроки = НомерСтроки + 1;
                        Для Каждого Реквизит Из МДТабЧасть.Реквизиты Цикл
                                Если Реквизит.ПроверкаЗаполнения = ПроверкаЗаполнения.ВыдаватьОшибку Тогда
                                        Если НЕ ЗначениеЗаполнено(Строка[Реквизит.Имя]) Тогда
                                                Отказ = Истина;
                                                Элемент = Новый Соответствие;
                                                Элемент.Вставить("field", МДТабЧасть.Имя + "[" + НомерСтроки + "]." + Реквизит.Имя);
                                                Элемент.Вставить("presentation", Реквизит.Представление());
                                                Элемент.Вставить("error", "Поле не заполнено в строке " + НомерСтроки);
                                                Ошибки.Добавить(Элемент);
                                        КонецЕсли;
                                КонецЕсли;
                        КонецЦикла;
                КонецЦикла;
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("document", СтрСсылка);
        Ответ.Вставить("document_type", ТипДокумента);
        Ответ.Вставить("is_valid", НЕ Отказ);
        Ответ.Вставить("errors", Ошибки);
        Ответ.Вставить("error_count", Ошибки.Количество());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #47 — get_form_structure: Структура управляемой формы
Функция Инструмент_GetFormStructure(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Если ПолноеИмя = Неопределено ИЛИ ПолноеИмя = "" Тогда
                ВызватьИсключение "Параметр full_name обязателен";
        КонецЕсли;
        
        ИмяФормы = Аргументы["form_name"];
        
        // Находим объект метаданных
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                ВызватьИсключение "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        // Находим форму
        Если ИмяФормы <> Неопределено И ИмяФормы <> "" Тогда
                МДФорма = МДОбъект.Формы.Найти(ИмяФормы);
                Если МДФорма = Неопределено Тогда
                        ВызватьИсключение "Форма не найдена: " + ИмяФормы;
                КонецЕсли;
        Иначе
                // Берём первую форму (основную)
                Если МДОбъект.Формы.Количество() = 0 Тогда
                        ВызватьИсключение "У объекта нет форм";
                КонецЕсли;
                МДФорма = МДОбъект.Формы.Получить(0);
                ИмяФормы = МДФорма.Имя;
        КонецЕсли;
        
        // Собираем информацию о форме
        РеквизитыФормы = Новый Массив;
        Для Каждого Реквизит Из МДФорма.Реквизиты Цикл
                Элемент = Новый Соответствие;
                Элемент.Вставить("name", Реквизит.Имя);
                Элемент.Вставить("title", Реквизит.Заголовок);
                Попытка
                        Элемент.Вставить("type", Строка(Реквизит.Тип));
                Исключение
                        Элемент.Вставить("type", "Неизвестно");
                КонецПопытки;
                РеквизитыФормы.Добавить(Элемент);
        КонецЦикла;
        
        КомандыФормы = Новый Массив;
        Для Каждого Команда Из МДФорма.Команды Цикл
                Элемент = Новый Соответствие;
                Элемент.Вставить("name", Команда.Имя);
                Элемент.Вставить("title", Команда.Заголовок);
                КомандыФормы.Добавить(Элемент);
        КонецЦикла;
        
        // Список доступных форм объекта
        ВсеФормы = Новый Массив;
        Для Каждого Ф Из МДОбъект.Формы Цикл
                ВсеФормы.Добавить(Ф.Имя);
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("object", ПолноеИмя);
        Ответ.Вставить("form_name", ИмяФормы);
        Ответ.Вставить("attributes", РеквизитыФормы);
        Ответ.Вставить("attribute_count", РеквизитыФормы.Количество());
        Ответ.Вставить("commands", КомандыФормы);
        Ответ.Вставить("command_count", КомандыФормы.Количество());
        Ответ.Вставить("available_forms", ВсеФормы);
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #48 — get_rights: Права доступа текущего пользователя
Функция Инструмент_GetRights(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Если ПолноеИмя = Неопределено ИЛИ ПолноеИмя = "" Тогда
                ВызватьИсключение "Параметр full_name обязателен";
        КонецЕсли;
        
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                ВызватьИсключение "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        Права = Новый Соответствие;
        
        // Базовые права — проверяем через ПравоДоступа
        МассивПрав = Новый Массив;
        МассивПрав.Добавить("Чтение");
        МассивПрав.Добавить("Добавление");
        МассивПрав.Добавить("Изменение");
        МассивПрав.Добавить("Удаление");
        МассивПрав.Добавить("Проведение");
        МассивПрав.Добавить("ОтменаПроведения");
        МассивПрав.Добавить("ИнтерактивноеДобавление");
        МассивПрав.Добавить("ИнтерактивноеИзменение");
        МассивПрав.Добавить("ИнтерактивноеУдаление");
        МассивПрав.Добавить("Просмотр");
        МассивПрав.Добавить("ИнтерактивнаяПометкаУдаления");
        
        Для Каждого ИмяПрава Из МассивПрав Цикл
                Попытка
                        Права.Вставить(ИмяПрава, ПравоДоступа(ИмяПрава, МДОбъект));
                Исключение
                        // Право не применимо к данному объекту — пропускаем
                КонецПопытки;
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("object", ПолноеИмя);
        Ответ.Вставить("user", Строка(ПользователиИнформационнойБазы.ТекущийПользователь().Имя));
        Ответ.Вставить("rights", Права);
        Ответ.Вставить("is_full_rights", ПривилегированныйРежим());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #49 — find_duplicates: Поиск дублей в справочниках
Функция Инструмент_FindDuplicates(Аргументы)
        
        ПолноеИмя = Аргументы["full_name"];
        Если ПолноеИмя = Неопределено ИЛИ ПолноеИмя = "" Тогда
                ВызватьИсключение "Параметр full_name обязателен";
        КонецЕсли;
        
        СтрокаРеквизитов = Аргументы["attributes"];
        Если СтрокаРеквизитов = Неопределено ИЛИ СтрокаРеквизитов = "" Тогда
                ВызватьИсключение "Параметр attributes обязателен";
        КонецЕсли;
        
        Порог = Аргументы["threshold"];
        Если Порог = Неопределено Тогда
                Порог = 90;
        КонецЕсли;
        
        МаксРезультатов = Аргументы["max_results"];
        Если МаксРезультатов = Неопределено ИЛИ МаксРезультатов = 0 Тогда
                МаксРезультатов = 100;
        КонецЕсли;
        
        Части = РазобратьПолноеИмя(ПолноеИмя);
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        Если МДОбъект = Неопределено Тогда
                ВызватьИсключение "Объект метаданных не найден: " + ПолноеИмя;
        КонецЕсли;
        
        // Парсим список реквизитов
        МассивРеквизитов = СтрРазделить(СтрокаРеквизитов, ",", Ложь);
        Для Индекс = 0 По МассивРеквизитов.ВГраница() Цикл
                МассивРеквизитов[Индекс] = СокрЛП(МассивРеквизитов[Индекс]);
        КонецЦикла;
        
        // Формируем запрос — ищем записи с одинаковыми значениями
        ПоляВыборки = "Ссылка";
        Для Каждого ИмяРеквизита Из МассивРеквизитов Цикл
                ПоляВыборки = ПоляВыборки + ", " + ИмяРеквизита;
        КонецЦикла;
        
        // Самосоединение для поиска дублей
        УсловияСравнения = Новый Массив;
        Для Каждого ИмяРеквизита Из МассивРеквизитов Цикл
                УсловияСравнения.Добавить("Т1." + ИмяРеквизита + " = Т2." + ИмяРеквизита);
        КонецЦикла;
        
        ТекстЗапроса = "ВЫБРАТЬ ПЕРВЫЕ " + Формат(МаксРезультатов * 2, "ЧГ=") + "
        |        Т1.Ссылка КАК Ссылка1,
        |        Т2.Ссылка КАК Ссылка2";
        
        Для Каждого ИмяРеквизита Из МассивРеквизитов Цикл
                ТекстЗапроса = ТекстЗапроса + ",
        |        Т1." + ИмяРеквизита + " КАК " + ИмяРеквизита;
        КонецЦикла;
        
        ТекстЗапроса = ТекстЗапроса + "
        |ИЗ " + ПолноеИмя + " КАК Т1
        |        ВНУТРЕННЕЕ СОЕДИНЕНИЕ " + ПолноеИмя + " КАК Т2
        |        ПО " + СтрСоединить(УсловияСравнения, " И ") + "
        |                И Т1.Ссылка < Т2.Ссылка
        |ГДЕ НЕ Т1.ПометкаУдаления И НЕ Т2.ПометкаУдаления";
        
        Запрос = Новый Запрос(ТекстЗапроса);
        Результат = Запрос.Выполнить();
        
        Пары = Новый Массив;
        Выборка = Результат.Выбрать();
        Пока Выборка.Следующий() И Пары.Количество() < МаксРезультатов Цикл
                Пара = Новый Соответствие;
                Пара.Вставить("ref1", ЗначениеДляJSON(Выборка.Ссылка1));
                Пара.Вставить("presentation1", Строка(Выборка.Ссылка1));
                Пара.Вставить("ref2", ЗначениеДляJSON(Выборка.Ссылка2));
                Пара.Вставить("presentation2", Строка(Выборка.Ссылка2));
                ОбщиеПоля = Новый Соответствие;
                Для Каждого ИмяРеквизита Из МассивРеквизитов Цикл
                        ОбщиеПоля.Вставить(ИмяРеквизита, ЗначениеДляJSON(Выборка[ИмяРеквизита]));
                КонецЦикла;
                Пара.Вставить("matching_fields", ОбщиеПоля);
                Пара.Вставить("match_score", 100); // точное совпадение
                Пары.Добавить(Пара);
        КонецЦикла;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("object", ПолноеИмя);
        Ответ.Вставить("attributes", МассивРеквизитов);
        Ответ.Вставить("duplicates", Пары);
        Ответ.Вставить("count", Пары.Количество());
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции


// #50 — get_print_form: Печатная форма через УправлениеПечатью
Функция Инструмент_GetPrintForm(Аргументы)
        
        СтрСсылка = Аргументы["document_ref"];
        Если СтрСсылка = Неопределено ИЛИ СтрСсылка = "" Тогда
                ВызватьИсключение "Параметр document_ref обязателен";
        КонецЕсли;
        
        ИдПечатнойФормы = Аргументы["print_form_id"];
        
        Формат = Аргументы["format"];
        Если Формат = Неопределено ИЛИ Формат = "" Тогда
                Формат = "info";
        КонецЕсли;
        
        // Ищем документ по GUID
        Ссылка = XMLЗначение(Тип("УникальныйИдентификатор"), СтрСсылка);
        НайденнаяСсылка = Неопределено;
        ТипДокумента = "";
        Для Каждого МДДок Из Метаданные.Документы Цикл
                Попытка
                        Кандидат = Документы[МДДок.Имя].ПолучитьСсылку(Ссылка);
                        Если Кандидат.ПолучитьОбъект() <> Неопределено Тогда
                                НайденнаяСсылка = Кандидат;
                                ТипДокумента = МДДок.ПолноеИмя();
                                Прервать;
                        КонецЕсли;
                Исключение
                КонецПопытки;
        КонецЦикла;
        
        Если НайденнаяСсылка = Неопределено Тогда
                ВызватьИсключение "Документ не найден по GUID: " + СтрСсылка;
        КонецЕсли;
        
        МассивОбъектов = Новый Массив;
        МассивОбъектов.Добавить(НайденнаяСсылка);
        
        // Если ИдПечатнойФормы не указан — возвращаем список доступных форм
        Если ИдПечатнойФормы = Неопределено ИЛИ ИдПечатнойФормы = "" Тогда
                КомандыПечати = Новый Соответствие;
                Попытка
                        ТаблицаКоманд = УправлениеПечатью.КомандыПечатиОбъекта(НайденнаяСсылка.Метаданные());
                        ДоступныеФормы = Новый Массив;
                        Для Каждого Команда Из ТаблицаКоманд Цикл
                                Элемент = Новый Соответствие;
                                Элемент.Вставить("id", Команда.Идентификатор);
                                Элемент.Вставить("presentation", Команда.Представление);
                                ДоступныеФормы.Добавить(Элемент);
                        КонецЦикла;
                        
                        Ответ = Новый Соответствие;
                        Ответ.Вставить("document", СтрСсылка);
                        Ответ.Вставить("document_type", ТипДокумента);
                        Ответ.Вставить("available_forms", ДоступныеФормы);
                        Ответ.Вставить("count", ДоступныеФормы.Количество());
                        Возврат ОбъектВJSON(Ответ);
                Исключение
                        ВызватьИсключение "Не удалось получить список печатных форм: " + ОписаниеОшибки();
                КонецПопытки;
        КонецЕсли;
        
        // Генерируем печатную форму
        Попытка
                КоллекцияПечатныхФорм = УправлениеПечатью.СформироватьПечатныеФормы(
                        ИдПечатнойФормы, 
                        МассивОбъектов);
        Исключение
                ВызватьИсключение "Ошибка формирования печатной формы '" + ИдПечатнойФормы + "': " + ОписаниеОшибки();
        КонецПопытки;
        
        Если КоллекцияПечатныхФорм.Количество() = 0 Тогда
                ВызватьИсключение "Печатная форма не сформирована";
        КонецЕсли;
        
        ТабДокумент = КоллекцияПечатныхФорм[0].ТабличныйДокумент;
        
        Если Формат = "mxl_text" Тогда
                // Текстовое представление табличного документа
                ТекстовыйДокумент = Новый ТекстовыйДокумент;
                Для НомерСтроки = 1 По ТабДокумент.ВысотаТаблицы Цикл
                        СтрокаТекста = "";
                        Для НомерКолонки = 1 По ТабДокумент.ШиринаТаблицы Цикл
                                Область = ТабДокумент.Область(НомерСтроки, НомерКолонки);
                                Текст = СокрЛП(Строка(Область.Текст));
                                Если Текст <> "" Тогда
                                        СтрокаТекста = СтрокаТекста + Текст + " | ";
                                КонецЕсли;
                        КонецЦикла;
                        Если СтрокаТекста <> "" Тогда
                                ТекстовыйДокумент.ДобавитьСтроку(СтрокаТекста);
                        КонецЕсли;
                КонецЦикла;
                
                Ответ = Новый Соответствие;
                Ответ.Вставить("document", СтрСсылка);
                Ответ.Вставить("print_form_id", ИдПечатнойФормы);
                Ответ.Вставить("format", "mxl_text");
                Ответ.Вставить("text", ТекстовыйДокумент.ПолучитьТекст());
                Ответ.Вставить("rows", ТабДокумент.ВысотаТаблицы);
                Ответ.Вставить("columns", ТабДокумент.ШиринаТаблицы);
                Возврат ОбъектВJSON(Ответ);
        Иначе
                // info — мета-описание печатной формы
                Ответ = Новый Соответствие;
                Ответ.Вставить("document", СтрСсылка);
                Ответ.Вставить("print_form_id", ИдПечатнойФормы);
                Ответ.Вставить("format", "info");
                Ответ.Вставить("rows", ТабДокумент.ВысотаТаблицы);
                Ответ.Вставить("columns", ТабДокумент.ШиринаТаблицы);
                Ответ.Вставить("title", КоллекцияПечатныхФорм[0].СинонимМакета);
                Возврат ОбъектВJSON(Ответ);
        КонецЕсли;
        
КонецФункции


// #51 — get_configuration_extensions: Список расширений конфигурации
Функция Инструмент_GetConfigurationExtensions(Аргументы)
        
        ТолькоАктивные = Аргументы["active_only"];
        Если ТолькоАктивные = Неопределено Тогда
                ТолькоАктивные = Истина;
        КонецЕсли;
        
        Расширения = Новый Массив;
        
        Попытка
                Коллекция = РасширенияКонфигурации.Получить();
                Для Каждого Расширение Из Коллекция Цикл
                        Если ТолькоАктивные И НЕ Расширение.Активно Тогда
                                Продолжить;
                        КонецЕсли;
                        
                        Элемент = Новый Соответствие;
                        Элемент.Вставить("name", Расширение.Имя);
                        Элемент.Вставить("synonym", Расширение.Синоним);
                        Элемент.Вставить("version", Расширение.Версия);
                        Элемент.Вставить("active", Расширение.Активно);
                        Элемент.Вставить("safe_mode", Расширение.БезопасныйРежим);
                        Элемент.Вставить("purpose", Строка(Расширение.Назначение));
                        Элемент.Вставить("scope", Строка(Расширение.ОбластьДействия));
                        
                        Попытка
                                Элемент.Вставить("uuid", XMLСтрока(Расширение.УникальныйИдентификатор));
                        Исключение
                                Элемент.Вставить("uuid", "");
                        КонецПопытки;
                        
                        Расширения.Добавить(Элемент);
                КонецЦикла;
        Исключение
                ВызватьИсключение "Не удалось получить список расширений: " + ОписаниеОшибки();
        КонецПопытки;
        
        Ответ = Новый Соответствие;
        Ответ.Вставить("extensions", Расширения);
        Ответ.Вставить("count", Расширения.Количество());
        Ответ.Вставить("active_only", ТолькоАктивные);
        Возврат ОбъектВJSON(Ответ);
        
КонецФункции

#КонецОбласти

#Область ВспомогательныеФункции
// ============================================================================

// Разбирает полное имя вида "Справочник.Номенклатура" на тип и имя
Функция РазобратьПолноеИмя(ПолноеИмя)
        
        Поз = СтрНайти(ПолноеИмя, ".");
        Если Поз = 0 Тогда
                Возврат Неопределено;
        КонецЕсли;
        
        Результат = Новый Структура;
        Результат.Вставить("Тип", Лев(ПолноеИмя, Поз - 1));
        Результат.Вставить("Имя", Сред(ПолноеИмя, Поз + 1));
        Возврат Результат;
        
КонецФункции

// Возвращает менеджер объекта (Справочники[...], Документы[...] и т.д.)
Функция ПолучитьМенеджерОбъекта(Тип, Имя)
        
        Если Тип = "Справочник" Тогда
                Возврат Справочники[Имя];
        ИначеЕсли Тип = "Документ" Тогда
                Возврат Документы[Имя];
        ИначеЕсли Тип = "ПланСчетов" Тогда
                Возврат ПланыСчетов[Имя];
        ИначеЕсли Тип = "ПланВидовХарактеристик" Тогда
                Возврат ПланыВидовХарактеристик[Имя];
        ИначеЕсли Тип = "ПланОбмена" Тогда
                Возврат ПланыОбмена[Имя];
        Иначе
                Возврат Неопределено;
        КонецЕсли;
        
КонецФункции

// Описание реквизита метаданных
Функция ОписаниеРеквизита(Реквизит)
        
        РА = Новый Соответствие;
        РА.Вставить("name", Реквизит.Имя);
        РА.Вставить("synonym", Реквизит.Синоним);
        
        // Тип
        ОписаниеТипа = Реквизит.Тип;
        Типы = Новый Массив;
        Для Каждого Т Из ОписаниеТипа.Типы() Цикл
                Типы.Добавить(Строка(Т));
        КонецЦикла;
        РА.Вставить("types", Типы);
        
        // Длина строки (если есть)
        Попытка
                Если ОписаниеТипа.КвалификаторыСтроки <> Неопределено Тогда
                        РА.Вставить("string_length", ОписаниеТипа.КвалификаторыСтроки.Длина);
                КонецЕсли;
        Исключение
        КонецПопытки;
        
        Возврат РА;
        
КонецФункции

// Преобразование любого значения 1С в JSON-совместимый тип
Функция ЗначениеДляJSON(Значение)
        
        Если Значение = Неопределено Или Значение = NULL Тогда
                Возврат Неопределено;
        КонецЕсли;
        
        ТипЗначения = ТипЗнч(Значение);
        
        Если ТипЗначения = Тип("Строка")
                Или ТипЗначения = Тип("Число")
                Или ТипЗначения = Тип("Булево") Тогда
                Возврат Значение;
                
        ИначеЕсли ТипЗначения = Тип("Дата") Тогда
                Возврат Формат(Значение, "ДФ=yyyy-MM-ddTHH:mm:ss");
                
        ИначеЕсли ТипЗначения = Тип("УникальныйИдентификатор") Тогда
                Возврат Строка(Значение);
        Иначе
                // Для ссылочных типов пытаемся получить представление и UUID
                Попытка
                        МД = Значение.Метаданные();
                        Рез = Новый Соответствие;
                        Рез.Вставить("_ref", Строка(Значение));
                        Рез.Вставить("_type", МД.ПолноеИмя());
                        Попытка
                                Рез.Вставить("_guid", Строка(Значение.УникальныйИдентификатор()));
                        Исключение
                        КонецПопытки;
                        Возврат Рез;
                Исключение
                        Возврат Строка(Значение);
                КонецПопытки;
        КонецЕсли;
        
КонецФункции

// Сериализация объекта 1С (справочник, документ) в Соответствие
Функция СериализоватьОбъект(Объект, ПолноеИмя)
        
        Результат = Новый Соответствие;
        
        МДОбъект = Метаданные.НайтиПоПолномуИмени(ПолноеИмя);
        
        // UUID
        Попытка
                Результат.Вставить("_guid", Строка(Объект.Ссылка.УникальныйИдентификатор()));
        Исключение
        КонецПопытки;
        
        Результат.Вставить("_type", ПолноеИмя);
        
        // Стандартные реквизиты
        Попытка Результат.Вставить("Код", Объект.Код); Исключение КонецПопытки;
        Попытка Результат.Вставить("Наименование", Объект.Наименование); Исключение КонецПопытки;
        Попытка Результат.Вставить("Дата", Формат(Объект.Дата, "ДФ=yyyy-MM-ddTHH:mm:ss")); Исключение КонецПопытки;
        Попытка Результат.Вставить("Номер", Объект.Номер); Исключение КонецПопытки;
        Попытка Результат.Вставить("ПометкаУдаления", Объект.ПометкаУдаления); Исключение КонецПопытки;
        Попытка Результат.Вставить("Проведен", Объект.Проведен); Исключение КонецПопытки;
        Попытка Результат.Вставить("Родитель", ЗначениеДляJSON(Объект.Родитель)); Исключение КонецПопытки;
        Попытка Результат.Вставить("Владелец", ЗначениеДляJSON(Объект.Владелец)); Исключение КонецПопытки;
        
        // Пользовательские реквизиты
        Если МДОбъект <> Неопределено Тогда
                Попытка
                        Для Каждого Рекв Из МДОбъект.Реквизиты Цикл
                                Попытка
                                        Результат.Вставить(Рекв.Имя, ЗначениеДляJSON(Объект[Рекв.Имя]));
                                Исключение
                                КонецПопытки;
                        КонецЦикла;
                Исключение
                КонецПопытки;
                
                // Табличные части
                Попытка
                        Для Каждого ТабЧасть Из МДОбъект.ТабличныеЧасти Цикл
                                СтрокиТЧ = Новый Массив;
                                Для Каждого СтрокаТЧ Из Объект[ТабЧасть.Имя] Цикл
                                        СтрокаДанных = Новый Соответствие;
                                        СтрокаДанных.Вставить("НомерСтроки", СтрокаТЧ.НомерСтроки);
                                        Для Каждого Рекв Из ТабЧасть.Реквизиты Цикл
                                                Попытка
                                                        СтрокаДанных.Вставить(Рекв.Имя, ЗначениеДляJSON(СтрокаТЧ[Рекв.Имя]));
                                                Исключение
                                                КонецПопытки;
                                        КонецЦикла;
                                        СтрокиТЧ.Добавить(СтрокаДанных);
                                КонецЦикла;
                                Результат.Вставить(ТабЧасть.Имя, СтрокиТЧ);
                        КонецЦикла;
                Исключение
                КонецПопытки;
        КонецЕсли;
        
        Возврат Результат;
        
КонецФункции

// Заполнение реквизитов объекта из Соответствия
Процедура ЗаполнитьРеквизитыОбъекта(Объект, Реквизиты, ПолноеИмя)
        
        Для Каждого КЗ Из Реквизиты Цикл
                ИмяРеквизита = КЗ.Ключ;
                Значение = КЗ.Значение;
                
                // Пропускаем служебные поля
                Если СтрНачинаетсяС(ИмяРеквизита, "_") Тогда Продолжить; КонецЕсли;
                
                Попытка
                        УстановитьЗначениеРеквизита(Объект, ИмяРеквизита, Значение);
                Исключение
                КонецПопытки;
        КонецЦикла;
        
КонецПроцедуры

// Установка значения реквизита с преобразованием типов
Процедура УстановитьЗначениеРеквизита(Объект, ИмяРеквизита, Значение)
        
        // Если имя заканчивается на _guid — это ссылочный тип, нужно найти объект
        Если СтрЗаканчиваетсяНа(ИмяРеквизита, "_guid") Тогда
                // Формат: ИмяРеквизита_guid = "UUID", ожидаем что реквизит = ИмяРеквизита
                НастоящееИмя = Лев(ИмяРеквизита, СтрДлина(ИмяРеквизита) - 5);
                // Определяем тип реквизита из метаданных
                МД = Объект.Метаданные();
                Для Каждого Рекв Из МД.Реквизиты Цикл
                        Если Рекв.Имя = НастоящееИмя Тогда
                                Типы = Рекв.Тип.Типы();
                                Если Типы.Количество() > 0 Тогда
                                        ТипСсылки = Типы[0];
                                        МДСсылки = Метаданные.НайтиПоТипу(ТипСсылки);
                                        Если МДСсылки <> Неопределено Тогда
                                                Части = РазобратьПолноеИмя(МДСсылки.ПолноеИмя());
                                                Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
                                                Если Менеджер <> Неопределено Тогда
                                                        УИД = Новый УникальныйИдентификатор(Значение);
                                                        Объект[НастоящееИмя] = Менеджер.ПолучитьСсылку(УИД);
                                                        Возврат;
                                                КонецЕсли;
                                        КонецЕсли;
                                КонецЕсли;
                                Прервать;
                        КонецЕсли;
                КонецЦикла;
                Возврат;
        КонецЕсли;
        
        // Обычное присваивание
        Объект[ИмяРеквизита] = Значение;
        
КонецПроцедуры


Функция СтрПовторить(ПовторяемыйФрагмент,КоличествоПовторов) 
МассивПустыхСтрок=новый массив(КоличествоПовторов + 1);	
Результат = СтрСоединить(МассивПустыхСтрок, ПовторяемыйФрагмент); 
Возврат Результат;
КонецФункции


// Преобразование строки даты в Дату 1С (поддержка ISO 8601 и YYYYMMDD)
Функция ПреобразоватьДату(СтрокаДаты)
	Если СтрокаДаты = Неопределено Или ПустаяСтрока(СтрокаДаты) Тогда
		Возврат Неопределено;
	КонецЕсли;
	
	// Приводим к строке если число
	Стр = СокрЛП(Строка(СтрокаДаты));
	
	// Убираем суффикс часового пояса (Z, +05:00, -03:00)
	Стр = СтрЗаменить(Стр, "Z", "");
	ПозицияПлюс = СтрНайти(Стр, "+");
	Если ПозицияПлюс > 10 Тогда
		Стр = Лев(Стр, ПозицияПлюс - 1);
	КонецЕсли;
	// Минус в конце (часовой пояс -XX:XX после времени)
	ДлинаСтр = СтрДлина(Стр);
	Если ДлинаСтр > 19 Тогда
		// Обрезаем хвост (пояс)
		Стр = Лев(Стр, 19);
	КонецЕсли;
	
	Попытка
		// Формат ISO 8601: 2026-05-14T10:30:00
		Если СтрНайти(Стр, "T") > 0 Или СтрНайти(Стр, "t") > 0 Тогда
			ЧастиДТ = СтрРазделить(ВРег(Стр), "T");
			Если ЧастиДТ.Количество() < 2 Тогда Возврат Неопределено; КонецЕсли;
			ЧастиДаты = СтрРазделить(ЧастиДТ[0], "-");
			Если ЧастиДаты.Количество() < 3 Тогда Возврат Неопределено; КонецЕсли;
			ВремяСтр = ЧастиДТ[1];
			// Отсекаем дробные секунды (.123)
			ПозТочки = СтрНайти(ВремяСтр, ".");
			Если ПозТочки > 0 Тогда ВремяСтр = Лев(ВремяСтр, ПозТочки - 1); КонецЕсли;
			ЧастиВремени = СтрРазделить(ВремяСтр, ":");
			Год = Формат(Число(ЧастиДаты[0]), "ЧЦ=4; ЧВН=; ЧГ=");
			Мес = Формат(Число(ЧастиДаты[1]), "ЧЦ=2; ЧВН=; ЧГ=");
			День = Формат(Число(ЧастиДаты[2]), "ЧЦ=2; ЧВН=; ЧГ=");
			Час = Формат(Число(ЧастиВремени[0]), "ЧЦ=2; ЧВН=; ЧГ=");
			Мин = ?(ЧастиВремени.Количество() > 1, Формат(Число(ЧастиВремени[1]), "ЧЦ=2; ЧВН=; ЧГ="), "00");
			Сек = ?(ЧастиВремени.Количество() > 2, Формат(Число(ЧастиВремени[2]), "ЧЦ=2; ЧВН=; ЧГ="), "00");
			Возврат Дата(Год + Мес + День + Час + Мин + Сек);
		КонецЕсли;
		
		// Формат YYYYMMDD (8 цифр без разделителей)
		Если СтрДлина(Стр) = 8 И СтрНайти(Стр, "-") = 0 И СтрНайти(Стр, ".") = 0 Тогда
			Возврат Дата(Стр + "000000");
		КонецЕсли;
		
		// Формат YYYYMMDDHHMMSS (14 цифр)
		Если СтрДлина(Стр) = 14 И СтрНайти(Стр, "-") = 0 Тогда
			Возврат Дата(Стр);
		КонецЕсли;
		
		// Формат YYYY-MM-DD
		Если СтрДлина(Стр) = 10 И СтрНайти(Стр, "-") > 0 Тогда
			ЧастиДаты = СтрРазделить(Стр, "-");
			Если ЧастиДаты.Количество() = 3 Тогда
				Год = Формат(Число(ЧастиДаты[0]), "ЧЦ=4; ЧВН=; ЧГ=");
				Мес = Формат(Число(ЧастиДаты[1]), "ЧЦ=2; ЧВН=; ЧГ=");
				День = Формат(Число(ЧастиДаты[2]), "ЧЦ=2; ЧВН=; ЧГ=");
				Возврат Дата(Год + Мес + День + "000000");
			КонецЕсли;
		КонецЕсли;
		
		// Формат DD.MM.YYYY (русский)
		Если СтрДлина(Стр) = 10 И СтрНайти(Стр, ".") > 0 Тогда
			ЧастиДаты = СтрРазделить(Стр, ".");
			Если ЧастиДаты.Количество() = 3 Тогда
				Год = Формат(Число(ЧастиДаты[2]), "ЧЦ=4; ЧВН=; ЧГ=");
				Мес = Формат(Число(ЧастиДаты[1]), "ЧЦ=2; ЧВН=; ЧГ=");
				День = Формат(Число(ЧастиДаты[0]), "ЧЦ=2; ЧВН=; ЧГ=");
				Возврат Дата(Год + Мес + День + "000000");
			КонецЕсли;
		КонецЕсли;
		
		Возврат Неопределено;
	Исключение
		Возврат Неопределено;
	КонецПопытки;
КонецФункции


// Преобразование значения для записи в регистр с учётом ссылочных типов
Функция ПреобразоватьЗначениеДляРегистра(МДИзмерение, Значение)
        Если Значение = Неопределено Тогда Возврат Неопределено; КонецЕсли;
        
        // Проверяем, является ли тип ссылочным
        Типы = МДИзмерение.Тип.Типы();
        Для Каждого Тип Из Типы Цикл
                МДТипа = Метаданные.НайтиПоТипу(Тип);
                Если МДТипа <> Неопределено Тогда
                        // Это ссылочный тип — пробуем преобразовать GUID
                        Попытка
                                Части = РазобратьПолноеИмя(МДТипа.ПолноеИмя());
                                Менеджер = ПолучитьМенеджерОбъекта(Части.Тип, Части.Имя);
                                Если Менеджер <> Неопределено Тогда
                                        УИД = Новый УникальныйИдентификатор(Значение);
                                        Возврат Менеджер.ПолучитьСсылку(УИД);
                                КонецЕсли;
                        Исключение
                        КонецПопытки;
                КонецЕсли;
        КонецЦикла;
        
        Возврат Значение;
КонецФункции

// Преобразование значения по метаданным регистра (универсальное)
Функция ПреобразоватьЗначениеПоМетаданным(МДРегистр, ИмяПоля, Значение)
        
        // Ищем поле среди измерений
        Для Каждого Изм Из МДРегистр.Измерения Цикл
                Если Изм.Имя = ИмяПоля Тогда
                        Возврат ПреобразоватьЗначениеДляРегистра(Изм, Значение);
                КонецЕсли;
        КонецЦикла;
        
        // Ищем среди ресурсов
        Для Каждого Рес Из МДРегистр.Ресурсы Цикл
                Если Рес.Имя = ИмяПоля Тогда
                        Возврат ПреобразоватьЗначениеДляРегистра(Рес, Значение);
                КонецЕсли;
        КонецЦикла;
        
        // Ищем среди реквизитов
        Для Каждого Рекв Из МДРегистр.Реквизиты Цикл
                Если Рекв.Имя = ИмяПоля Тогда
                        Возврат ПреобразоватьЗначениеДляРегистра(Рекв, Значение);
                КонецЕсли;
        КонецЦикла;
        
        Возврат Значение;
КонецФункции

// Вспомогательная: свойство-массив для описания инструментов
Функция СвойствоМассив(Описание)
        Св = Новый Соответствие;
        Св.Вставить("type", "array");
        Св.Вставить("description", Описание);
        Св.Вставить("items", Новый Соответствие); // items: { type: "object" }
        Св["items"].Вставить("type", "object");
        Возврат Св;
КонецФункции

// Диспетчер: вызов инструмента по имени (для execute_batch)
Функция ВыполнитьИнструментПоИмени(ИмяИнструмента, Аргументы)
        
        // Группа А: Метаданные
        Если ИмяИнструмента = "get_metadata_tree" Тогда Возврат Инструмент_GetMetadataTree(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_object_metadata" Тогда Возврат Инструмент_GetObjectMetadata(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_object_attributes" Тогда Возврат Инструмент_GetObjectAttributes(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_object_tabular_sections" Тогда Возврат Инструмент_GetObjectTabularSections(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_enum_values" Тогда Возврат Инструмент_GetEnumValues(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_register_dimensions" Тогда Возврат Инструмент_GetRegisterDimensions(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_document_movements" Тогда Возврат Инструмент_GetDocumentMovements(Аргументы);
        ИначеЕсли ИмяИнструмента = "analyze_impact" Тогда Возврат Инструмент_AnalyzeImpact(Аргументы);
        ИначеЕсли ИмяИнструмента = "search_metadata" Тогда Возврат Инструмент_SearchMetadata(Аргументы);
        // Группа Б: Чтение данных
        ИначеЕсли ИмяИнструмента = "execute_query" Тогда Возврат Инструмент_ExecuteQuery(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_object_by_ref" Тогда Возврат Инструмент_GetObjectByRef(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_list" Тогда Возврат Инструмент_GetList(Аргументы);
        ИначеЕсли ИмяИнструмента = "find_by_code" Тогда Возврат Инструмент_FindByCode(Аргументы);
        ИначеЕсли ИмяИнструмента = "find_by_name" Тогда Возврат Инструмент_FindByName(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_register_records" Тогда Возврат Инструмент_GetRegisterRecords(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_document_list" Тогда Возврат Инструмент_GetDocumentList(Аргументы);
        // Группа В: Запись данных
        ИначеЕсли ИмяИнструмента = "create_object" Тогда Возврат Инструмент_CreateObject(Аргументы);
        ИначеЕсли ИмяИнструмента = "update_object" Тогда Возврат Инструмент_UpdateObject(Аргументы);
        ИначеЕсли ИмяИнструмента = "delete_object" Тогда Возврат Инструмент_DeleteObject(Аргументы);
        ИначеЕсли ИмяИнструмента = "post_document" Тогда Возврат Инструмент_PostDocument(Аргументы);
        ИначеЕсли ИмяИнструмента = "unpost_document" Тогда Возврат Инструмент_UnpostDocument(Аргументы);
        ИначеЕсли ИмяИнструмента = "copy_object" Тогда Возврат Инструмент_CopyObject(Аргументы);
        ИначеЕсли ИмяИнструмента = "set_attribute" Тогда Возврат Инструмент_SetAttribute(Аргументы);
        // Группа Г: Код и отчёты
        ИначеЕсли ИмяИнструмента = "execute_code" Тогда Возврат Инструмент_ExecuteCode(Аргументы);
        ИначеЕсли ИмяИнструмента = "evaluate_expression" Тогда Возврат Инструмент_EvaluateExpression(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_module_text" Тогда Возврат Инструмент_GetModuleText(Аргументы);
        ИначеЕсли ИмяИнструмента = "generate_report" Тогда Возврат Инструмент_GenerateReport(Аргументы);
        // Группа Д: Администрирование
        ИначеЕсли ИмяИнструмента = "get_active_users" Тогда Возврат Инструмент_GetActiveUsers(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_event_log" Тогда Возврат Инструмент_GetEventLog(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_locks" Тогда Возврат Инструмент_GetLocks(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_server_info" Тогда Возврат Инструмент_GetServerInfo(Аргументы);
        ИначеЕсли ИмяИнструмента = "check_references" Тогда Возврат Инструмент_CheckReferences(Аргументы);
        ИначеЕсли ИмяИнструмента = "run_scheduled_job" Тогда Возврат Инструмент_RunScheduledJob(Аргументы);
        // Группа Е: Интеграция
        ИначеЕсли ИмяИнструмента = "exchange_execute" Тогда Возврат Инструмент_ExchangeExecute(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_exchange_log" Тогда Возврат Инструмент_GetExchangeLog(Аргументы);
        ИначеЕсли ИмяИнструмента = "import_data" Тогда Возврат Инструмент_ImportData(Аргументы);
        // Группа Ж: Новые v2.0
        ИначеЕсли ИмяИнструмента = "fill_on_basis" Тогда Возврат Инструмент_FillOnBasis(Аргументы);
        ИначеЕсли ИмяИнструмента = "write_register_records" Тогда Возврат Инструмент_WriteRegisterRecords(Аргументы);
        ИначеЕсли ИмяИнструмента = "update_tabular_section" Тогда Возврат Инструмент_UpdateTabularSection(Аргументы);
        ИначеЕсли ИмяИнструмента = "subscribe_events" Тогда Возврат Инструмент_SubscribeEvents(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_changes_since" Тогда Возврат Инструмент_GetChangesSince(Аргументы);
        // Группа З: Новые v2.1
        ИначеЕсли ИмяИнструмента = "get_balance" Тогда Возврат Инструмент_GetBalance(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_register_totals" Тогда Возврат Инструмент_GetRegisterTotals(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_accounting_entries" Тогда Возврат Инструмент_GetAccountingEntries(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_related_documents" Тогда Возврат Инструмент_GetRelatedDocuments(Аргументы);
        ИначеЕсли ИмяИнструмента = "validate_document" Тогда Возврат Инструмент_ValidateDocument(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_form_structure" Тогда Возврат Инструмент_GetFormStructure(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_rights" Тогда Возврат Инструмент_GetRights(Аргументы);
        ИначеЕсли ИмяИнструмента = "find_duplicates" Тогда Возврат Инструмент_FindDuplicates(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_print_form" Тогда Возврат Инструмент_GetPrintForm(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_configuration_extensions" Тогда Возврат Инструмент_GetConfigurationExtensions(Аргументы);
        // Группа И: Понимание и анализ (двойник)
        ИначеЕсли ИмяИнструмента = "get_object_usage" Тогда Возврат Инструмент_GetObjectUsage(Аргументы);
        ИначеЕсли ИмяИнструмента = "count_records" Тогда Возврат Инструмент_CountRecords(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_subsystems" Тогда Возврат Инструмент_GetSubsystems(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_functional_options" Тогда Возврат Инструмент_GetFunctionalOptions(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_constants" Тогда Возврат Инструмент_GetConstants(Аргументы);
        ИначеЕсли ИмяИнструмента = "get_predefined" Тогда Возврат Инструмент_GetPredefined(Аргументы);
        ИначеЕсли ИмяИнструмента = "list_reports" Тогда Возврат Инструмент_ListReports(Аргументы);

        Иначе
                ВызватьИсключение "Неизвестный инструмент: " + ИмяИнструмента;
        КонецЕсли;
        
КонецФункции


#КонецОбласти