Как 1С научить говорить на языке Google и Apache: AVRO и Protobuf внутри

роцедура ИнициализацияСхемыAVRO(Компонента)

    ИмяСхемыJSON = "sales_document";

    // Определяем структуру данных
    СхемаJSON = "{
    |  ""type"": ""record"",
    |  ""name"": ""sales_document"",
    |  ""fields"": [
    |    {
    |      ""name"": ""document_id"",
    |      ""type"": {
    |        ""type"": ""string"",
    |        ""logicalType"": ""uuid""
    |      }
    |    },
    |    {
    |      ""name"": ""document_number"",
    |      ""type"": ""string""
    |    },
    |    {
    |      ""name"": ""document_date"",
    |      ""type"": ""long"",
    |      ""logicalType"": ""timestamp-millis""
    |    },
    |    {
    |      ""name"": ""customer_id"",
    |      ""type"": [""null"", ""string""]
    |    },
    |    {
    |      ""name"": ""amount"",
    |      ""type"": ""double""
    |    },
    |    {
    |      ""name"": ""currency"",
    |      ""type"": ""string""
    |    },
    |    {
    |      ""name"": ""line_count"",
    |      ""type"": ""int""
    |    }
    |  ]
    |}";

    // Сохраняем схему в компоненте
    Результат = Компонента.СохранитьСхемуAVRO(ИмяСхемыJSON, СхемаJSON);

    Если Не Результат Тогда
        ВызватьИсключение "Ошибка сохранения схемы AVRO: "
            + Компонента.ПрочитатьСообщениеОбОшибке();
    КонецЕсли;

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

Процедура ОтправитьДокументыВAVRO(МассивДокументов, Компонента)

    // AVRO ожидает данные в формате колонок (columnar format)
    // Это обеспечивает лучшее сжатие и производительность

    МассивИдентификаторов = Новый Массив;
    МассивНомеров = Новый Массив;
    МассивДат = Новый Массив;
    МассивКонтрагентов = Новый Массив;
    МассивСумм = Новый Массив;
    МассивВалют = Новый Массив;
    МассивСтрок = Новый Массив;

    Для Каждого Документ Из МассивДокументов Цикл

        МассивИдентификаторов.Добавить(Строка(Документ.УникальныйИдентификатор()));
        МассивНомеров.Добавить(Документ.Номер);
        МассивДат.Добавить((Документ.Дата - Дата(1970, 1, 1)) * 1000); // Unix timestamp в миллисекундах

        Если ЗначениеЗаполнено(Документ.Контрагент) Тогда
            МассивКонтрагентов.Добавить(Строка(Документ.Контрагент.УникальныйИдентификатор()));
        Иначе
            МассивКонтрагентов.Добавить(Null); // AVRO поддерживает null для Union-типов
        КонецЕсли;

        МассивСумм.Добавить(Документ.СуммаДокумента);
        МассивВалют.Добавить(Строка(Документ.ВалютаДокумента));
        МассивСтрок.Добавить(Документ.Товары.Количество());

    КонецЦикла;

    // Формируем JSON для AVRO (колоночный формат)
    ДанныеJSON = Новый Структура;
    ДанныеJSON.Вставить("document_id", МассивИдентификаторов);
    ДанныеJSON.Вставить("document_number", МассивНомеров);
    ДанныеJSON.Вставить("document_date", МассивДат);
    ДанныеJSON.Вставить("customer_id", МассивКонтрагентов);
    ДанныеJSON.Вставить("amount", МассивСумм);
    ДанныеJSON.Вставить("currency", МассивВалют);
    ДанныеJSON.Вставить("line_count", МассивСтрок);

    ЗаписьJSON = Новый ЗаписьJSON;
    ЗаписьJSON.УстановитьСтроку();
    ЗаписатьJSON(ЗаписьJSON, ДанныеJSON);
    СтрокаJSON = ЗаписьJSON.Закрыть();

    // Преобразуем в формат AVRO
    Результат = Компонента.ПреобразоватьВФорматAVRO(СтрокаJSON, "sales_document");

    Если Не Результат Тогда
        ВызватьИсключение "Ошибка преобразования в AVRO: "
            + Компонента.ПрочитатьСообщениеОбОшибке();
    КонецЕсли;

    // Отправляем в Kafka
    Топик = "sales.documents.v1";
    Ключ = Формат(ТекущаяДата(), "ДФ=yyyyMMdd"); // Партиционирование по дате

    РезультатОтправки = Компонента.ОтправитьСообщениеAVRO(Топик, , Ключ);

    Если РезультатОтправки = -1 Тогда
        ВызватьИсключение "Ошибка отправки AVRO: "
            + Компонента.ПрочитатьСообщениеОбОшибке();
    КонецЕсли;

    Сообщить("Отправлено документов в AVRO: " + МассивДокументов.Количество());

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

