fix(onboarding): 结算银行卡卡号面从未落库，历史进件重提时补齐

yeg

2026-09-18 a058f6109834e29435f5ce4aa19a43d67d07c060

 talent-card-server/src/test/java/com/talentcard/server/business/merchant/MerchantExistingOnboardingTests.java

@@ -23,6 +23,9 @@
    // 否则测试会真的打到汇付。
    @MockitoBean com.talentcard.server.business.payment.huifu.HuifuMerchantWechatConfigGateway wechatConfigGateway;
    @MockitoBean com.talentcard.server.business.payment.huifu.HuifuMerchantBusinessOpenGateway businessOpenGateway;
    // 提交进件会真的上传图片、并向汇付递交申请，这两个也一并挡住——测试不该打网络。
    @MockitoBean com.talentcard.server.business.payment.huifu.HuifuPictureUploadGateway pictureUploadGateway;
    @MockitoBean com.talentcard.server.business.payment.huifu.HuifuIndividualOnboardingGateway individualOnboardingGateway;
    @Autowired org.springframework.web.context.WebApplicationContext context;
    @Autowired com.talentcard.server.business.admin.auth.AdminAuthService adminAuth;

@@ -186,6 +189,41 @@
        assertThat(result).containsEntry("status","pending");
    }

    /**
     * 通道**不返回** {@code fee_min_amt} 时，微信支付阶段同样要算已生效。
     *
     * <p>该字段是可选的，文档写明「大于 0」，不设最低收费时我们本来就不下发它，通道也就不返回它。
     * 判定原先要求它必须出现且为 0，于是真实商户的微信业务明明已经开好（三场景、费率 0.70、内扣、
     * 子商户号与默认标识都在），阶段却永远停在未确认——2026-09-16 拿通道回执逐项核对才发现。
     */
    @Test
    void anAbsentMinimumFeeStillCountsAsWechatConfirmed() {
        MerchantPrincipal principal=(MerchantPrincipal)fixture().get("principal");
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        // 与真实回执同形：三个场景都不带 fee_min_amt。
        var scenes=java.util.List.of("4","5","12").stream().map(scene -> Map.of("pay_scene",scene,"fee_rate","0.70","fee_charge_type","1","out_fee_flag","2",
                "wx_mer_infos",java.util.List.of(Map.of("bank_mer_code","922609119","pay_channel_id","00016904","is_default","1")))).toList();
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N","qry_wx_conf_list",scenes));

        Map<String,Object> result=service.refreshOnboarding(principal,false);

        assertThat((java.util.List<Map<String,Object>>)result.get("stages")).anySatisfy(stage -> assertThat(stage).containsEntry("key","wechat").containsEntry("status","confirmed"));
    }

    /** 但真设了最低收费（非 0）时仍不算生效——放宽的只是"字段缺失"，不是"值不对"。 */
    @Test
    void aNonZeroMinimumFeeKeepsTheWechatStageUnconfirmed() {
        MerchantPrincipal principal=(MerchantPrincipal)fixture().get("principal");
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        var scenes=java.util.List.of("4","5","12").stream().map(scene -> Map.of("pay_scene",scene,"fee_rate","0.70","fee_min_amt","1.00","fee_charge_type","1","out_fee_flag","2",
                "wx_mer_infos",java.util.List.of(Map.of("bank_mer_code","922609119","is_default","1")))).toList();
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N","qry_wx_conf_list",scenes));

        Map<String,Object> result=service.refreshOnboarding(principal,false);

        assertThat((java.util.List<Map<String,Object>>)result.get("stages")).anySatisfy(stage -> assertThat(stage).containsEntry("key","wechat").containsEntry("status","missing"));
    }

    @Test
    void confirmsD1OnlyFromEffectiveZeroThresholdBatchSettlement() {
        MerchantPrincipal principal=(MerchantPrincipal)fixture().get("principal");
@@ -252,28 +290,6 @@
    }

    /**
     * 分阶段刷新要**先推进开通步骤，再回报结果**。渠道侧的微信小程序支付配置与商户业务开通原本
     * 只由进件审核回调触发，而分阶段申请的回调走的是进度刷新——不在这里补上推进，新商户的微信
     * 开通就永远不会被发起。
     */
    @Test
    void refreshingAdvancesTheWechatProvisioningSteps() {
        Map<String,Object> fixture=provisioningFixture();
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","delay_flag","Y","forced_delay_flag","N"));
        when(gateway.queryWechatConfig(anyString())).thenReturn(Map.of("resp_code","00000000"));
        when(wechatConfigGateway.configure(anyString(),anyString())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantWechatConfigGateway.Result(true,"00000000","成功"));
        when(businessOpenGateway.open(anyString(),anyString(),anyString(),anyString(),anyBoolean())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantBusinessOpenGateway.Result(true,"BO-APPLY","90000000","审核中"));

        service.refreshOnboarding((MerchantPrincipal)fixture.get("principal"),false);

        assertThat(statusOf("wechat_config_status",String.valueOf(fixture.get("applicationNo")))).isEqualTo("approved");
        assertThat(statusOf("business_open_status",String.valueOf(fixture.get("applicationNo")))).isEqualTo("processing");
        verify(wechatConfigGateway,times(1)).configure(anyString(),eq("6666000241335656"));
        verify(businessOpenGateway,times(1)).open(anyString(),eq("6666000241335656"),anyString(),anyString(),anyBoolean());
    }

    /**
     * 通道侧已经生效的步骤不再重复提交。微信商户配置是**添加**接口（成功后不支持改删、每种参数
     * 最多 5 组），业务开通是申请型接口，重复提交会在通道留下重复配置或第二份申请。
     */
