Вступление

В интеграционных решениях нередко возникает ситуация, когда данные корректны по смыслу, но не соответствуют формату системы-получателя. Одна система передаёт дату как 23.10.2026, другая — 2026-10-23, третья — 20261023. Одна и та же дата скрывается за разными масками представления. Аналогичные различия встречаются при передаче чисел, телефонов и логических признаков.
В результате отправитель считает запрос корректным, получатель его отклоняет, а специалисты сопровождения выясняют причины. Хотя проблема зачастую не в самих данных, а в способе их представления.
Когда в интеграционном контуре взаимодействуют десятки систем, не всегда рационально требовать от каждой соблюдения формата получателя. Гораздо удобнее централизовать преобразование данных на уровне интеграционной платформы: приводить их к единому стандарту и только затем выполнять валидацию.
В предыдущей статье мы разобрали валидацию входящих JSON-сообщений в DATAREON Platform. Теперь сорвем с данных маски и выясним, почему одинаковые на вид значения не всегда означают одно и то же.
На практическом примере покажем универсальный механизм нормализации, разберем неоднозначные форматы и особенности, обнаруженные при тестировании DATAREON Platform 3.2.1.
Разберём на примере:
Почему на входе все поля — строки, и строгие типы появляются только на выходе
Одну общую функцию нормализации, в которой у каждой системы могут быть свои правила
Что делать с неоднозначными значениями вроде 10/11/2026 и 1,500;
Как вернуть отправителю все проблемные поля одним ответом.
Сценарий
Представим типичную интеграцию: несколько систем отправляют в DATAREON Platform документы для одного получателя. Учётная система на 1С (ERP_1C), американская CRM (CRM_US), европейский склад (WMS_EU). Каждая пишет даты, суммы и телефоны по-своему, и переделывать их никто не будет.
Так выглядит документ от 1С:
{ "source": "erp_1c", "docNumber": " doc-001 ", "docDate": "23.10.2026", "amount": "1 500,50", "counterparty": " ООО «Ёлочка» ", "inn": "4345 000001", "phone": "8 (912) 345-67-89", "isUrgent": "да", "email": " Info@Elochka.RU " }
Что может прийти в каждом поле от разных отправителей, и чего ждёт получатель:
Поле | Что приходит | Что ждёт получатель |
source | erp_1c, CRM_US, wms_eu | Код в верхнем регистре |
docNumber | С пробелами, в любом регистре | Верхний регистр, обязательно |
docDate | 23.10.2026, 23/10/2026, 23102026, 20261023, 23.10.26, 2026-10-23T14:30:00 | YYYY-MM-DD, дата существует, обязательно |
amount | 1 500,50, 1,500.50, 1.500,50, 1500, 12,5 | Число с точкой и двумя знаками, больше нуля |
counterparty | Лишние пробелы, буква «ё» | Очищенная строка, обязательно |
inn | 4345 000001 | 10 или 12 цифр, обязательно |
phone | 8 (912) 345-67-89, +7 912 345-67-89, 9123456789 | +7XXXXXXXXXX |
isUrgent | да/нет, Y/N, 1/0, true/false | Boolean |
В любом регистре, с пробелами | Нижний регистр, корректный формат |
Решение собираем из четырёх частей: тип «сырого» запроса → функция нормализации → валидация → ответ 200 с нормализованными данными или 400 со списком полей.
Почему на входе строки, а не типы
В прошлой статье я говорил типизировать поля: DateTime, Int, Decimal. Здесь же тип входящего запроса намеренно строковый, и это не противоречие.
Если поле имеет тип DateTime или Decimal, платформа разбирает JSON ещё до кода обработчика. Значение 23.10.2026 в DateTime или 1 500,50 в Decimal сразу отклоняется ответом 400. Нормализовать его становится уже негде.
Поэтому типов два:
Тип | Назначение | Поля |
DT_RestAPI_СырыеДанныеДокумента | Принимает всё, что прислал отправитель | Все String, Nullable |
DT_Норм_Документ | Строгий формат получателя | С форматом и типами, isUrgent — Boolean |
Строгость не исчезает, а переезжает на выход. Отправитель может писать как привык, а получатель всегда видит одно и то же.
Шаг 1. Тип «сырого» запроса
В Центре настройки создаём тип DT_RestAPI_СырыеДанныеДокумента. Все поля — String без ограничения длины, с флагом Nullable: source, docNumber, docDate, amount, counterparty, inn, phone, isUrgent, email.
Строковое поле принимает не только строки. На стенде я передавал в них числа (1500.5) и булевы (true) без кавычек — платформа превращает их в строку. Значит, отправителям не нужно подстраиваться даже под тип JSON-значения.