Процедура ИнициализацияСхемыProtobuf(Компонента)

    ИмяСхемы = "StockUpdate";

    // .proto схема (синтаксис Protocol Buffers)
    СхемаProto = "
    |syntax = ""proto3"";
    |
    |message StockUpdate {
    |  string product_id = 1;
    |  string warehouse_id = 2;
    |  double quantity = 3;
    |  string unit = 4;
    |  int64 timestamp = 5;
    |  string source_system = 6;
    |}
    |";

    Результат = Компонента.СохранитьСхемуProtobuf(ИмяСхемы, СхемаProto);

    Если Не Результат Тогда
        ВызватьИсключение "Ошибка сохранения схемы Protobuf: "
            + Компонента.ПрочитатьСообщениеОбОшибке();
    КонецЕсли;

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

Процедура ОбработкаОстатковИзKafka(Компонента)

    // Инициализируем потребителя
    АдресБрокера = "kafka-cluster.company.local:9092";
    ГруппаПотребителей = "1c_stock_processor";

    Компонента.ИнициализироватьКонсьюмера(АдресБрокера);
    Компонента.УстановитьПараметр("group.id", ГруппаПотребителей);
    Компонента.УстановитьПараметр("auto.offset.reset", "earliest");

    // Подписываемся на топик
    Топик = "warehouse.stock.updates";
    Компонента.Подписаться(Топик);

    Сообщить("Ожидание сообщений из топика: " + Топик);

    // Цикл обработки сообщений
    КоличествоОбработанных = 0;
    ТаймаутМс = 5000; // 5 секунд

    Пока КоличествоОбработанных < 100 Цикл // Обработаем 100 сообщений для примера

        // Получаем сообщение
        Если Компонента.ПрочитатьСообщение(ТаймаутМс) Тогда

            // Получаем бинарные данные Protobuf
            ДанныеProtobuf = Компонента.ПолучитьДанныеСообщения(Истина); // Истина = бинарные данные

            // Декодируем Protobuf в JSON
            ДанныеJSON = Компонента.ДекодироватьСообщениеProtobuf(
                ДанныеProtobuf,
                "StockUpdate",
                Истина // Возвращать JSON
            );

            Если ПустаяСтрока(ДанныеJSON) Тогда
                ВызватьИсключение "Ошибка декодирования Protobuf: "
                    + Компонента.ПрочитатьСообщениеОбОшибке();
            КонецЕсли;

            // Разбираем JSON
            ЧтениеJSON = Новый ЧтениеJSON;
            ЧтениеJSON.УстановитьСтроку(ДанныеJSON);
            ДанныеОстатка = ПрочитатьJSON(ЧтениеJSON);
            ЧтениеJSON.Закрыть();

            // Обрабатываем данные
            ОбработатьОстаток(ДанныеОстатка);

            КоличествоОбработанных = КоличествоОбработанных + 1;

        Иначе
            // Таймаут - сообщений нет
            Сообщить("Сообщений больше нет, завершение обработки.");
            Прервать;
        КонецЕсли;

    КонецЦикла;

    Сообщить("Обработано сообщений: " + КоличествоОбработанных);

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

Процедура ОбработатьОстаток(Данные)

    // Находим номенклатуру и склад по UUID
    Номенклатура = Справочники.Номенклатура.ПолучитьСсылку(
        Новый УникальныйИдентификатор(Данные["product_id"])
    );

    Склад = Справочники.Склады.ПолучитьСсылку(
        Новый УникальныйИдентификатор(Данные["warehouse_id"])
    );

    Количество = Данные["quantity"];
    ВременнаяМетка = Дата(1970, 1, 1) + Данные["timestamp"] / 1000;

    // Здесь логика обновления остатков в 1С
    // Например, создание документа корректировки или прямое изменение регистра

    Сообщить(СтрШаблон(
        "Остаток обновлен: %1 на складе %2 = %3 (источник: %4)",
        Номенклатура,
        Склад,
        Количество,
        Данные["source_system"]
    ));

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