@@ -291,13 +307,306 @@
        assertThat(statusOf("wechat_config_status",String.valueOf(fixture.get("applicationNo")))).isEqualTo("approved");
        assertThat(statusOf("business_open_status",String.valueOf(fixture.get("applicationNo")))).isEqualTo("approved");
        verify(wechatConfigGateway,never()).configure(anyString(),anyString());
        verify(businessOpenGateway,never()).open(anyString(),anyString(),anyString(),anyString(),anyBoolean());
        verify(businessOpenGateway,never()).open(anyString(),anyString(),anyString(),anyString(),anyBoolean(),anyBoolean(),anyString(),anyString());
    }

    /**
     * 顺序与闸门：先做业务开通；微信小程序配置要等**通道侧真的有微信子商户号**才发。
     *
     * <p>微信子商户号由业务开通创建，但入驻是**异步**的——业务开通回 {@code 90000000}（审核中）
     * 并不代表子商户号已经建好，此时发配置会被「根据渠道号或微信子商户号未查到入驻记录」驳回。
     * 所以闸门取通道证据（{@code qry_wx_conf_list} 里出现线上场景），不取本地受理状态。
     * 2026-09-16 用本地状态当闸门的真实代价就是这个报错。
     */
    @Test
    void theWechatConfigWaitsUntilTheChannelConfirmsTheWechatBusiness() {
        Map<String,Object> fixture=provisioningFixture();
        String applicationNo=String.valueOf(fixture.get("applicationNo"));
        MerchantPrincipal principal=(MerchantPrincipal)fixture.get("principal");
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N"));
        when(businessOpenGateway.open(anyString(),anyString(),anyString(),anyString(),anyBoolean(),anyBoolean(),anyString(),anyString())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantBusinessOpenGateway.Result(true,"BO-APPLY","90000000","审核中"));

        // 第一轮：通道侧还没有微信业务 → 只提交业务开通，配置这一步根本不碰。
        service.refreshOnboarding(principal,false);
        assertThat(statusOf("business_open_status",applicationNo)).isEqualTo("processing");
        verify(wechatConfigGateway,never()).configure(anyString(),anyString());
        // 保持 not_started，不写成 failed：这一步根本没试过。
        assertThat(statusOf("wechat_config_status",applicationNo)).isEqualTo("not_started");

        // 第二轮：通道侧已经开通线上场景 → 业务开通按已开通收口（不重复提交），配置才发出去。
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N",
                "qry_wx_conf_list",java.util.List.of(Map.of("pay_scene","4"))));
        when(wechatConfigGateway.configure(anyString(),anyString())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantWechatConfigGateway.Result(true,"00000000","成功"));

        service.refreshOnboarding(principal,false);

        // 业务开通只提交过一次——通道已开通时不再重复提交，避免第二份申请。
        verify(businessOpenGateway,times(1)).open(anyString(),anyString(),anyString(),anyString(),anyBoolean(),anyBoolean(),anyString(),anyString());
        verify(wechatConfigGateway,times(1)).configure(anyString(),anyString());
        assertThat(statusOf("business_open_status",applicationNo)).isEqualTo("approved");
        assertThat(statusOf("wechat_config_status",applicationNo)).isEqualTo("approved");
    }

    /** 微信配置失败不影响业务开通的推进与收口：两步各自记状态、各自可重试。 */
    @Test
    void aFailedWechatConfigDoesNotHoldBackTheBusinessOpen() {
        Map<String,Object> fixture=provisioningFixture();
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N",
                "qry_wx_conf_list",java.util.List.of(Map.of("pay_scene","4"))));
        when(wechatConfigGateway.configure(anyString(),anyString())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantWechatConfigGateway.Result(false,"00000001","参数非法"));

        service.refreshOnboarding((MerchantPrincipal)fixture.get("principal"),false);

        String applicationNo=String.valueOf(fixture.get("applicationNo"));
        // 业务开通照样收口为已开通（通道证据），不被另一步的失败牵连。
        assertThat(statusOf("business_open_status",applicationNo)).isEqualTo("approved");
        assertThat(statusOf("wechat_config_status",applicationNo)).isEqualTo("failed");
        assertThat(statusOf("reject_reason",applicationNo)).contains("参数非法");
    }

    /**
     * 延迟入账失败时把通道给的描述一起落库。
     *
     * <p>这一条失败回的是 {@code 99999999}（通道的「失败:&lt;原因&gt;」通用码），原先只存 code，
     * 描述一丢就完全看不出为什么失败——2026-09-16 排查时正是卡在这里。
     */
    @Test
    void aFailedDelayAttemptKeepsTheChannelMessage() {
        Map<String,Object> fixture=fixture();
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","N","forced_delay_flag","N"));
        when(gateway.configureDelay(anyString(),anyString(),anyString())).thenReturn(Map.of("resp_code","99999999","sub_resp_desc","复用交易信息，上级商户号为空"));

        service.refreshOnboarding((MerchantPrincipal)fixture.get("principal"),false);

        String message=jdbc.queryForObject("""
                select t.response_message from merchant_onboarding_attempt t
                join merchant_onboarding_application a on a.id=t.application_id
                where a.application_no=? and t.step='delay'
                """,String.class,String.valueOf(fixture.get("applicationNo")));
        assertThat(message).isEqualTo("复用交易信息，上级商户号为空");
    }

    /**
     * 通道按流水号去重：上一步被通道**明确驳回**后重试必须换新号，沿用旧号会被当成重复请求。
     * 进件与实名走的是同一条规则，业务开通与微信配置原本是复用——2026-09-16 被驳回后要重发时才发现。
     */
    @Test
    void aFailedBusinessOpenIsRetriedWithANewRequestNumber() {
        Map<String,Object> fixture=provisioningFixture();
        String applicationNo=String.valueOf(fixture.get("applicationNo"));
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N"));
        when(businessOpenGateway.open(anyString(),anyString(),anyString(),anyString(),anyBoolean(),anyBoolean(),anyString(),anyString())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantBusinessOpenGateway.Result(false,"","00000001","wx_conf_list格式错误"));

        MerchantPrincipal principal=(MerchantPrincipal)fixture.get("principal");
        service.refreshOnboarding(principal,false);
        assertThat(statusOf("business_open_status",applicationNo)).isEqualTo("failed");
        service.refreshOnboarding(principal,false);

        var requests=org.mockito.ArgumentCaptor.forClass(String.class);
        verify(businessOpenGateway,times(2)).open(requests.capture(),anyString(),anyString(),anyString(),anyBoolean(),anyBoolean(),anyString(),anyString());
        assertThat(requests.getAllValues()).doesNotHaveDuplicates();
        assertThat(requests.getAllValues().get(0)).isEqualTo(applicationNo+"BO");
        assertThat(statusOf("business_open_request_no",applicationNo)).isEqualTo(requests.getAllValues().get(1));
    }

    @Test
    void aFailedWechatConfigIsRetriedWithANewRequestNumber() {
        Map<String,Object> fixture=provisioningFixture();
        String applicationNo=String.valueOf(fixture.get("applicationNo"));
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S"));
        // 通道侧已开通线上场景，配置这一步才有东西可挂（见 advanceWechatConfig 的闸门）。
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N",
                "qry_wx_conf_list",java.util.List.of(Map.of("pay_scene","4"))));
        when(wechatConfigGateway.configure(anyString(),anyString())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuMerchantWechatConfigGateway.Result(false,"00000001","参数非法"));

        MerchantPrincipal principal=(MerchantPrincipal)fixture.get("principal");
        service.refreshOnboarding(principal,false);
        assertThat(statusOf("wechat_config_status",applicationNo)).isEqualTo("failed");
        service.refreshOnboarding(principal,false);

        var requests=org.mockito.ArgumentCaptor.forClass(String.class);
        verify(wechatConfigGateway,times(2)).configure(requests.capture(),anyString());
        assertThat(requests.getAllValues()).doesNotHaveDuplicates();
        assertThat(requests.getAllValues().get(0)).isEqualTo(applicationNo+"WC");
        assertThat(statusOf("wechat_config_request_no",applicationNo)).isEqualTo(requests.getAllValues().get(1));
    }

    private String statusOf(String column,String applicationNo) {
        return jdbc.queryForObject("select "+column+" from merchant_onboarding_application where application_no=?",String.class,applicationNo);
    }

    /**
     * 进件通过后**新增**的结算卡也要能从人工刷新那条路收敛为已批准。
     *
     * <p>它的状态原先只有绑定回调能推进（回调会丢，开发与内网环境根本收不到），而初次进件那张卡的
     * 查询对等物只认 {@code initial_bank_card_id}。补法是把同一条查询路径推广到该门店所有待处理的卡，
     * 不新增定时任务。
     */
    @Test
    void anAddedBankCardConvergesThroughTheSameManualRefresh() {
        Map<String,Object> fixture = fixture();
        MerchantPrincipal principal = (MerchantPrincipal) fixture.get("principal");
        String applicationNo = String.valueOf(fixture.get("applicationNo"));
        String addedCardKey = "T02ADD-" + applicationNo;
        jdbc.update("""
                insert into merchant_bank_card(merchant_id, store_id, bank_name, branch_name, city_code, card_tail,
                                               card_masked, card_hash, status, idempotency_key)
                values (?, ?, 'Bank', 'Branch', '510100', '5678', '****5678', ?, 'pending', ?)
                """, principal.merchantId(), principal.storeId(), sha256("622200009999"), addedCardKey);
        when(gateway.queryApplication(anyString(),anyString())).thenReturn(Map.of("resp_code","00000000","apply_status","Y","reg_status","S","bind_card_status","S"));
        when(gateway.queryCapabilities(anyString())).thenReturn(Map.of("resp_code","00000000","mer_stat","NORMAL","delay_flag","Y","forced_delay_flag","N",
                "qry_cash_card_info_list",java.util.List.of(Map.of("card_no","622200009999","token_no","added-card-token")),
                "qry_settle_config_list",java.util.List.of(Map.of("settle_status","1","settle_cycle","D1","settle_pattern","P0","min_amt","0","remained_amt","0","token_no","added-card-token"))));

        service.refreshOnboarding(principal,false);

        assertThat(jdbc.queryForObject("select status from merchant_bank_card where idempotency_key=?",String.class,addedCardKey))
                .as("新增的结算卡也要能靠查询收敛，而不是永远停在处理中")
                .isEqualTo("approved");
    }

    /**
     * 分阶段模型下重复提交不新建进件，也就不会在通道上多出一家商户。唯一的例外是补齐个人主体的
     * 门店照片：那是开通微信支付与发起微信实名的硬材料，而商户端没有别的补图入口——真实开发库里
     * 已经有拿到汇付商户号的个人进件停在这个形态上（有商户号、门店照片为空、业务开通没做过）。
     */
    @Test
    void resubmittingSuppliesTheMissingStorePhotosWithoutCreatingANewApplication() {
        Map<String,Object> fixture = individualProvisioningFixture();
        MerchantPrincipal principal = (MerchantPrincipal) fixture.get("principal");
        String applicationNo = String.valueOf(fixture.get("applicationNo"));

        service.submitOnboarding(principal, request("https://cdn.example.com/store-header.jpg","https://cdn.example.com/store-indoor.jpg"), "T02-store-"+System.nanoTime());

        assertThat(statusOf("store_header_url",applicationNo)).isEqualTo("https://cdn.example.com/store-header.jpg");
        assertThat(statusOf("store_indoor_url",applicationNo)).isEqualTo("https://cdn.example.com/store-indoor.jpg");
        assertThat(jdbc.queryForObject("select count(*) from merchant_onboarding_application where application_no=?",Integer.class,applicationNo)).isEqualTo(1);
        // 没有重新进件，原汇付商户号与银行卡关系都保持。
        assertThat(statusOf("provider_huifu_id",applicationNo)).isEqualTo("6666000241335656");
        assertThat(jdbc.queryForObject("select initial_bank_card_id from merchant_onboarding_application where application_no=?",Long.class,applicationNo)).isNotNull();
    }

    /** 已经有值的门店照片不会被重新提交覆盖。 */
    @Test
    void resubmittingDoesNotOverwriteAnExistingStorePhoto() {
        Map<String,Object> fixture = individualProvisioningFixture();
        MerchantPrincipal principal = (MerchantPrincipal) fixture.get("principal");
        String applicationNo = String.valueOf(fixture.get("applicationNo"));
        jdbc.update("update merchant_onboarding_application set store_header_url='https://cdn.example.com/original.jpg' where application_no=?", applicationNo);

        service.submitOnboarding(principal, request("https://cdn.example.com/other.jpg","https://cdn.example.com/store-indoor.jpg"), "T02-store-"+System.nanoTime());

        assertThat(statusOf("store_header_url",applicationNo)).isEqualTo("https://cdn.example.com/original.jpg");
        assertThat(statusOf("store_indoor_url",applicationNo)).isEqualTo("https://cdn.example.com/store-indoor.jpg");
    }

    /**
     * 存量进件缺「结算银行卡卡号面」时，重新提交要能补上。
     *
     * <p>这一列过去从来没落过库（2026-09-18 工单），库里也没有别的地方能还原它；而分阶段模型下
     * 重复提交不会新建进件，重提就是已提交进件唯一的补救入口，所以这条必须补得住。
     */
    @Test
    void resubmittingSuppliesTheMissingSettlementCardFront() {
        Map<String,Object> fixture = individualProvisioningFixture();
        MerchantPrincipal principal = (MerchantPrincipal) fixture.get("principal");
        String applicationNo = String.valueOf(fixture.get("applicationNo"));
        assertThat(statusOf("settlement_card_front_url",applicationNo)).isNull();

        service.submitOnboarding(principal, request(
                "https://cdn.example.com/store-header.jpg",
                "https://cdn.example.com/store-indoor.jpg",
                "https://cdn.example.com/card-front.jpg"), "T02-card-"+System.nanoTime());

        assertThat(statusOf("settlement_card_front_url",applicationNo)).isEqualTo("https://cdn.example.com/card-front.jpg");
        // 没有重新进件，原汇付商户号与银行卡关系都保持。
        assertThat(jdbc.queryForObject("select count(*) from merchant_onboarding_application where application_no=?",Integer.class,applicationNo)).isEqualTo(1);
    }

    /** 已经有值的卡号面不会被重新提交覆盖——存档的那张才是当时提交的。 */
    @Test
    void resubmittingDoesNotOverwriteAnExistingSettlementCardFront() {
        Map<String,Object> fixture = individualProvisioningFixture();
        MerchantPrincipal principal = (MerchantPrincipal) fixture.get("principal");
        String applicationNo = String.valueOf(fixture.get("applicationNo"));
        jdbc.update("update merchant_onboarding_application set settlement_card_front_url='https://cdn.example.com/original-card.jpg' where application_no=?", applicationNo);

        service.submitOnboarding(principal, request(
                "https://cdn.example.com/store-header.jpg",
                "https://cdn.example.com/store-indoor.jpg",
                "https://cdn.example.com/other-card.jpg"), "T02-card-"+System.nanoTime());

        assertThat(statusOf("settlement_card_front_url",applicationNo)).isEqualTo("https://cdn.example.com/original-card.jpg");
    }

    private Map<String,Object> individualProvisioningFixture() {
        String key="T02I-"+System.nanoTime();
        jdbc.update("insert into merchant(merchant_name,status,deleted) values (?,1,0)",key);
        Long merchant=jdbc.queryForObject("select id from merchant where merchant_name=?",Long.class,key);
        jdbc.update("insert into merchant_store(merchant_id,store_name,status,deleted) values (?,?,1,0)",merchant,key);
        Long store=jdbc.queryForObject("select id from merchant_store where merchant_id=?",Long.class,merchant);
        jdbc.update("insert into merchant_bank_card(merchant_id,store_id,bank_name,branch_name,city_code,card_tail,card_masked,card_hash,status,idempotency_key) values (?,?,'Bank','Branch','510100','1234','****1234',?,'approved',?)",merchant,store,key,key);
        Long card=jdbc.queryForObject("select id from merchant_bank_card where idempotency_key=?",Long.class,key);
        jdbc.update("insert into merchant_onboarding_application(merchant_id,store_id,application_no,subject_type,subject_name,contact_name,contact_mobile,idempotency_key,status,provider_huifu_id,provider_apply_no,initial_bank_card_id,business_open_status) values (?, ?, ?, 'individual','Owner','Owner','13700000000',?,'pending','6666000241335656','original-apply',?,'failed')",merchant,store,key,key,card);
        return Map.of("principal",new MerchantPrincipal(1L,merchant,store,"owner"),"applicationNo",key);
    }

    /** 补齐门店照片这一步只读这两项，其余字段留空即可。 */
    private static MerchantOnboardingRequest request(String storeHeaderUrl,String storeIndoorUrl) {
        return request(storeHeaderUrl, storeIndoorUrl, null);
    }

    private static MerchantOnboardingRequest request(String storeHeaderUrl,String storeIndoorUrl,String settlementCardFrontUrl) {
        return new MerchantOnboardingRequest("individual","Owner",null,null,null,null,null,null,null,null,
                null,null,"510100",null,null,null,null,null,null,null,null,null,null,null,null,null,
                "Owner","13700000000",null,null,"510100",null,settlementCardFrontUrl,null,storeHeaderUrl,storeIndoorUrl);
    }

    /**
     * 新提交的个人进件要把「结算银行卡卡号面」真的写进库。
     *
     * <p>在这之前那条 INSERT 的列清单里没有 {@code settlement_card_front_url}：商户端传了值、后端也
     * 拿它上传了汇付图片（F13），但写库时被静默丢掉，于是后台详情里这一格永远是 {@code -}。
     * 断言直接盯数据库那一列，不看接口返回值——返回值在修复前也是「成功」的。
     */
    @Test
    void aNewIndividualSubmissionPersistsTheSettlementCardFront() {
        String key = "T02C-" + System.nanoTime();
        jdbc.update("insert into merchant(merchant_name,merchant_type,status,deleted) values (?, '餐饮服务', 1, 0)", key);
        Long merchant = jdbc.queryForObject("select id from merchant where merchant_name=?", Long.class, key);
        jdbc.update("insert into merchant_store(merchant_id,store_name,status,deleted) values (?,?,1,0)", merchant, key);
        Long store = jdbc.queryForObject("select id from merchant_store where merchant_id=?", Long.class, merchant);
        String clearingCode = String.format("%012d", Math.abs(System.nanoTime() % 1_000_000_000_000L));
        jdbc.update("insert into bank_branch_directory(clearing_code,branch_name,bank_name,head_bank_code) values (?,?,?,?)",
                clearingCode, "测试支行", "测试银行", "HB" + clearingCode);
        when(pictureUploadGateway.uploadUrl(anyString(),anyString())).thenReturn("pic-id");
        // 通道递交刻意回「驳回」：写库发生在递交**之前**，而驳回会让流程就此收口，
        // 不再触发后面的开通链路——这条测试只关心那一列有没有落库，其余都是噪音。
        when(individualOnboardingGateway.create(any())).thenReturn(new com.talentcard.server.business.payment.huifu.HuifuIndividualOnboardingGateway.Result(false,"","","","00000001","参数非法"));

        service.submitOnboarding(new MerchantPrincipal(1L,merchant,store,"owner"), individualRequest(clearingCode), "T02-card-"+System.nanoTime());

        assertThat(jdbc.queryForObject("select settlement_card_front_url from merchant_onboarding_application where merchant_id=?",String.class,merchant))
                .as("上传了结算卡卡号面就必须落库，否则后台详情只能显示 -")
                .isEqualTo("https://cdn.example.com/card-front.jpg");
    }

    /** 个人进件的一次完整提交（除门店照片与结算卡卡号面外的必填项也都给上）。 */
    private static MerchantOnboardingRequest individualRequest(String clearingCode) {
        return new MerchantOnboardingRequest(
                "individual","测试负责人",null,"511623200211245724","fixed","2022-02-14","2032-02-14",
                null,null,null,"四川省 成都市 武侯区","510000","510100","510107","四川省邻水县丰禾镇9组108号",
                null,null,"其它",null,null,null,
                "https://cdn.example.com/id-front.jpg","https://cdn.example.com/id-back.jpg","四川省邻水县丰禾镇9组108号","13700000000","owner@example.com",
                "测试负责人","13700000000","6222000012345678","510000","510100",clearingCode,
                "https://cdn.example.com/card-front.jpg",null,
                "https://cdn.example.com/store-header.jpg","https://cdn.example.com/store-indoor.jpg");
    }

    /** 建一张还停在 not_started 的进件，用来观察刷新会不会去推进开通步骤。 */
    private Map<String,Object> provisioningFixture() {
        String key="T02P-"+System.nanoTime();