Шаг 2. Тип нормализованных данных
Тип DT_Норм_Документ описывает формат получателя. Он же служит типом ответа обработчика.
Поле | Тип | Формат |
source, docNumber, counterparty, inn, email | String | Очищенная строка |
docDate | String(10) | YYYY-MM-DD |
amount | String | 1500.50 — точка, два знака |
phone | String | +7XXXXXXXXXX |
isUrgent | Boolean | true / false |
Длины строк заданы под формат получателя: docDate - 10, inn и phone - 12, amount - 30.
Почему сумма строкой, а не Decimal, расскажу в разделе про неочевидное поведение.

Шаг 3. Функция FN_НормализацияДанных
Вся нормализация живёт в одной функции. Её можно вызывать из процессов всех отправителей, и правила задаются один раз.
Переменная | Тип | Направление | Зачем |
СырыеДанные | DT_RestAPI_СырыеДанныеДокумента | Вход | Запрос отправителя |
НормДанные | DT_Норм_Документ | Выход | Данные в формате получателя |
ОшибкиНормализации | String, Nullable | Выход | Поля с нераспознанным форматом, через запятую |
ПримененныеПравила | String, Nullable | Выход | Пояснения по неоднозначным значениям, для журнала |
Переменные функции не должны называться так же, как переменные вызывающего процесса, иначе при вызове возникает конфликт имён.
Поэтому входящий запрос внутри функции называется СырыеДанные, а в процессе СырыйДокумент