Процедура ИнициализацияСхемыAVRO_Заказ(Компонента)

    ИмяСхемы = "order_event";

    СхемаJSON = "{
    |  ""type"": ""record"",
    |  ""name"": ""order_event"",
    |  ""namespace"": ""com.company.orders"",
    |  ""fields"": [
    |    {
    |      ""name"": ""order_id"",
    |      ""type"": {
    |        ""type"": ""string"",
    |        ""logicalType"": ""uuid""
    |      },
    |      ""doc"": ""Уникальный идентификатор заказа""
    |    },
    |    {
    |      ""name"": ""customer_id"",
    |      ""type"": ""string""
    |    },
    |    {
    |      ""name"": ""order_date"",
    |      ""type"": ""long"",
    |      ""logicalType"": ""timestamp-millis""
    |    },
    |    {
    |      ""name"": ""items"",
    |      ""type"": {
    |        ""type"": ""array"",
    |        ""items"": {
    |          ""type"": ""record"",
    |          ""name"": ""order_item"",
    |          ""fields"": [
    |            {
    |              ""name"": ""product_id"",
    |              ""type"": ""string""
    |            },
    |            {
    |              ""name"": ""quantity"",
    |              ""type"": ""double""
    |            },
    |            {
    |              ""name"": ""price"",
    |              ""type"": ""double""
    |            }
    |          ]
    |        }
    |      }
    |    },
    |    {
    |      ""name"": ""total_amount"",
    |      ""type"": ""double""
    |    },
    |    {
    |      ""name"": ""source_system"",
    |      ""type"": ""string"",
    |      ""default"": ""order-service""
    |    }
    |  ]
    |}";

    Результат = Компонента.СохранитьСхемуAVRO(ИмяСхемы, СхемаJSON);

    Если Не Результат Тогда
        ВызватьИсключение "Ошибка инициализации AVRO схемы: "
            + Компонента.ПрочитатьСообщениеОбОшибке();
    КонецЕсли;

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

Процедура ИнициализацияСхемыProtobuf_Статус(Компонента)

    ИмяСхемы = "OrderProcessingStatus";

    СхемаProto = "
    |syntax = ""proto3"";
    |
    |message OrderProcessingStatus {
    |  string order_id = 1;
    |  string status = 2;              // RESERVED, CONFIRMED, REJECTED, SHIPPED
    |  int64 processed_at = 3;         // Unix timestamp в миллисекундах
    |  string processed_by = 4;        // Идентификатор 1С инстанса
    |  repeated ReservationItem reservations = 5;
    |  string rejection_reason = 6;    // Причина отказа (если status = REJECTED)
    |  double total_reserved_amount = 7;
    |}
    |
    |message ReservationItem {
    |  string product_id = 1;
    |  string warehouse_id = 2;
    |  double quantity = 3;
    |  double reserved_amount = 4;
    |}
    |";

    Результат = Компонента.СохранитьСхемуProtobuf(ИмяСхемы, СхемаProto);

    Если Не Результат Тогда
        ВызватьИсключение "Ошибка инициализации Protobuf схемы: "
            + Компонента.ПрочитатьСообщениеОбОшибке();
    КонецЕсли;

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

Процедура ОбработкаЗаказовИзKafka_ExactlyOnce()

    // Инициализация компоненты
    Компонента = Новый("AddIn.Integration.simpleKafka1C");

    // Загружаем схемы
    ИнициализацияСхемыAVRO_Заказ(Компонента);
    ИнициализацияСхемыProtobuf_Статус(Компонента);

    // Настраиваем consumer для Exactly-Once
    ГруппаПотребителей = "1c-order-processor";
    Компонента.УстановитьПараметр("group.id", ГруппаПотребителей );
    Компонента.УстановитьПараметр("auto.offset.reset", "earliest");

    // ВАЖНО: Отключаем автокоммит offset - будем управлять вручную через транзакции
    Компонента.УстановитьПараметр("enable.auto.commit", "false");

    // Настройка для чтения только committed сообщений (для полной изоляции)
    Компонента.УстановитьПараметр("isolation.level", "read_committed");

    // Инициализируем consumer
    АдресБрокера = "kafka-cluster.company.local:9092";
    Компонента.ИнициализироватьКонсьюмера(АдресБрокера);

    // Инициализируем ТРАНЗАКЦИОННОГО producer
    // Уникальный ID для каждого экземпляра 1С (при перезапуске используем тот же ID)
    ИдентификаторТранзакции = "1c-order-processor-instance-01";

    РезультатИнициализации = Компонента.ИнициализироватьТранзакционногоПродюсера(
        АдресБрокера,
        ИдентификаторТранзакции
    );

    Если Не РезультатИнициализации Тогда
        ВызватьИсключение "Ошибка инициализации транзакционного продюсера: "
            + Компонента.ПолучитьСообщениеОбОшибке();
    КонецЕсли;

    // Подписываемся на топик с новыми заказами (от Order Service в AVRO)
    ТопикВход = "orders.new";
    Компонента.Подписаться(ТопикВход);

    Сообщить("Запущена обработка заказов из топика: " + ТопикВход);

    // Топик для отправки статусов в Protobuf
    ТопикВыход = "orders.processing.status";

    // Счётчики для статистики
    КоличествоОбработано = 0;
    КоличествоПодтверждено = 0;
    КоличествоОтклонено = 0;

    // Основной цикл обработки
    Пока Истина Цикл

        Попытка
            // Читаем сообщение из Kafka (таймаут 10 секунд)
            Если Компонента.ПрочитатьСообщение(10000) Тогда

                // *** НАЧИНАЕМ ТРАНЗАКЦИЮ KAFKA для Exactly-Once ***
                Компонента.НачатьТранзакцию();

                Попытка
                    // Получаем AVRO данные
                    ДанныеAVRO = Компонента.ПолучитьДанныеСообщения(Истина); // Истина = бинарные данные
                    ТопикСообщения = Компонента.ПолучитьТопикСообщения();
                    ПартицияСообщения = Компонента.ПолучитьРазделСообщения();
                    ОфсетСообщения = Компонента.ПолучитьСмещениеСообщения();

                    // Декодируем AVRO в JSON
                    ДанныеJSON = Компонента.ДекодироватьСообщениеAVRO(
                        ДанныеAVRO,
                        "order_event",
                        Истина
                    );

                    Если ПустаяСтрока(ДанныеJSON) Тогда
                        ВызватьИсключение "Ошибка декодирования AVRO: "
                            + Компонента.ПолучитьСообщениеОбОшибке();
                    КонецЕсли;

                    // Парсим JSON
                    ЧтениеJSON = Новый ЧтениеJSON;
                    ЧтениеJSON.УстановитьСтроку(ДанныеJSON);
                    ДанныеЗаказа = ПрочитатьJSON(ЧтениеJSON);
                    ЧтениеJSON.Закрыть();

                    // Обрабатываем заказ в 1С
                    СтатусОбработки = ОбработатьЗаказВ1С(ДанныеЗаказа);

                    // Формируем статус для отправки в Protobuf
                    СтатусJSON = СформироватьСтатусJSON(СтатусОбработки);

                    // Преобразуем в Protobuf
                    Результат = Компонента.ПреобразоватьВФорматProtobuf(
                        СтатусJSON,
                        "OrderProcessingStatus"
                    );

                    Если Не Результат Тогда
                        ВызватьИсключение "Ошибка преобразования в Protobuf: "
                            + Компонента.ПрочитатьСообщениеОбОшибке();
                    КонецЕсли;

                    // Отправляем статус в Kafka (Protobuf)
                    КлючСообщения = СтатусОбработки.ИдентификаторЗаказа;
                    РезультатОтправки = Компонента.ОтправитьСообщениеProtobuf(
                        ТопикВыход,
                        -1, // Автоматический выбор партиции
                        КлючСообщения
                    );

                    Если РезультатОтправки = -1 Тогда
                        ВызватьИсключение "Ошибка отправки Protobuf: "
                            + Компонента.ПрочитатьСообщениеОбОшибке();
                    КонецЕсли;

                    // *** КРИТИЧНО: Сохраняем offset в транзакцию ***
                    // Формируем JSON с информацией об офсете (+1, т.к. фиксируем следующий офсет для чтения)
                    ОфсетыJSON = СтрШаблон(
                        "[{""topic"": ""%1"", ""partition"": %2, ""offset"": %3}]",
                        ТопикСообщения,
                        ПартицияСообщения,
                        ОфсетСообщения + 1
                    );
                    // Это гарантирует, что offset будет зафиксирован только вместе с отправленным сообщением
                    Компонента.ОтправитьОфсетыВТранзакцию(ОфсетыJSON, ГруппаПотребителей);

                    // *** ФИКСИРУЕМ ТРАНЗАКЦИЮ KAFKA ***
                    // Атомарно фиксируются: отправленное сообщение + offset прочитанного сообщения
                    Компонента.ЗафиксироватьТранзакцию();

                    // Статистика (только после успешной фиксации)
                    КоличествоОбработано = КоличествоОбработано + 1;

                    Если СтатусОбработки.Статус = "CONFIRMED" Тогда
                        КоличествоПодтверждено = КоличествоПодтверждено + 1;
                    ИначеЕсли СтатусОбработки.Статус = "REJECTED" Тогда
                        КоличествоОтклонено = КоличествоОтклонено + 1;
                    КонецЕсли;

                    // Логируем каждые 100 заказов
                    Если КоличествоОбработано % 100 = 0 Тогда
                        Сообщить(СтрШаблон(
                            "Обработано заказов: %1 (подтверждено: %2, отклонено: %3)",
                            КоличествоОбработано,
                            КоличествоПодтверждено,
                            КоличествоОтклонено
                        ));
                    КонецЕсли;

                Исключение
                    // *** ОТКАТЫВАЕМ ТРАНЗАКЦИЮ KAFKA при любой ошибке ***
                    // Сообщение будет прочитано заново при следующей итерации
                    Компонента.ОтменитьТранзакцию();
                    ВызватьИсключение;
                КонецПопытки;

            Иначе
                // Таймаут - сообщений нет, небольшая пауза
                // В production здесь можно проверять условие остановки обработки
            КонецЕсли;

        Исключение
            // Логируем ошибку, но продолжаем обработку
            ТекстОшибки = ОписаниеОшибки();
            Сообщить("ОШИБКА: " + ТекстОшибки, СтатусСообщения.Важное);

            // В production здесь можно отправлять ошибку в систему мониторинга
            // или в Dead Letter Queue
        КонецПопытки;

    КонецЦикла;

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

