diff --git a/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_checkfile_service.kt b/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_checkfile_service.kt
index ec7db14..6f0ac9b 100644
--- a/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_checkfile_service.kt
+++ b/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_checkfile_service.kt
@@ -78,6 +78,7 @@
                         it.code = AgentCode.SUCCESS
                         it.agentMsg = "获取对账文件路径成功"
                         it.payload = sourceTypeService.saveOrUpdateSourceTypeCheckStatus(checkStatus.apply {
+                            this.checkFileOk = false
                             this.chkfileUrl = agentUrl
                         })
                     }