Правила нормализации
Данные | Правило |
Строки | Обрезка пробелов, схлопывание повторных, неразрывный пробел → обычный, ё → е. Номер документа — в верхний регистр, email — в нижний |
Даты | ISO (2026-10-23, с временем) — как есть. 8 цифр: сначала YYYYMMDD (год 1900–2100), иначе DDMMYYYY. С разделителями: если одно из чисел больше 12, порядок однозначен; иначе решает правило отправителя. Двузначный год → 20XX. Несуществующая дата (31.02.2026) — ошибка |
Числа | Пробелы и апострофы удаляются. Есть и точка, и запятая → десятичный тот, что правее. Разделитель повторяется (1.500.000) → это разряды. Один разделитель и ровно 3 цифры после (1,500) → решает правило отправителя. Результат — 0.00 |
Телефон | Только цифры; 11 цифр на 7/8 или 10 цифр на 9 → +7XXXXXXXXXX, иначе ошибка |
Булевы | 1, true, y, yes, да, д, истина, + → true; 0, false, n, no, нет, н, ложь, - → false; пусто → false; другое — ошибка |
ИНН | Только цифры |
Правила по системе-отправителю
Как понимать 10/11/2026 и 1,500, зависит от того, кто прислал данные. Для американской CRM это 11 октября и полторы тысячи, для 1С — 10 ноября и полтора. Поэтому в начале функции — таблица правил:
var source = (СырыеДанные.source ?? "").Trim().ToUpperInvariant(); var dateOrder = "DMY"; // порядок для 10/11/2026: DMY по умолчанию, MDY — американский формат var decimalSep = ','; // десятичный разделитель для 1,500 / 1.500 switch (source) { case "CRM_US": dateOrder = "MDY"; decimalSep = '.'; break; case "WMS_EU": dateOrder = "DMY"; decimalSep = ','; break; }
Новая система со своим форматом — это одна строка case. Если отправителей много, правила можно вынести в глобальные константы или справочник.
Мы могли бы написать отдельный обработчик для каждого отправителя, но тогда одно и то же преобразование пришлось бы поддерживать в нескольких местах. Поэтому вынесли общую логику в функцию, а различия между отправителями оставили в параметрах правил.
В коде ниже сначала определяем источник данных, затем применяем соответствующие правила нормализации. Если значение распознать не удалось, функция не пытается его исправить произвольно, а сохраняет информацию об ошибке для следующего этапа.
Код функции:
var ci = System.Globalization.CultureInfo.InvariantCulture; var errors = new List<string>(); var notes = new List<string>(); var source = (СырыеДанные.source ?? "").Trim().ToUpperInvariant(); var dateOrder = "DMY"; var decimalSep = ','; switch (source) { case "CRM_US": dateOrder = "MDY"; decimalSep = '.'; break; case "WMS_EU": dateOrder = "DMY"; decimalSep = ','; break; } // Строки: trim, лишние пробелы, неразрывный пробел, ё -> е Func<string, string> CleanText = s => { if (s == null) return ""; var t = System.Text.RegularExpressions.Regex.Replace(s.Replace((char)160, ' '), @"\s+", " ").Trim(); return t.Replace('ё', 'е').Replace('Ё', 'Е'); }; // Дата -> YYYY-MM-DD Func<string, string, string> NormDate = (field, raw) => { var s = CleanText(raw); if (s == "") return ""; DateTime d; if (DateTime.TryParseExact(s, new[] { "yyyy-MM-dd", "yyyy-MM-ddTHH:mm:ss", "yyyy-MM-ddTHH:mm:ssK", "yyyy-MM-dd HH:mm:ss" }, ci, System.Globalization.DateTimeStyles.None, out d)) return d.ToString("yyyy-MM-dd"); if (System.Text.RegularExpressions.Regex.IsMatch(s, @"^\d{8}$")) { // 8 цифр: сначала YYYYMMDD, затем DDMMYYYY if (DateTime.TryParseExact(s, "yyyyMMdd", ci, System.Globalization.DateTimeStyles.None, out d) && d.Year >= 1900 && d.Year <= 2100) return d.ToString("yyyy-MM-dd"); if (DateTime.TryParseExact(s, "ddMMyyyy", ci, System.Globalization.DateTimeStyles.None, out d)) return d.ToString("yyyy-MM-dd"); errors.Add(field); return ""; } var m = System.Text.RegularExpressions.Regex.Match(s, @"^(\d{1,2})[./\- ](\d{1,2})[./\- ](\d{2}|\d{4})$"); if (m.Success) { int a = int.Parse(m.Groups[1].Value), b = int.Parse(m.Groups[2].Value), y = int.Parse(m.Groups[3].Value); if (y < 100) y += 2000; int day, month; if (a > 12 && b <= 12) { day = a; month = b; } else if (b > 12 && a <= 12) { day = b; month = a; } else { // Неоднозначно (10/11/2026): решает правило системы-отправителя if (dateOrder == "MDY") { month = a; day = b; } else { day = a; month = b; } if (a != b) notes.Add($"{field}: '{s}' разобрана как {dateOrder} (правило системы {source})"); } if (month < 1 || month > 12 || day < 1 || day > DateTime.DaysInMonth(y, month)) { errors.Add(field); return ""; } return new DateTime(y, month, day).ToString("yyyy-MM-dd"); } errors.Add(field); return ""; }; // Число -> 1500.50 Func<string, string, string> NormNumber = (field, raw) => { var s = CleanText(raw).Replace(" ", "").Replace("'", ""); if (s == "") return ""; int lastDot = s.LastIndexOf('.'), lastComma = s.LastIndexOf(','); if (lastDot >= 0 && lastComma >= 0) { // Есть оба разделителя: десятичный — тот, что правее (1,500.50 / 1.500,50) char dec = lastDot > lastComma ? '.' : ','; char grp = dec == '.' ? ',' : '.'; s = s.Replace(grp.ToString(), "").Replace(dec, '.'); } else if (lastDot >= 0 || lastComma >= 0) { char sep = lastDot >= 0 ? '.' : ','; int count = s.Split(sep).Length - 1; int digitsAfter = s.Length - s.LastIndexOf(sep) - 1; if (count > 1) s = s.Replace(sep.ToString(), ""); // 1.500.000 -> разделитель разрядов else if (digitsAfter == 3) // 1,500 / 1.500 -> неоднозначно { if (sep == decimalSep) s = s.Replace(sep, '.'); else s = s.Replace(sep.ToString(), ""); notes.Add($"{field}: '{raw}' разобрано с десятичным разделителем '{decimalSep}' (правило системы {source})"); } else s = s.Replace(sep, '.'); } decimal value; if (!decimal.TryParse(s, System.Globalization.NumberStyles.AllowDecimalPoint | System.Globalization.NumberStyles.AllowLeadingSign, ci, out value)) { errors.Add(field); return ""; } return value.ToString("0.00", ci); }; // Телефон -> +7XXXXXXXXXX Func<string, string, string> NormPhone = (field, raw) => { var digits = System.Text.RegularExpressions.Regex.Replace(raw ?? "", @"\D", ""); if (digits == "") return ""; if (digits.Length == 11 && (digits[0] == '7' || digits[0] == '8')) return "+7" + digits.Substring(1); if (digits.Length == 10 && digits[0] == '9') return "+7" + digits; errors.Add(field); return ""; }; // Булево: да/нет, Y/N, 1/0, true/false Func<string, string, bool> NormBool = (field, raw) => { var s = CleanText(raw).ToLowerInvariant(); if (s == "") return false; if (new[] { "1", "true", "y", "yes", "да", "д", "истина", "+" }.Contains(s)) return true; if (new[] { "0", "false", "n", "no", "нет", "н", "ложь", "-" }.Contains(s)) return false; errors.Add(field); return false; }; НормДанные.source = source; НормДанные.docNumber = CleanText(СырыеДанные.docNumber).ToUpperInvariant(); НормДанные.docDate = NormDate("docDate", СырыеДанные.docDate); НормДанные.amount = NormNumber("amount", СырыеДанные.amount); НормДанные.counterparty = CleanText(СырыеДанные.counterparty); НормДанные.inn = System.Text.RegularExpressions.Regex.Replace(СырыеДанные.inn ?? "", @"\D", ""); НормДанные.phone = NormPhone("phone", СырыеДанные.phone); НормДанные.isUrgent = NormBool("isUrgent", СырыеДанные.isUrgent); НормДанные.email = CleanText(СырыеДанные.email).ToLowerInvariant(); ОшибкиНормализации = string.Join(",", errors); ПримененныеПравила = string.Join("; ", notes);
Функция не бросает исключений. Нераспознанное значение остаётся пустым, а имя поля попадает в ОшибкиНормализации. Решение «принять или отклонить» принимает следующий шаг — так отправитель увидит все проблемные поля за один запрос.
Шаг 4. Веб-обработчик
Запросы принимает внешняя система ExS_RestAPI с коннектором «Расширенный REST API» на localhost:8888.
В её настройках задан шаблон responseErrorSettings, собирающий ответ об ошибке из плейсхолдеров {errorCode}, {errorMessage}, {notValidFields}. (Его настройку рассматривали в прошлой статье Валидация JSON во входящих REST-запросах DATAREON Platform)

Создаём обработчик HND_RestAPI_ПриемДокумента_ToPlatform:
Настройка | Значение |
Метод и путь | POST /wiki/documents/normalize |
Флаг | «Ожидание ответа» |
Вкладка «В Platform» | СырыйДокумент — DT_RestAPI_СырыеДанныеДокумента |
Вкладка «Ответ» | НормализованныйДокумент — DT_Норм_Документ |
Проверок в обработчике нет: он только передаёт запрос в процесс.
RunMessage.SetBody(СырыйДокумент); Logger.Info($"POST /wiki/documents/normalize: source={СырыйДокумент.source}, docNumber={СырыйДокумент.docNumber}");

Шаг 5. Бизнес-процесс
Процесс BP_ПриемДокумента_RestAPI с флагом «Автозапуск» состоит из двух шагов: «Нормализация данных» → «Валидация и ответ». Переменные процесса:
Переменная | Тип |
СырыйДокумент | DT_RestAPI_СырыеДанныеДокумента (входное сообщение) |
Документ | DT_Норм_Документ |
Ошибки | String, Nullable |
Правила | String, Nullable |


5.1. Нормализация данных
Шаг «Выполнение функции» вызывает FN_НормализацияДанных.
Параметры связываем так:
Переменная функции | Переменная процесса |
СырыеДанные (вход) | СырыйДокумент |
НормДанные (выход) | Документ |
ОшибкиНормализации (выход) | Ошибки |
ПримененныеПравила (выход) | Правила |