Функция ОбработатьЗаказВ1С(ДанныеЗаказа)

    // Структура для возврата статуса
    Статус = Новый Структура;
    Статус.Вставить("ИдентификаторЗаказа", ДанныеЗаказа["order_id"][0]);
    Статус.Вставить("ВремяОбработки", ТекущаяУниверсальнаяДатаВМиллисекундах());
    Статус.Вставить("ОбработалСистема", "1C-ERP-Instance-01");
    Статус.Вставить("Резервирования", Новый Массив);
    Статус.Вставить("СуммаРезерва", 0);

    Попытка
        // Начинаем транзакцию в 1С
        НачатьТранзакцию();

        Попытка
            // Проверяем остатки и резервируем товары
            МассивПозиций = ДанныеЗаказа["items"][0]; // AVRO возвращает массивы в формате columnar

            ВсеТоварыДоступны = Истина;
            ОбщаяСуммаРезерва = 0;

            Для Индекс = 0 По МассивПозиций.Количество() - 1 Цикл

                ИдентификаторТовара = ДанныеЗаказа["items"][0]["product_id"][Индекс];
                Количество = ДанныеЗаказа["items"][0]["quantity"][Индекс];
                Цена = ДанныеЗаказа["items"][0]["price"][Индекс];

                // Находим номенклатуру
                Номенклатура = Справочники.Номенклатура.ПолучитьСсылку(
                    Новый УникальныйИдентификатор(ИдентификаторТовара)
                );

                // Проверяем остаток (упрощённая логика)
                Остаток = ПолучитьОстатокНоменклатуры(Номенклатура);

                Если Остаток >= Количество Тогда
                    // Резервируем товар
                    РезервТовар = РезервироватьТовар(Номенклатура, Количество);

                    // Добавляем в массив резервирований
                    СтруктураРезерв = Новый Структура;
                    СтруктураРезерв.Вставить("product_id", ИдентификаторТовара);
                    СтруктураРезерв.Вставить("warehouse_id", Строка(РезервТовар.Склад.УникальныйИдентификатор()));
                    СтруктураРезерв.Вставить("quantity", Количество);
                    СтруктураРезерв.Вставить("reserved_amount", Количество * Цена);

                    Статус.Резервирования.Добавить(СтруктураРезерв);
                    ОбщаяСуммаРезерва = ОбщаяСуммаРезерва + (Количество * Цена);
                Иначе
                    // Недостаточно товара
                    ВсеТоварыДоступны = Ложь;
                    Статус.Вставить("ПричинаОтказа", СтрШаблон(
                        "Недостаточно товара %1. Требуется: %2, доступно: %3",
                        Номенклатура,
                        Количество,
                        Остаток
                    ));
                    Прервать;
                КонецЕсли;

            КонецЦикла;

            Если ВсеТоварыДоступны Тогда
                // Фиксируем транзакцию
                ЗафиксироватьТранзакцию();

                Статус.Вставить("Статус", "CONFIRMED");
                Статус.Вставить("СуммаРезерва", ОбщаяСуммаРезерва);
                Статус.Вставить("ПричинаОтказа", "");

                Сообщить(СтрШаблон(
                    "Заказ %1 подтверждён, зарезервировано на сумму: %2 руб.",
                    Статус.ИдентификаторЗаказа,
                    Формат(ОбщаяСуммаРезерва, "ЧЦ=15; ЧДЦ=2")
                ));
            Иначе
                // Откатываем транзакцию
                ОтменитьТранзакцию();

                Статус.Вставить("Статус", "REJECTED");
                Статус.Резервирования.Очистить();
            КонецЕсли;

        Исключение
            ОтменитьТранзакцию();
            ВызватьИсключение;
        КонецПопытки;

    Исключение
        Статус.Вставить("Статус", "REJECTED");
        Статус.Вставить("ПричинаОтказа", "Внутренняя ошибка обработки: " + КраткоеПредставлениеОшибки(ИнформацияОбОшибке()));
        Статус.Резервирования.Очистить();

        Сообщить(СтрШаблон(
            "Заказ %1 отклонён: %2",
            Статус.ИдентификаторЗаказа,
            Статус.ПричинаОтказа
        ), СтатусСообщения.Важное);
    КонецПопытки;

    Возврат Статус;

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

