Skip to content
The Chat Archive
gpt-4o-mini-2024-07-18· OpenAI WildChat-4.8M (AI2)

раздели на отдельные колонки в бд Успешный ответ { "tariffs": [{ "id": 1, "name":…

  1. User

    раздели на отдельные колонки в бд Успешный ответ {

    "tariffs": [{
    
            "id": 1,
    
            "name": "Black",
    
            "icon": {
    
                "name": "x24_star",
    
                "color": "#000000",
    
                "backgroundColors": [
    
                    "#FFFFFF",
    
                    "#D6D7D8",
    
                    "#AFB1B3",
    
                    "#97999C",
    
                    "#8F9194",
    
                    "#AFB1B4",
    
                    "#B3B5B8",
    
                    "#DADBDD",
    
                    "#FFFFFF",
    
                    "#F2F2F3",
    
                    "#CBCCCE",
    
                    "#BCBEC0"
    
                ]
    
            },
    
            "isCurrent": true,
    
            "canBeChage": false,
    
            "price": {
    
                "amount": 0,
    
                "currency": "USD",
    
                "currencyLang": "$",
    
                "period": "month",
    
                "periodLang": "мес"
    
            },
    
            "backgroundColors": [
    
                "#1D1F24",
    
                "#31353D"
    
            ],
    
            "conditions": [{
    
                "title": "Платное обслуживание ",
    
                "description": "*0 $ При среднем остатке 2500 $\nв месяц и sales операциях 1500 $"
    
            }],
    
            "header": [
    
                "Операции"
    
            ],
    
            "pages": [{
    
                "name": "Операции",
    
                "info": [{
    
                        "title": "Обслуживание именной и неименной карты ежемесячно",
    
                        "subtitle": "25$*\n\n0$ При среднем остатке 2500$ в месяц и sales операциях 1500$"
    
                    },
    
                    {
    
                        "title": "Перевыпуск карты",
    
                        "subtitle": "Бесплатно"
    
                    },
    
                    {
    
                        "title": "Восстановление утраченного \nPIN - кода посредством IVR ",
    
                        "subtitle": "Бесплатно"
    
                    },
    
                    {
    
                        "title": "Снятие наличных в банкоматах",
    
                        "subtitle": "1000$ бесплатно, свыше — 1,5%"
    
                    },
    
                    {
    
                        "title": "Оплата товаров и услуг",
    
                        "subtitle": "Без комиссии"
    
                    }
    
                ]
    
            }],
    
            "termsOfServiceUrl": "https://example.ru"
    
        },
    
  2. Assistant

    Для разделения приведенных данных JSON на отдельные колонки в базе данных, можно создать несколько таблиц. Я предлагаю следующую структуру для хранения информации о тарифах:

    Таблица tariffs

    КолонкаТип данных
    idINT (Primary Key)
    nameVARCHAR(255)
    isCurrentBOOLEAN
    canBeChageBOOLEAN
    price_amountDECIMAL(10, 2)
    price_currencyVARCHAR(10)
    price_currencyLangVARCHAR(10)
    price_periodVARCHAR(20)
    price_periodLangVARCHAR(20)
    termsOfServiceUrlVARCHAR(255)

    Таблица tariff_icons

    КолонкаТип данных
    idINT (Primary Key)
    tariff_idINT (foreign key to tariffs.id)
    icon_nameVARCHAR(255)
    icon_colorVARCHAR(7)

    Таблица tariff_background_colors

    КолонкаТип данных
    idINT (Primary Key)
    tariff_idINT (foreign key to tariffs.id)
    background_colorVARCHAR(7)

    Таблица tariff_conditions

    КолонкаТип данных
    idINT (Primary Key)
    tariff_idINT (foreign key to tariffs.id)
    titleVARCHAR(255)
    descriptionTEXT

    Таблица tariff_pages

    КолонкаТип данных
    idINT (Primary Key)
    tariff_idINT (foreign key to tariffs.id)
    nameVARCHAR(255)

    Таблица page_info

    КолонкаТип данных
    idINT (Primary Key)
    page_idINT (foreign key to tariff_pages.id)
    titleVARCHAR(255)
    subtitleTEXT

    Пример вставки данных в таблицы

    1. Вставляем данные о тарифе в tariffs:

      INSERT INTO tariffs (id, name, isCurrent, canBeChage, price_amount, price_currency, price_currencyLang, price_period, price_periodLang, termsOfServiceUrl)
      VALUES (1, 'Black', true, false, 0, 'USD', '$', 'month', 'мес', 'https://example.ru');
      
    2. Вставляем данные об иконе в tariff_icons:

      INSERT INTO tariff_icons (tariff_id, icon_name, icon_color)
      VALUES (1, 'x24_star', '#000000');
      
    3. Вставляем данные о цветах фона в tariff_background_colors:

      INSERT INTO tariff_background_colors (tariff_id, background_color)
      VALUES (1, '#1D1F24'), (1, '#31353D');
      
    4. Вставляем условия в tariff_conditions:

      INSERT INTO tariff_conditions (tariff_id, title, description)
      VALUES (1, 'Платное обслуживание', '*0 $ При среднем остатке 2500 $\nв месяц и sales операциях 1500 $');
      
    5. Вставляем страницы в tariff_pages:

      INSERT INTO tariff_pages (tariff_id, name)
      VALUES (1, 'Операции');
      
    6. Вставляем информацию о страницах в page_info:

      INSERT INTO page_info (page_id, title, subtitle)
      VALUES (1, 'Обслуживание именной и неименной карты ежемесячно', '25$*\n\n0$ При среднем остатке 2500$ в месяц и sales операциях 1500$'),
             (1, 'Перевыпуск карты', 'Бесплатно'),
             (1, 'Восстановление утраченного \nPIN - кода посредством IVR', 'Бесплатно'),
             (1, 'Снятие наличных в банкоматах', '1000$ бесплатно, свыше — 1,5%'),
             (1, 'Оплата товаров и услуг', 'Без комиссии');
      

    Эта структура позволит эффективно хранить и извлекать данные о тарифах, их иконках, цветах и условиях.

  3. User

    это одна таблица должна быть

  4. Assistant

    Если все данные необходимо хранить в одной таблице, то можем создать одну таблицу с колонками, отражающими все необходимые атрибуты тарифа и прочую информацию. Обратите внимание, что это может привести к значительному количеству пустых или повторяющихся полей, но все равно можно реализовать в одной таблице.

    Структура таблицы tariffs

    CREATE TABLE tariffs (
        id INT PRIMARY KEY,
        name VARCHAR(255),
        icon_name VARCHAR(255),
        icon_color VARCHAR(7),
        price_amount DECIMAL(10, 2),
        price_currency VARCHAR(10),
        price_currencyLang VARCHAR(10),
        price_period VARCHAR(20),
        price_periodLang VARCHAR(20),
        isCurrent BOOLEAN,
        canBeChage BOOLEAN,
        background_color VARCHAR(7),  -- Для хранения одного цвета фона
        condition_title VARCHAR(255),
        condition_description TEXT,
        page_name VARCHAR(255),
        page_info_title VARCHAR(255),
        page_info_subtitle TEXT,
        termsOfServiceUrl VARCHAR(255)
    );
    

    Пример вставки данных

    Поскольку таблица может быть довольно широкой и некоторые поля могут дублироваться для разных записей (например, каждое условие или информация о странице будет в той же строке), можно вставить данные следующим образом:

    1. Для первого сочетания тарифов, иконок, условий и информации о страницах:
    INSERT INTO tariffs (
        id,
        name,
        icon_name,
        icon_color,
        price_amount,
        price_currency,
        price_currencyLang,
        price_period,
        price_periodLang,
        isCurrent,
        canBeChage,
        background_color,
        condition_title,
        condition_description,
        page_name,
        page_info_title,
        page_info_subtitle,
        termsOfServiceUrl
    ) VALUES (
        1,
        'Black',
        'x24_star',
        '#000000',
        0,
        'USD',
        '$',
        'month',
        'мес',
        TRUE,
        FALSE,
        '#1D1F24',  -- Пример одного из цветов фона
        'Платное обслуживание',
        '*0 $ При среднем остатке 2500 $\nв месяц и sales операциях 1500 $',
        'Операции',
        'Обслуживание именной и неименной карты ежемесячно',
        '25$*\n\n0$ При среднем остатке 2500$ в месяц и sales операциях 1500$',
        'https://example.ru'
    ),
    (
        2,
        'Black',
        'x24_star',
        '#000000',
        0,
        'USD',
        '$',
        'month',
        'мес',
        TRUE,
        FALSE,
        '#1D1F24',  -- Для второго условия можно добавить другой цвет или оставить как есть
        'Перевыпуск карты',
        'Бесплатно',
        'Операции',
        'Восстановление утраченного PIN-кода посредством IVR',
        'Бесплатно',
        'https://example.ru'
    ),
    (
        3,
        'Black',
        'x24_star',
        '#000000',
        0,
        'USD',
        '$',
        'month',
        'мес',
        TRUE,
        FALSE,
        '#1D1F24',
        'Снятие наличных в банкоматах',
        '1000$ бесплатно, свыше — 1,5%',
        'Операции',
        'Оплата товаров и услуг',
        'Без комиссии',
        'https://example.ru'
    );
    

    Обратите внимание:

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

    Если количество условий и страниц значительно увеличится, имеет смысл рассмотреть другой подход с нормализацией базы данных.

  5. User

    там отдельными json в колонке будет храниться, вот пример одной колонки "icon": {

                "name": "x24_star",
    
                "color": "#000000",
    
                "backgroundColors": [
    
                    "#FFFFFF",
    
                    "#D6D7D8",
    
                    "#AFB1B3",
    
                    "#97999C",
    
                    "#8F9194",
    
                    "#AFB1B4",
    
                    "#B3B5B8",
    
                    "#DADBDD",
    
                    "#FFFFFF",
    
                    "#F2F2F3",
    
                    "#CBCCCE",
    
                    "#BCBEC0"
    
                ]
    
            },
    
  6. Assistant

    Если вы планируете хранить данные в формате JSON в отдельных колонках, можно использовать один тип данных JSON или JSONB (если поддерживается вашей СУБД, например, PostgreSQL) для хранения более сложных структур. Предположим, что вы используете реляционную базу данных, которая поддерживает такой тип данных.

    Структура таблицы tariffs

    CREATE TABLE tariffs (
        id INT PRIMARY KEY,
        name VARCHAR(255),
        icon JSONB,
        isCurrent BOOLEAN,
        canBeChage BOOLEAN,
        price JSONB,
        backgroundColors JSONB,
        conditions JSONB,
        header JSONB,
        pages JSONB,
        termsOfServiceUrl VARCHAR(255)
    );
    

    Описание полей:

    • id: Уникальный идентификатор тарифа.
    • name: Название тарифа.
    • icon: JSON-объект, содержащий информацию об иконке (имя, цвет и массив фонов).
    • isCurrent: Указывает, является ли тариф текущим.
    • canBeChage: Указывает, может ли тариф быть изменён.
    • price: JSON-объект с информацией о цене (сумма, валюта и т.д.).
    • backgroundColors: Массив фонов для хранения цветов.
    • conditions: Массив условий, содержащий заголовок и описание.
    • header: Заголовок, содержащий строки.
    • pages: Информация о страницах и их содержимом.
    • termsOfServiceUrl: URL, направляющий на условия обслуживания.

    Пример вставки данных

    Теперь вы можете вставить данные в таблицу, используя JSON-формат для соответствующих колонок:

    INSERT INTO tariffs (
        id,
        name,
        icon,
        isCurrent,
        canBeChage,
        price,
        backgroundColors,
        conditions,
        header,
        pages,
        termsOfServiceUrl
    ) VALUES (
        1,
        'Black',
        '{
            "name": "x24_star",
            "color": "#000000",
            "backgroundColors": [
                "#FFFFFF",
                "#D6D7D8",
                "#AFB1B3",
                "#97999C",
                "#8F9194",
                "#AFB1B4",
                "#B3B5B8",
                "#DADBDD",
                "#FFFFFF",
                "#F2F2F3",
                "#CBCCCE",
                "#BCBEC0"
            ]
        }',
        TRUE,
        FALSE,
        '{
            "amount": 0,
            "currency": "USD",
            "currencyLang": "$",
            "period": "month",
            "periodLang": "мес"
        }',
        '[
            "#1D1F24",
            "#31353D"
        ]',
        '[
            {
                "title": "Платное обслуживание",
                "description": "*0 $ При среднем остатке 2500 $\nв месяц и sales операциях 1500 $"
            }
        ]',
        '[
            "Операции"
        ]',
        '[
            {
                "name": "Операции",
                "info": [
                    {
                        "title": "Обслуживание именной и неименной карты ежемесячно",
                        "subtitle": "25$*\n\n0$ При среднем остатке 2500$ в месяц и sales операциях 1500$"
                    },
                    {
                        "title": "Перевыпуск карты",
                        "subtitle": "Бесплатно"
                    },
                    {
                        "title": "Восстановление утраченного PIN-кода посредством IVR",
                        "subtitle": "Бесплатно"
                    },
                    {
                        "title": "Снятие наличных в банкоматах",
                        "subtitle": "1000$ бесплатно, свыше — 1,5%"
                    },
                    {
                        "title": "Оплата товаров и услуг",
                        "subtitle": "Без комиссии"
                    }
                ]
            }
        ]',
        'https://example.ru'
    );
    

    Замечания:

    • Используйте правильный формат JSON для данных, и обязательно закройте JSON-объекты и массивы корректно.
    • Убедитесь, что ваша реляционная база данных поддерживает JSON или JSONB и соответствующие функции для работы с ними.
    • С помощью JSON-формата можно динамически добавлять и изменять структуру, что дает большую гибкость. Однако, эффективность выполнения запросов может быть ниже по сравнению с традиционными реляционными таблицами, особенно при больших объемах данных.
  7. User

    При возврате платежа когда передается shopOrderId, если это уже повторный вызов (уже добавлена возвратная запись с reference таким же как и у исходной записи), может выбраться возвратная запись, а в ней не заполнен счет (accountNumber) и в результате произойдет ошибка NPE в acq.micro.core.impl.AcquiringProcessingServiceImpl#checkBalance.

    Сделать так что бы всегда выбиралась только приходная операция.

    Место: acq.micro.core.impl.AcquiringOperationServiceImpl#reverseOperation

    @Override public StatusMessage reverseOperation(Long partnerId, Long orderId, String shopOrderId, String reason, String sign) { if (partnerId == null || (orderId == null && isEmpty(shopOrderId)) || isEmpty(sign)) { throw new IllegalArgumentException(); } String expectedSign = acquiringProcessingService.getSignature(concat(partnerId, orderId, shopOrderId, reason), partnerId); if (!expectedSign.equals(sign)) { log.info("[reverseOperation] sign = {}", sign); log.info("[reverseOperation] expectedSign = {}", expectedSign); throw new IllegalArgumentException(SIGN_NOT_VALID); } // Проверка статуса активности String checkResult = probationService.checkActiveState(partnerId); if (!StringUtils.isEmpty(checkResult)) { throw new IllegalArgumentException(checkResult); }

        final Company partner = requirePartner(partnerId);
        boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
        Long operationId = orderId;
        if (operationId == null) {
            if (isAgent) {
                AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.agent.id.eq(partnerId).and(p.reference.eq(shopOrderId))).fetchFirst();
                if (acquiringOperation != null) {
                    operationId = acquiringOperation.getId();
                }
            } else {
                AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.partner.id.eq(partnerId).and(p.reference.eq(shopOrderId))).fetchFirst();
                if (acquiringOperation != null) {
                    operationId = acquiringOperation.getId();
                }
            }
            if (operationId == null) {
                throw new IllegalArgumentException();
            }
        }
        final Long id = operationId;
        final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();
    
        if (isAgent) {
            if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
                throw new IllegalArgumentException();
            }
        }
    
        WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
        if (result.isFail()) {
            return StatusMessage.error(result.getFirstMessage());
        }
    
        return StatusMessage.ok(result.getFirstMessage());
    }
    
  8. Assistant

    Чтобы обеспечить выбор только приходных операций при обработке возврата платежа в методе reverseOperation, вам нужно обновить запрос к базе данных, чтобы он фильтровал операции по типу (например, "приходная" операция). В коде, который вы предоставили, делается выборка операции по shopOrderId, и это следует изменить так, чтобы возвращались только приходные операции.

    Возможное решение

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

    @Override
    public StatusMessage reverseOperation(Long partnerId, Long orderId, String shopOrderId, String reason, String sign) {
        if (partnerId == null || (orderId == null && isEmpty(shopOrderId)) || isEmpty(sign)) {
            throw new IllegalArgumentException();
        }
        String expectedSign = acquiringProcessingService.getSignature(concat(partnerId, orderId, shopOrderId, reason), partnerId);
        if (!expectedSign.equals(sign)) {
            log.info("[reverseOperation] sign = {}", sign);
            log.info("[reverseOperation] expectedSign = {}", expectedSign);
            throw new IllegalArgumentException(SIGN_NOT_VALID);
        }
        
        // Проверка статуса активности
        String checkResult = probationService.checkActiveState(partnerId);
        if (!StringUtils.isEmpty(checkResult)) {
            throw new IllegalArgumentException(checkResult);
        }
    
        final Company partner = requirePartner(partnerId);
        boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
        Long operationId = orderId;
        if (operationId == null) {
            AcquiringOperation acquiringOperation = null;
    
            // Изменённый запрос для получения только приходной операции
            if (isAgent) {
                acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
                    p -> p.agent.id.eq(partnerId)
                            .and(p.reference.eq(shopOrderId))
                            .and(p.operationType.eq(OperationType.INCOMING)))  // Предполагается наличие поля operationType
                    .fetchFirst();
            } else {
                acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
                    p -> p.partner.id.eq(partnerId)
                            .and(p.reference.eq(shopOrderId))
                            .and(p.operationType.eq(OperationType.INCOMING)))  // Фильтруем только приходные операции
                    .fetchFirst();
            }
            
            if (acquiringOperation != null) {
                operationId = acquiringOperation.getId();
            }
    
            if (operationId == null) {
                throw new IllegalArgumentException();
            }
        }
    
        final Long id = operationId;
        final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();
    
        if (isAgent) {
            if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
                throw new IllegalArgumentException();
            }
        }
    
        WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
        if (result.isFail()) {
            return StatusMessage.error(result.getFirstMessage());
        }
    
        return StatusMessage.ok(result.getFirstMessage());
    }
    

    Разбор изменений:

    1. Фильтрация по типу операции: В обоих случаях, когда выполняется запрос для выбора операции по shopOrderId, добавлен дополнительный фильтр .and(p.operationType.eq(OperationType.INCOMING)), что позволяет выбрать только приходные операции. Предполагается, что у вас есть перечисление OperationType с выбором INCOMING для приходных операций.

    2. Проверка наличия операции: Теперь, если операция не найдена, будет выбрасываться исключение, как и прежде.

    Примечания:

    • Убедитесь, что у вас есть соответствующее поле (например, operationType) в вашей базе данных и модели AcquiringOperation, где вы храните тип операции.
    • Если фильтрация по типу операции уже реализована в вашей базе данных или ORM (например, через JPA), убедитесь, что вы добавили это условие в ваш query без проблем.

    Если вы используете другой тип хранения данных, например, другой ORM, синтаксис запроса может немного отличаться, и вы должны скорректировать код соответственно.

  9. User

    у меня вот так public enum AcquiringOperationType { PAY_BASKET("Оплата корзины"), INCOME_ACCOUNT("Пополнение счета"), REVERSE("Возврат");

    public String description;
    
    private AcquiringOperationType(String description) {
        this.description = description;
    }
    
    public String getDescription() {
        return this.description;
    }
    
    public static List<String> notReverseTypes() {
        return (List)Arrays.stream(values()).filter((t) -> {
            return !REVERSE.equals(t);
        }).map(Enum::name).collect(Collectors.toList());
    }
    
    public static List<AcquiringOperationType> notReverseTypesEnum() {
        return (List)Arrays.stream(values()).filter((t) -> {
            return !REVERSE.equals(t);
        }).collect(Collectors.toList());
    }
    

    }

  10. Assistant

    Отлично! У вас есть перечисление AcquiringOperationType, которое содержит типы операций, включая INCOME_ACCOUNT для пополнения счёта, PAY_BASKET для оплаты корзины и REVERSE для возвратов.

    Изменение метода reverseOperation

    Вам нужно будет обновить метод reverseOperation, чтобы фильтровать возвращаемые операции только на основе типов операций, которые не являются возвратными (т.е. исключить тип REVERSE и оставить только типы INCOME_ACCOUNT и PAY_BASKET).

    Вот как это можно сделать:

    @Override
    public StatusMessage reverseOperation(Long partnerId, Long orderId, String shopOrderId, String reason, String sign) {
        if (partnerId == null || (orderId == null && isEmpty(shopOrderId)) || isEmpty(sign)) {
            throw new IllegalArgumentException();
        }
        String expectedSign = acquiringProcessingService.getSignature(concat(partnerId, orderId, shopOrderId, reason), partnerId);
        if (!expectedSign.equals(sign)) {
            log.info("[reverseOperation] sign = {}", sign);
            log.info("[reverseOperation] expectedSign = {}", expectedSign);
            throw new IllegalArgumentException(SIGN_NOT_VALID);
        }
        
        // Проверка статуса активности
        String checkResult = probationService.checkActiveState(partnerId);
        if (!StringUtils.isEmpty(checkResult)) {
            throw new IllegalArgumentException(checkResult);
        }
    
        final Company partner = requirePartner(partnerId);
        boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
        Long operationId = orderId;
        if (operationId == null) {
            AcquiringOperation acquiringOperation = null;
    
            // Теперь изменим условие для фильтрации по операциям
            if (isAgent) {
                acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
                    p -> p.agent.id.eq(partnerId)
                            .and(p.reference.eq(shopOrderId))
                            .and(p.operationType.in(AcquiringOperationType.notReverseTypesEnum()))  // Выбор только приходных операций
                    ).fetchFirst();
            } else {
                acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
                    p -> p.partner.id.eq(partnerId)
                            .and(p.reference.eq(shopOrderId))
                            .and(p.operationType.in(AcquiringOperationType.notReverseTypesEnum()))  // Выбор только приходных операций
                    ).fetchFirst();
            }
            
            if (acquiringOperation != null) {
                operationId = acquiringOperation.getId();
            }
    
            if (operationId == null) {
                throw new IllegalArgumentException();
            }
        }
    
        final Long id = operationId;
        final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();
    
        if (isAgent) {
            if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
                throw new IllegalArgumentException();
            }
        }
    
        WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
        if (result.isFail()) {
            return StatusMessage.error(result.getFirstMessage());
        }
    
        return StatusMessage.ok(result.getFirstMessage());
    }
    

    Изменения в коде:

    1. Фильтрация по типу операции: В запросах для получения AcquiringOperation добавлены условия .and(p.operationType.in(AcquiringOperationType.notReverseTypesEnum())), чтобы выбрать только типы операций, которые не являются REVERSE. Это позволяет гарантировать, что при попытке выполнения операции возврата будет выбрана только приходная операция.

    2. Использование метода notReverseTypesEnum: Я использую ваш метод из перечисления AcquiringOperationType, который возвращает список типов, кроме REVERSE. Это позволяет избежать дисбаланса в логике фильтрации операций.

    Заключение:

    Эти изменения помогут избежать возникновения NullPointerException (NPE) в том месте, где проверяется счёт, гарантируя, что при возврате платежа выбирается только приходная операция, тем самым предотвращая возможные ошибки. Убедитесь, что у вас есть соответствующие индексы на поле operationType в вашей таблице для улучшения производительности запросов.

  11. User

    а это откуда, это метод или что это? notReverseTypesEnum()

  12. Assistant

    Метод notReverseTypesEnum() — это метод, который вы определили в вашем перечислении AcquiringOperationType. Ваша реализация выглядит следующим образом:

    public static List<AcquiringOperationType> notReverseTypesEnum() {
        return (List) Arrays.stream(values()).filter((t) -> {
            return !REVERSE.equals(t);
        }).collect(Collectors.toList());
    }
    

    Что делает этот метод

    Метод notReverseTypesEnum() возвращает список всех значений перечисления AcquiringOperationType, кроме значения REVERSE.

    Как он работает:

    1. values(): Этот метод возвращает массив всех констант, объявленных в перечислении AcquiringOperationType.
    2. Arrays.stream(values()): Превращает массив констант в поток, что позволяет использовать методы стримов для обработки коллекций.
    3. filter(...): Применяет фильтр к стриму, оставляя только те элементы, которые не равны REVERSE.
    4. collect(Collectors.toList()): Собирает отфильтрованные элементы обратно в список.

    Этот метод может использоваться, чтобы легко получить список всех типов операций, кроме типа возврата (REVERSE), что позволяет упростить логику выбора операций, когда вам нужно исключить возвратные операции, как в вашем методе reverseOperation.

    Использование метода в коде

    В вашем методе reverseOperation мы использовали этот метод для выбора только нужных типов операций:

    .operationType.in(AcquiringOperationType.notReverseTypesEnum())
    

    Этот фрагмент кода означает, что при выполнении запроса к базе данных вы выбираете только те операции, которые имеют тип, входящий в список, возвращаемый вашим методом notReverseTypesEnum().

    Если нет необходимости в перечислении

    Если по какой-то причине вы не хотите использовать этот метод, вы можете просто изменить логику фильтрации непосредственно в вашем SQL-запросе, чтобы просто фильтровать по типам операций, не включая REVERSE. Однако использование перечисления делает код более читаемым и поддерживаемым.

    Заключение

    Метод notReverseTypesEnum() полезен для повышения читаемости и удобства поддержки вашего кода и позволяет централизованно управлять типами операций.

  13. User

    а корректно сюда список передавать? public <T, U> JPAQuery selectFromWhere(EntityPath entity, Class cls, Function<U, Predicate> where) { return (JPAQuery)this.selectFrom(entity).where((Predicate)where.apply(entity)); }

  14. Assistant

    Да, метод selectFromWhere в вашем коде предполагает передачу функционального интерфейса Function<U, Predicate>, что позволяет использовать лямбда-выражения для создания условий в запросе. Вы можете корректно использовать этот метод, передавая список в качестве параметра, когда это необходимо.

    Давайте разберём код метода:

    public <T, U> JPAQuery<T> selectFromWhere(EntityPath<T> entity, Class<U> cls, Function<U, Predicate> where) {
        return (JPAQuery)this.selectFrom(entity).where((Predicate)where.apply(entity));
    }
    

    Параметры метода:

    1. EntityPath<T> entity: Это определение пути к сущности, с которой вы хотите выполнять запрос. Это может быть своего рода «представление» сущности в JPA.
    2. Class<U> cls: Это класс, который будет использоваться для создания условий в запросе. Обычно это ваш класс сущности.
    3. Function<U, Predicate> where: Это функциональный интерфейс, который принимает объект класса U и возвращает условие Predicate. Это позволяет вам задавать условия фильтрации.

    Пример использования

    Когда вы хотите создать запрос с использованием вашей функции, вы можете сделать это следующим образом:

    AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
        QAcquiringOperation.class,
        p -> p.partner.id.eq(partnerId)
               .and(p.reference.eq(shopOrderId))
               .and(p.operationType.in(AcquiringOperationType.notReverseTypesEnum()))
    ).fetchFirst();
    

    Объяснение

    • Здесь вы вызываете selectFromWhere, передавая:
      • QAcquiringOperation.acquiringOperation как EntityPath<T>.
      • QAcquiringOperation.class как класс сущности.
      • Лямбда-выражение, которое задает условия для выполнения выборки.

    Корректность передачи списка

    Касательно передачи списка:

    • Ваша строка p.operationType.in(AcquiringOperationType.notReverseTypesEnum()) будет работать корректно, если вы используете подходящий метод для приведения типов и ваша ORM поддерживает работу с перечислениями так же, как с обычными типами данных.
    • Убедитесь, что ваша ORM поддерживает все операции и фильтрации для используемого типа (в вашем случае это перечисление).

    Если ваш метод notReverseTypesEnum() возвращает список типов, который поддерживается вашим ORM, так, как описано выше, то всё будет работать корректно.

    Заключение

    Метод selectFromWhere реализован так, чтобы быть универсальным и позволяет использовать лямбда-выражения для создания любого необходимого условия. Выбор фильтров по полученному списку типов (например, с использованием notReverseTypesEnum()) является хорошей практикой, поскольку делает код более чистым и удобным для чтения при работе с фильтрацией данных.

  15. User

    напиши поля json private Long partnerId; private Long orderId; private String shopOrderId; private String reason; private String sign;

  16. Assistant

    Если вам нужно представить поля, такие как partnerId, orderId, shopOrderId, reason, и sign, в формате JSON, вы можете сделать это следующим образом:

    {
        "partnerId": 12345,
        "orderId": 67890,
        "shopOrderId": "ABC123XYZ",
        "reason": "Возврат товара",
        "sign": "your_generated_signature"
    }
    

    Описание полей:

    • partnerId: идентификатор партнера (тип Long).
    • orderId: идентификатор заказа (тип Long).
    • shopOrderId: идентификатор заказа в магазине (тип String).
    • reason: причина возврата (тип String).
    • sign: подпись (типа String), возможно, сгенерированная на основе других полей.

    JSON с примерами значений:

    Вот полноценный пример JSON с некоторыми значениями:

    {
        "partnerId": 101,
        "orderId": 202,
        "shopOrderId": "ORD123456",
        "reason": "Клиент передумал",
        "sign": "abc123signature"
    }
    

    Этот формат можно использовать для передачи данных по сети или для хранения в базе данных, если используется формат JSON.

    Если вам нужно генерировать JSON в Java, вы можете использовать библиотеки, такие как Jackson или Gson, для сериализации объектов, содержащих эти поля. Пример кода для сериализации с использованием библиотеки Jackson:

    import com.fasterxml.jackson.databind.ObjectMapper;
    
    public class OperationData {
        private Long partnerId;
        private Long orderId;
        private String shopOrderId;
        private String reason;
        private String sign;
    
        // геттеры и сеттеры
    
        public static void main(String[] args) throws Exception {
            ObjectMapper mapper = new ObjectMapper();
    
            OperationData data = new OperationData();
            data.setPartnerId(101L);
            data.setOrderId(202L);
            data.setShopOrderId("ORD123456");
            data.setReason("Клиент передумал");
            data.setSign("abc123signature");
    
            String jsonString = mapper.writeValueAsString(data);
            System.out.println(jsonString);
        }
    }
    

    Этот код создаст JSON-строку, представляющую объект OperationData, который включает в себя ваши поля.

  17. User

    как исправить такой момент, если id null, то достается по shopOrderId, и устанавливается значение operationId, а потом опять для сценария с id опять лезем в базу, этого не должно быть final Company partner = requirePartner(partnerId); boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT); Long operationId = orderId; if (operationId == null) { if (isAgent) { AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.agent.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); if (acquiringOperation != null) { operationId = acquiringOperation.getId(); } } else { AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.partner.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); if (acquiringOperation != null) { operationId = acquiringOperation.getId(); } } if (operationId == null) { throw new IllegalArgumentException(); } } final Long id = operationId; final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();

        if (isAgent) {
            if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
                throw new IllegalArgumentException();
            }
        }
    
        WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
        if (result.isFail()) {
            return StatusMessage.error(result.getFirstMessage());
        }
    
        return StatusMessage.ok(result.getFirstMessage());
    }
    
  18. Assistant

    Для исправления проблемы, при которой ID сначала устанавливается на основании shopOrderId, а затем выполняется повторный запрос к базе для получения операции по этому ID, можно изменить логику таким образом, чтобы избежать повторного обращения в базу данных, если операция уже найдена.

    Решение

    Вместо того чтобы дважды опрашивать базу данных, первое значение операции стараться сохранить в переменной и продолжить работу с ней. Если операция найдена по shopOrderId, то используем её. Если же операция не найдена, тогда можно бросить исключение сразу.

    Вот улучшенная версия вашего кода:

    final Company partner = requirePartner(partnerId);
    boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
    Long operationId = orderId;
    
    if (operationId == null) {
        AcquiringOperation acquiringOperation = null;
    
        if (isAgent) {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
                QAcquiringOperation.class, 
                p -> p.agent.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        } else {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
                QAcquiringOperation.class, 
                p -> p.partner.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        }
    
        // Если операция не найдена
        if (acquiringOperation == null) {
            throw new IllegalArgumentException("Operation not found for provided shopOrderId.");
        }
    
        // Получаем operationId из найденной операции
        operationId = acquiringOperation.getId();
    }
    
    // Получаем операцию только один раз
    final Long id = operationId;
    final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
        QAcquiringOperation.class, 
        p -> p.id.eq(id)).fetchFirst();
    
    if (isAgent) {
        if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
            throw new IllegalArgumentException();
        }
    }
    
    WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
    if (result.isFail()) {
        return StatusMessage.error(result.getFirstMessage());
    }
    
    return StatusMessage.ok(result.getFirstMessage());
    

    Объяснение изменений:

    1. Удаление второго запроса к базе: Мы сократили количество запросов. Если orderId равен null, происходит выборка операции по shopOrderId, и мы сразу проверяем, найдена ли операция. Если не найдена, выбрасываем исключение.

    2. Установка operationId: Если операция найдена, operationId устанавливается с помощью найденной операции.

    3. Единственный запрос к базе для получения операции по ID: После установки operationId мы выполняем только один запрос для получения операции по этому ID. Это решение исключает необходимость делать повторный запрос, если вы уже получили operationId.

    Таким образом, мы улучшили код, добавили проверки и упростили логику, убрав избыточный запрос к базе данных.

  19. User

    мы же уже получили операцию, если id null, а этот сценарий если id изначально не null // Получаем операцию только один раз final Long id = operationId; final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();

  20. Assistant

    Понял, давайте уточним. Если operationId изначально не равен null, то мы уже имеем идентификатор операции и можем сразу же выполнить запрос для получения самой операции. При этом условие должно быть таким, чтобы использовать разные сценарии для получения операции — для случая, когда orderId не равен null, и для случая, когда orderId равен null.

    Вот более корректный и оптимизированный вариант вашего кода:

    final Company partner = requirePartner(partnerId);
    boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
    
    // Изначально operationId установлено из orderId
    Long operationId = orderId; 
    
    // Если operationId == null, пытаемся получить его по shopOrderId
    if (operationId == null) {
        AcquiringOperation acquiringOperation = null;
    
        if (isAgent) {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
                QAcquiringOperation.class, 
                p -> p.agent.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        } else {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
                QAcquiringOperation.class, 
                p -> p.partner.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        }
    
        // Если операция не найдена, выбрасываем исключение
        if (acquiringOperation == null) {
            throw new IllegalArgumentException("Operation not found for provided shopOrderId.");
        }
    
        // Получаем operationId из найденной операции
        operationId = acquiringOperation.getId();
    }
    
    // На данном этапе, operationId гарантированно не null
    final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation,
        QAcquiringOperation.class,
        p -> p.id.eq(operationId)).fetchFirst();
    
    if (isAgent) {
        if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
            throw new IllegalArgumentException();
        }
    }
    
    WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
    if (result.isFail()) {
        return StatusMessage.error(result.getFirstMessage());
    }
    
    return StatusMessage.ok(result.getFirstMessage());
    

    Объяснение изменений:

    1. Первичное значение operationId: Мы устанавливаем operationId напрямую из orderId, без лишних проверок, потому что при запросах к базе данных штабелируются попытки получения управления, если orderId не равен null.

    2. Упрощение логики: В случае, если orderId равен null, мы выполняем запрос по shopOrderId и получаем operationId только в этом сценарии, сохраняя логику запроса.

    3. Получение операции по operationId: После всех проверок остается один запрос к базе данных для работы со operationId, поскольку любой базовый сценарий был обработан ранее.

    Таким образом, мы исключаем повторные запросы к базе данных, и вся логика полностью зависит от значения orderId. Вы гарантированно получали нужные данные на каждом этапе.

  21. User

    нет ты не понял, смотри если id ==null, то мы по сути уже достали операцию, if (operationId == null) { if (isAgent) { AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.agent.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); if (acquiringOperation != null) { operationId = acquiringOperation.getId(); } } else { AcquiringOperation acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.partner.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); if (acquiringOperation != null) { operationId = acquiringOperation.getId(); } } if (operationId == null) { throw new IllegalArgumentException(); } }

    а ниже который сценарий доставания операции уже не нужен при таком раскладе, он нужен если мы на условии if (operationId == null) { отвалились и пошли уже сюда сразу final Long id = operationId; final AcquiringOperation operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();

  22. Assistant

    Понял вас. Если в вашем условии if (operationId == null) была выполнена логика поиска операции по shopOrderId и установлено значение operationId, то действительно повторный запрос для получения операции по operationId уже не нужен.

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

    final Company partner = requirePartner(partnerId);
    boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
    
    // Изначально operationId установлено из orderId
    Long operationId = orderId;
    
    if (operationId == null) {
        AcquiringOperation acquiringOperation = null;
    
        if (isAgent) {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
                QAcquiringOperation.class, 
                p -> p.agent.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        } else {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, 
                QAcquiringOperation.class, 
                p -> p.partner.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        }
    
        // Если операция не найдена, выбрасываем исключение
        if (acquiringOperation == null) {
            throw new IllegalArgumentException("Operation not found for provided shopOrderId.");
        }
    
        // Получаем operationId из найденной операции
        operationId = acquiringOperation.getId();
    }
    
    // На этом этапе operationId гарантированно не null
    // Мы уже имеем нужную информацию о операции, так что мы можем использовать acquiringOperation напрямую
    AcquiringOperation operation = acquiringOperation;
    
    // Проверяем, принадлежит ли операция агенту, если это необходимо
    if (isAgent) {
        if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
            throw new IllegalArgumentException("Operation does not belong to the agent.");
        }
    }
    
    WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
    if (result.isFail()) {
        return StatusMessage.error(result.getFirstMessage());
    }
    
    return StatusMessage.ok(result.getFirstMessage());
    

    Объяснение изменений:

    1. Избавление от повторного запроса: Мы теперь непосредственно используем объект acquiringOperation, который был найден, вместо повторного запроса к базе данных, так как он уже содержит необходимую информацию.

    2. Проверка принадлежности операции агенту: Мы используемся найденный объект operation для проверки, принадлежит ли операция агенту, и возвращаем соответствующее исключение, если это не так.

    3. Упрощение логики: Логика теперь более проста и ясна, так как нет дублирования в обращениях к базе данных, и все проверки основаны на ранее извлеченной операции.

    Теперь код стал более эффективным, и вы избежали избыточных транзакций с базой данных, сделав его более читабельным и поддерживаемым.

  23. User

    а если operationId не null изначально? откуда мы операцию возьмем тогда? он может либо прийти либо нет

  24. Assistant

    Понял вас. Если operationId изначально не равен null, нам нужно сразу получить операцию из базы данных, и при этом учесть, что в случае, если operationId равен null, мы будем искать операцию по shopOrderId.

    Вот окончательная версия вашего метода, которая учитывает оба сценария:

    1. Если orderId (или operationId) не равен null, мы сразу извлекаем операцию по этому operationId.
    2. Если orderId равен null, мы извлекаем операцию по shopOrderId.

    Вот как это может выглядеть в коде:

    final Company partner = requirePartner(partnerId);
    boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
    Long operationId = orderId; // Сначала устанавливаем operationId из orderId
    
    AcquiringOperation operation; // Объявляем переменную для операции
    
    // Если operationId не null, получаем операцию по operationId
    if (operationId != null) {
        operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation,
            QAcquiringOperation.class,
            p -> p.id.eq(operationId)).fetchFirst();
    
        // Проверка, если операция не найдена
        if (operation == null) {
            throw new IllegalArgumentException("Operation not found for provided operationId.");
        }
    } else {
        // Если operationId равен null, пытаемся получить его по shopOrderId
        AcquiringOperation acquiringOperation = null;
    
        if (isAgent) {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation,
                QAcquiringOperation.class,
                p -> p.agent.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        } else {
            acquiringOperation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation,
                QAcquiringOperation.class,
                p -> p.partner.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        }
    
        // Если операция не найдена, выбрасываем исключение
        if (acquiringOperation == null) {
            throw new IllegalArgumentException("Operation not found for provided shopOrderId.");
        }
    
        // Получаем operationId из найденной операции
        operationId = acquiringOperation.getId();
        operation = acquiringOperation; // Теперь устанавливаем operation
    }
    
    // Проверяем, принадлежит ли операция агенту, если это необходимо
    if (isAgent) {
        if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
            throw new IllegalArgumentException("Operation does not belong to the agent.");
        }
    }
    
    WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
    if (result.isFail()) {
        return StatusMessage.error(result.getFirstMessage());
    }
    
    return StatusMessage.ok(result.getFirstMessage());
    

    Объяснение изменений:

    1. Обработка обоих сценариев: Логика обработана так, чтобы сначала проверить, есть ли operationId. Если он не равен null, мы пытаемся сразу получить операцию по этому идентификатору. Если она не найдена, выбрасываем исключение.

    2. Использование acquiringOperation для поиска: Если operationId равен null, выполняется поиск по shopOrderId. Если операция найдена, мы устанавливаем ее в operation и присваиваем её ID в operationId.

    3. Упрощение логики проверки принадлежности операции: Теперь нет многократных запросов, и мы имеем ясную структуру, которая отвечает на оба сценария.

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

  25. User

    посмотри вот так? final Company partner = requirePartner(partnerId); boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT); Long operationId = orderId; AcquiringOperation operation; if (operationId != null) { final Long id = operationId; operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst(); } else { if (isAgent) { operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.agent.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); if (operation != null) { operationId = operation.getId(); } } else { operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.partner.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); if (operation != null) { operationId = operation.getId(); } } if (operationId == null) { throw new IllegalArgumentException(); } }

        if (isAgent) {
            if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
                throw new IllegalArgumentException();
            }
        }
    
        WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
        if (result.isFail()) {
            return StatusMessage.error(result.getFirstMessage());
        }
    
        return StatusMessage.ok(result.getFirstMessage());
    }
    
  26. Assistant

    Да, ваш код выглядит хорошо и логично организован. Давайте прокомментируем ключевые моменты и убедимся, что все работает корректно:

    final Company partner = requirePartner(partnerId);
    boolean isAgent = partnerRoleService.hasRole(partner, PartnerRoleEnum.ACQ_AGENT);
    Long operationId = orderId; // Изначально получаем operationId из orderId
    AcquiringOperation operation;
    
    // Если operationId не null, получаем операцию по operationId
    if (operationId != null) {
        final Long id = operationId;
        operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(id)).fetchFirst();
    } else {
        // Если operationId равен null, выполняем поиск по shopOrderId
        if (isAgent) {
            operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
                p -> p.agent.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        } else {
            operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class,
                p -> p.partner.id.eq(partnerId)
                        .and(p.reference.eq(shopOrderId))
                        .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
            ).fetchFirst();
        }
        
        // Если операция не найдена, выбрасываем исключение
        if (operation != null) {
            operationId = operation.getId(); // Устанавливаем operationId из найденной операции
        } else {
            throw new IllegalArgumentException("Operation not found for the provided shopOrderId.");
        }
    }
    
    // Проверяем, принадлежит ли операция агенту, если это необходимо
    if (isAgent) {
        if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
            throw new IllegalArgumentException("Operation does not belong to the agent.");
        }
    }
    
    // Выполняем операцию возврата
    WorkResult<Void> result = acquiringProcessingService.reverseOperation(operationId, reason);
    if (result.isFail()) {
        return StatusMessage.error(result.getFirstMessage());
    }
    
    return StatusMessage.ok(result.getFirstMessage());
    

    Пр комментарии:

    1. Получение partner и определение роли: Вы получаете partner и определяете, является ли он агентом. Это необходимо для выбора правильной логики.

    2. Логика выбора операции:

      • Если operationId не равен null, вы запрашиваете операцию по этому ID.
      • Если operationId равен null, вы выполняете поиск по shopOrderId в зависимости от роли (isAgent).
    3. Проверка на существование операции:

      • Если операция найдена, вы присваиваете operationId значение из найденной операции.
      • Если операция не найдена, вы выбрасываете IllegalArgumentException, что является хорошей практикой для обработки случаев, когда ожидаемые данные отсутствуют.
    4. Проверка принадлежности операции: В этом блоке вы проверяете, принадлежит ли операция партнеру, если он является агентом.

    5. Возврат операции: После успешного выполнения всех проверок и получения операции, вы вызываете метод для выполнения возврата.

    Общие рекомендации:

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

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

  27. User

    корректно ли сейчас или можно как-то улучшить? final Long operationId = orderId; AcquiringOperation operation;

        if (operationId != null) {
            operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.id.eq(operationId)).fetchFirst();
        } else {
            if (isAgent) {
                operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.agent.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst();
            } else {
                operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.partner.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst();
            }
        }
        if (operation == null) {
            throw new IllegalArgumentException();
        }
        if (isAgent) {
            if (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId())) {
                throw new IllegalArgumentException();
            }
        }
    
  28. Assistant

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

    1. У Unified Exception Messages: Вместо того чтобы выбрасывать цифровое исключение без сообщения, можно добавить подробное сообщение, объясняющее, почему операция не найдена. Это упрощает диагностику при возникновении ошибок.

    2. Избегание дублирования: Вы можете объединить логику выборки операции в один блок, что сделает код более лаконичным.

    3. Оптимизация проверки на принадлежность: Вместо проверки if (operation.getAgent() == null || ...), можно использовать более краткий подход для проверки, если это действительно агент.

    Вот улучшенная версия вашего кода:

    final Long operationId = orderId; // Сначала устанавливаем operationId из orderId
    AcquiringOperation operation;
    
    // Получаем операцию в зависимости от наличия operationId
    if (operationId != null) {
        operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
            p -> p.id.eq(operationId)).fetchFirst();
    } else {
        // Формируем запрос в зависимости от роли (агент или партнер)
        operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
            p -> (isAgent ? p.agent.id.eq(partnerId) : p.partner.id.eq(partnerId))
                    .and(p.reference.eq(shopOrderId))
                    .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
        ).fetchFirst();
    }
    
    // Проверка существования операции
    if (operation == null) {
        throw new IllegalArgumentException("Operation not found for the provided identifier.");
    }
    
    // Проверка принадлежности операции
    if (isAgent && (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId()))) {
        throw new IllegalArgumentException("Operation does not belong to the agent.");
    }
    
    // Здесь вы можете продолжить логику, если операция найдена и принадлежит агенту
    

    Объяснение изменений:

    1. Упрощение логики выбора операции: Теперь вы используете один запрос для получения операции, который использует оператора тернарного выбора для определения, получать ли операцию по agent или partner. Это минимизирует дублирование кода.

    2. Содержательное сообщение об ошибке: Теперь сообщение об ошибке при отсутствии операции объясняет, что именно не удалось найти, что улучшает читаемость и удобство отладки.

    3. Краткость проверки принадлежности: Логика проверки принадлежности была упрощена до одной строки.

    Заключение

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

  29. User

    или вот этот блок можно сделать через тернарный оператор? else { if (isAgent) { operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.agent.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); } else { operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, p -> p.partner.id.eq(partnerId).and(p.reference.eq(shopOrderId)).and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))).fetchFirst(); } }

  30. Assistant

    Да, вы можете использовать тернарный оператор для упрощения этого блока и избежать дублирования кода. В этом случае вы можете создать запрос, который выбирает нужное поле в зависимости от роли (isAgent), используя тернарный оператор.

    Вот как можно улучшить ваш код с помощью тернарного оператора:

    final Long operationId = orderId; // Сначала устанавливаем operationId из orderId
    AcquiringOperation operation;
    
    // Получаем операцию в зависимости от наличия operationId
    if (operationId != null) {
        operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
            p -> p.id.eq(operationId)).fetchFirst();
    } else {
        // Формируем запрос в зависимости от роли (агент или партнер)
        operation = dataService.selectFromWhere(QAcquiringOperation.acquiringOperation, QAcquiringOperation.class, 
            p -> (isAgent ? p.agent.id.eq(partnerId) : p.partner.id.eq(partnerId))
                    .and(p.reference.eq(shopOrderId))
                    .and(p.type.in(AcquiringOperationType.notReverseTypesEnum()))
        ).fetchFirst();
    }
    
    // Проверка существования операции
    if (operation == null) {
        throw new IllegalArgumentException("Operation not found for the provided identifier.");
    }
    
    // Проверка принадлежности операции
    if (isAgent && (operation.getAgent() == null || !operation.getAgent().getId().equals(partner.getId()))) {
        throw new IllegalArgumentException("Operation does not belong to the agent.");
    }
    
    // Здесь вы можете продолжить логику, если операция найдена и принадлежит агенту
    

    Объяснение изменений:

    1. Тернарный оператор: Использование тернарного оператора (isAgent ? p.agent.id.eq(partnerId) : p.partner.id.eq(partnerId)) позволяет упростить код и избежать дублирования в логике выборки.

    2. Читаемость: Код все равно достаточно читаем, и разница между выборками по agent и partner четко видна.

    Важно

    Хотя тернарный оператор может упростить код, убедитесь, что он не делает его менее читабельным. Если условие становится сложным, лучше использовать обычный if-else, чтобы сохранить понятность кода. В вашем случае использование тернарного оператора здесь вполне уместно.

  31. User

    это одно и тоже? я руками ничего не делал, в этом классе как-то поменялось само List operationTypes = Arrays.stream(AcquiringOperationType.values()) List operationTypes = stream(AcquiringOperationType.values())

  32. Assistant

    Да, в вашем случае оба выражения, которые вы указали, по сути, делают одно и то же, но с небольшими различиями в синтаксисе.

    Объяснение:

    1. Первый вариант:

      List<AcquiringOperationType> operationTypes = Arrays.stream(AcquiringOperationType.values());
      

      Здесь вы используете Arrays.stream() для создания потока из массива, который возвращает метод values(). Этот метод возвращает массив всех констант перечисления AcquiringOperationType.

    2. Второй вариант:

      List<AcquiringOperationType> operationTypes = stream(AcquiringOperationType.values());
      

      Здесь stream() вызывается напрямую. Это возможно лишь при условии, что у вас есть статический импорт для метода stream(), например:

      import static java.util.Arrays.stream;
      

    Что произошло?

    • Если ваш проект поддерживает статический импорт и stream() был импортирован, вы можете использовать его без указания Arrays.
    • Если stream() не был импортирован, вы получите ошибку компиляции.

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

    Примечание

    • Если вы не уверены, какой вариант использовать, стоит помнить, что использование Arrays.stream() делает код более явным и может быть более предпочтительным в некоторых случаях, особенно для разработчиков, которые могут не знать о статическом импорте или не использовать его.
    • Вообще, если переформулировка кода произошла автоматически (например, в результате использования IDE), скорее всего, это просто изменение стиля, а не изменение логики.