5.2. Шаг «Алгоритм» — Валидация и ответ
Валидируем уже нормализованные данные: обязательность, длину ИНН, сумму больше нуля и формат email. Каждое поле попадает в одну из трёх групп: формат не распознан, не заполнено, недопустимое значение.
Ответ 400 из бизнес-процесса формируется свойствами сообщения-ответа:
Свойство | Куда попадает |
Dt_ResponseCode | HTTP-код ответа и {errorCode} |
Dt_ResponseMessage | {errorMessage} |
Dt_NotValidFields | {notValidFields} |
var badFormat = new List<string>((Ошибки ?? "").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)); var empty = new List<string>(); Action<string, string> Required = (name, value) => { if (string.IsNullOrEmpty(value) && !badFormat.Contains(name)) empty.Add(name); }; Required("docNumber", Документ.docNumber); Required("docDate", Документ.docDate); Required("amount", Документ.amount); Required("counterparty", Документ.counterparty); Required("inn", Документ.inn); var invalid = new List<string>(); if (Документ.inn != "" && Документ.inn.Length != 10 && Документ.inn.Length != 12) invalid.Add("inn"); if (Документ.amount != "" && decimal.Parse(Документ.amount, System.Globalization.CultureInfo.InvariantCulture) <= 0) invalid.Add("amount"); if (Документ.email != "" && !System.Text.RegularExpressions.Regex.IsMatch(Документ.email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$")) invalid.Add("email"); // Пояснения по неоднозначным значениям — в журнал if (!string.IsNullOrEmpty(Правила)) Logger.Info($"Документ {Документ.docNumber}: {Правила}"); var allFields = badFormat.Concat(empty).Concat(invalid).Distinct().ToList(); if (allFields.Count > 0) { var parts = new List<string>(); if (badFormat.Count > 0) parts.Add("не удалось распознать формат: " + string.Join(", ", badFormat)); if (empty.Count > 0) parts.Add("не заполнены: " + string.Join(", ", empty)); if (invalid.Count > 0) parts.Add("недопустимые значения: " + string.Join(", ", invalid)); var text = "Документ не принят — " + string.Join("; ", parts); var error = new Message(); error.SetProperty("Dt_ResponseCode", "400"); error.SetProperty("Dt_ResponseMessage", text); error.SetProperty("Dt_NotValidFields", string.Join(",", allFields)); error.SetBody(Newtonsoft.Json.JsonConvert.SerializeObject(new { message = text })); Transport.SendResponseMessage(error, InitMessage); Logger.Warning($"Документ {Документ.docNumber} от {Документ.source}: {text}"); return; } // Данные в формате получателя. В примере возвращаем их клиенту var response = new Message(); response.SetBody(Newtonsoft.Json.JsonConvert.SerializeObject(Документ)); Transport.SendResponseMessage(response, InitMessage);
В боевой интеграции после успешной валидации документ уходит получателю шагом «Отправка подписчику» или «Выполнение обработчика». Отправителю остаётся подтверждение.
Дальше включаем обработчик в систему, проверяем и применяем конфигурацию. На моём стенде обработчик начинал отвечать примерно через 40 секунд после применения.
Проверяем результат
Отправляем документ из сценария:
curl -X POST http://localhost:8888/wiki/documents/normalize \ -H "Content-Type: application/json" \ -d '{ "source": "erp_1c", "docNumber": " doc-001 ", "docDate": "23.10.2026", "amount": "1 500,50", "counterparty": " ООО «Ёлочка» ", "inn": "4345 000001", "phone": "8 (912) 345-67-89", "isUrgent": "да", "email": " Info@Elochka.RU " }'
Ответ 200 — все поля в формате получателя:
{ "source": "ERP_1C", "docNumber": "DOC-001", "docDate": "2026-10-23", "amount": "1500.50", "counterparty": "ООО «Елочка»", "inn": "4345000001", "phone": "+79123456789", "isUrgent": true, "email": "info@elochka.ru" }
Дальше менял по одному полю, остальные оставлял как в запросе выше (source erp_1c, если не указано другое). Всё проверено на стенде с DATAREON Platform 3.2.1.
# | Поле | Что передали | HTTP | Результат или notValidFields | Кто отклонил |
1 | docDate | 23/10/2026, 23102026, 20261023, 23.10.26, 2026-10-23T14:30:00 | 200 | 2026-10-23 | — |
2 | docDate | 10/11/2026, source ERP_1C | 200 | 2026-11-10 | — |
3 | docDate | 10/11/2026, source CRM_US | 200 | 2026-10-11 | — |
4 | docDate | 31.02.2026, вчера | 400 | docDate | Нормализация |
5 | amount | 1,500.50, 1.500,50 | 200 | 1500.50 | — |
6 | amount | 1 500 000 | 200 | 1500000.00 | — |
7 | amount | 1,500, source ERP_1C | 200 | 1.50 | — |
8 | amount | 1,500, source CRM_US | 200 | 1500.00 | — |
9 | amount | 1.500 / 12,5 | 200 | 1500.00 / 12.50 | — |
10 | amount | abc | 400 | amount | Нормализация |
11 | amount | -5 | 400 | amount | Валидация |
12 | phone | +7 912 345-67-89, 9123456789 | 200 | +79123456789 | — |
13 | phone | 12345 | 400 | phone | Нормализация |
14 | isUrgent | Y / TRUE / 0 | 200 | true / true / false | — |
15 | isUrgent | может быть | 400 | isUrgent | Нормализация |
16 | bad@ | 400 | Валидация | ||
17 | amount, docDate, inn | 1500.5, 20261023, 4345000001 числами без кавычек | 200 | Приняты как строки и нормализованы | — |
Что видно из таблицы:
Одна и та же строка 1,500 даёт 1.50 или 1500.00 — в зависимости от отправителя (строки 7 и 8). Без правил по системам одна из сумм была бы неверной в тысячу раз.
вчера и 31.02.2026 отклоняются, хотя поле заполнено. Нормализация не «угадывает», а считает ошибкой всё, что не поняла.
-5 — корректное число и проходит нормализацию. Отклоняет его бизнес-правило «сумма больше нуля».
Числа без кавычек в строковых полях не ломают разбор (строка 17).
Несколько ошибок в одном запросе
Самое интересное — запрос, в котором проблемы сразу в пяти полях:
{ "source": "ERP_1C", "docNumber": "", "docDate": "вчера", "amount": "-5", "counterparty": " ", "inn": "12345", "phone": "8 (912) 345-67-89", "isUrgent": "да", "email": "info@elochka.ru" }
Отправитель получает один ответ со всеми полями:
{ "errorCode": 400, "errorMessage": "Документ не принят — не удалось распознать формат: docDate; не заполнены: docNumber, counterparty; недопустимые значения: inn, amount", "notValidFields": "docDate,docNumber,counterparty,inn,amount" }
Поле | Группа ошибки | На каком этапе найдена |
docDate | Не удалось распознать формат | Функция нормализации |
docNumber, counterparty | Не заполнены | Валидация, проверка обязательности |
inn | Недопустимое значение: не 10 и не 12 цифр | Валидация |
amount | Недопустимое значение: не больше нуля | Валидация |
Поле docDate не попало в «не заполнены», хотя после нормализации оно пустое. Это делает проверка !badFormat.Contains(name): отправитель видит настоящую причину, а не две ошибки на одно поле.

Для неоднозначных значений в журнале сервиса обработки процессов в Центре мониторинга появляется пояснение: docDate: '10/11/2026' разобрана как MDY (правило системы CRM_US). Если получатель удивится дате, причина найдётся за минуту.

Что оказалось неочевидным
Три вещи, которые я выяснил на стенде во время настройки и тестирования кейса.
1. Неоднозначные значения не решаются кодом.
10/11/2026 и 1,500 нельзя разобрать «правильно», не зная отправителя. Правила для каждой системы нужно согласовать с её владельцем до запуска и вести в одном месте. Поэтому функция и пишет каждое такое решение в журнал.
2. Строковое поле принимает числа и булевы.
Если отправитель прислал "amount": 1500.5 без кавычек, в String-поле придёт строка 1500.5. Для нормализации это удобно: один код работает и со строками, и с JSON-числами.
3. Decimal в типе ответа.
Изначально я планировал использовать для суммы тип Decimal — после нормализации это казалось логичным решением. Однако при тестировании на DATAREON Platform 3.2.1 обнаружилось неожиданное поведение: при использовании Decimal в типе ответа Расширенного REST API соединение с клиентом обрывалось.
В рамках примера пришлось изменить решение: сохранять сумму в строковом поле, предварительно приводя её к строго заданному формату 1500.50.
Это не отменяет проверки числового значения, но позволяет обойти обнаруженное ограничение версии 3.2.1.
Итоги
Нормализация ставится перед валидацией, а не вместо неё. Решение состоит из пяти частей:
Часть | Роль |
DT_RestAPI_СырыеДанныеДокумента | Принимает всё без ошибок разбора JSON |
FN_НормализацияДанных | Приводит к единому формату, учитывая правила отправителя |
Шаг «Валидация и ответ» | Проверяет бизнес-правила на уже чистых данных |
Dt_ResponseCode, Dt_NotValidFields | Отдают отправителю 400 со всеми полями сразу |
DT_Норм_Документ | Строгий формат для получателя |
Я считаю, что задачи нормализации данных должна брать на себя именно интеграционная платформа, особенно в условиях разнородного ИТ-ландшафта, где каждая система использует собственные форматы.
Централизация этих правил позволяет избежать многочисленных доработок систем-отправителей, упростить сопровождение интеграций и снизить нагрузку на техническую поддержку. Вместо поиска причин ошибок и внесения изменений в каждой прикладной системе специалисты получают единый механизм управления преобразованием и контролем качества передаваемых данных. Это делает интеграционный контур более управляемым, а подключение новых систем – менее трудоемким.
Отправителям не нужно дорабатывать свои системы, а получатель всегда видит один формат. Новая система подключается строкой в таблице правил. А всё, что нельзя разобрать однозначно, либо решается явным правилом с записью в журнал, либо возвращается отправителю как ошибка.
Расскажите в комментариях, какой самый странный формат даты или суммы вам присылали.
Источники
Документация:
Статьи Хабр:
Валидация JSON во входящих REST-запросах DATAREON Platform — предыдущая статья цикла
Глобальные константы: как убрать хардкод из интеграций — если правила по отправителям захочется вынести из кода