Функция СформироватьСтатусJSON(СтатусОбработки)

    // Формируем JSON для Protobuf
    СтруктураJSON = Новый Структура;
    СтруктураJSON.Вставить("order_id", СтатусОбработки.ИдентификаторЗаказа);
    СтруктураJSON.Вставить("status", СтатусОбработки.Статус);
    СтруктураJSON.Вставить("processed_at", СтатусОбработки.ВремяОбработки);
    СтруктураJSON.Вставить("processed_by", СтатусОбработки.ОбработалСистема);
    СтруктураJSON.Вставить("reservations", СтатусОбработки.Резервирования);
    СтруктураJSON.Вставить("rejection_reason", СтатусОбработки.Получить("ПричинаОтказа"));
    СтруктураJSON.Вставить("total_reserved_amount", СтатусОбработки.СуммаРезерва);

    ЗаписьJSON = Новый ЗаписьJSON;
    ЗаписьJSON.УстановитьСтроку();
    ЗаписатьJSON(ЗаписьJSON, СтруктураJSON);
    СтрокаJSON = ЗаписьJSON.Закрыть();

    Возврат СтрокаJSON;

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

Функция ТекущаяУниверсальнаяДатаВМиллисекундах()
    Возврат (ТекущаяУниверсальнаяДата() - Дата(1970, 1, 1)) * 1000;
КонецФункции

// Упрощённые вспомогательные функции (в реальности сложнее)
Функция ПолучитьОстатокНоменклатуры(Номенклатура)
    // Здесь запрос к регистру остатков
    Возврат 100; // Для примера
КонецФункции

Функция РезервироватьТовар(Номенклатура, Количество)
    // Здесь создание записи регистра резервов
    Результат = Новый Структура;
    // Заполнение результата
    Возврат Результат;
КонецФункции