Вступление

В интеграционных решениях нередко возникает ситуация, когда данные корректны по смыслу, но не соответствуют формату системы-получателя. Одна система передаёт дату как 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

email

В любом регистре, с пробелами

Нижний регистр, корректный формат

Решение собираем из четырёх частей: тип «сырого» запроса → функция нормализации → валидация → ответ 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

email

bad@

400

email

Валидация

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_Норм_Документ

Строгий формат для получателя

Я считаю, что задачи нормализации данных должна брать на себя именно интеграционная платформа, особенно в условиях разнородного ИТ-ландшафта, где каждая система использует собственные форматы.

Централизация этих правил позволяет избежать многочисленных доработок систем-отправителей, упростить сопровождение интеграций и снизить нагрузку на техническую поддержку. Вместо поиска причин ошибок и внесения изменений в каждой прикладной системе специалисты получают единый механизм управления преобразованием и контролем качества передаваемых данных. Это делает интеграционный контур более управляемым, а подключение новых систем – менее трудоемким.

Отправителям не нужно дорабатывать свои системы, а получатель всегда видит один формат. Новая система подключается строкой в таблице правил. А всё, что нельзя разобрать однозначно, либо решается явным правилом с записью в журнал, либо возвращается отправителю как ошибка.

Расскажите в комментариях, какой самый странный формат даты или суммы вам присылали.

Источники

Документация:

Статьи Хабр: