定义agentservice 动态获取bean

diff --git a/payapi/src/main/java/com/supwisdom/dlpay/agent/AgentResponse.java b/payapi/src/main/java/com/supwisdom/dlpay/agent/AgentResponse.java
index 79bd0be..0906293 100644 (file)
--- a/payapi/src/main/java/com/supwisdom/dlpay/agent/AgentResponse.java
+++ b/payapi/src/main/java/com/supwisdom/dlpay/agent/AgentResponse.java
@@ -1,14 +1,41 @@
 package com.supwisdom.dlpay.agent;
 
-import lombok.Getter;
-import lombok.Setter;
-
-@Getter
-@Setter
 public class AgentResponse {
   private AgentCode code;
   private String agentCode;
   private String agentMsg;
 
   private String agentRefno;
+
+  public AgentCode getCode() {
+    return code;
+  }
+
+  public void setCode(AgentCode code) {
+    this.code = code;
+  }
+
+  public String getAgentCode() {
+    return agentCode;
+  }
+
+  public void setAgentCode(String agentCode) {
+    this.agentCode = agentCode;
+  }
+
+  public String getAgentMsg() {
+    return agentMsg;
+  }
+
+  public void setAgentMsg(String agentMsg) {
+    this.agentMsg = agentMsg;
+  }
+
+  public String getAgentRefno() {
+    return agentRefno;
+  }
+
+  public void setAgentRefno(String agentRefno) {
+    this.agentRefno = agentRefno;
+  }
 }

diff --git a/payapi/src/main/java/com/supwisdom/dlpay/agent/citizencard/YnrccRespCode.java b/payapi/src/main/java/com/supwisdom/dlpay/agent/citizencard/YnrccRespCode.java
index b1512d5..6fdd230 100644 (file)
--- a/payapi/src/main/java/com/supwisdom/dlpay/agent/citizencard/YnrccRespCode.java
+++ b/payapi/src/main/java/com/supwisdom/dlpay/agent/citizencard/YnrccRespCode.java
@@ -1,13 +1,27 @@
 package com.supwisdom.dlpay.agent.citizencard;
 
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.Setter;
-
-@Getter
-@Setter
-@AllArgsConstructor
 public class YnrccRespCode {
   private String code;
   private String msg;
+
+  public YnrccRespCode(String code, String msg) {
+    this.code = code;
+    this.msg = msg;
+  }
+
+  public String getCode() {
+    return code;
+  }
+
+  public void setCode(String code) {
+    this.code = code;
+  }
+
+  public String getMsg() {
+    return msg;
+  }
+
+  public void setMsg(String msg) {
+    this.msg = msg;
+  }
 }

diff --git a/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_service.kt b/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_service.kt
index 8e02f9d..93ec750 100644 (file)
--- a/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_service.kt
+++ b/payapi/src/main/kotlin/com/supwisdom/dlpay/agent/service/citizencard_service.kt
@@ -26,7 +26,7 @@ interface CitizencardPayService {
 
 }
 
-@Component
+@Component("citizenCardAgent")
 class CitizenCardPayAgent : AgentPayService {
     @Autowired
     private lateinit var citizencardPayService: CitizencardPayService

diff --git a/payapi/src/main/kotlin/com/supwisdom/dlpay/api/controller/consume_api_controller.kt b/payapi/src/main/kotlin/com/supwisdom/dlpay/api/controller/consume_api_controller.kt
index 2760298..45022c4 100644 (file)
--- a/payapi/src/main/kotlin/com/supwisdom/dlpay/api/controller/consume_api_controller.kt
+++ b/payapi/src/main/kotlin/com/supwisdom/dlpay/api/controller/consume_api_controller.kt
@@ -1,6 +1,7 @@
 package com.supwisdom.dlpay.api.controller
 
 import com.supwisdom.dlpay.agent.AgentCode
+import com.supwisdom.dlpay.agent.AgentPayService
 import com.supwisdom.dlpay.api.*
 import com.supwisdom.dlpay.api.bean.*
 import com.supwisdom.dlpay.api.service.*
@@ -12,6 +13,7 @@ import com.supwisdom.dlpay.framework.util.*
 import com.supwisdom.dlpay.agent.citizencard.YnrccUtil
 import com.supwisdom.dlpay.agent.service.CitizenCardPayAgent
 import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.context.ApplicationContext
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
@@ -36,9 +38,9 @@ class ConsumeAPIController {
     lateinit var cardService: CardService
     @Autowired
     lateinit var citizencardPayService: CitizencardPayService
-
     @Autowired
-    private lateinit var citizenCardPayAgent: CitizenCardPayAgent
+    private lateinit var applicationContext: ApplicationContext
+
     @Autowired
     lateinit var citizencardQueryResultTask: CitizencardQueryResultTask
 
@@ -201,6 +203,13 @@ class ConsumeAPIController {
                 .fail(TradeErrorCode.BUSINESS_PAYTYPE_NOSUPPORT, "不支持支付方式<市民卡代扣>"))
     }
 
+    fun createAgentService(sourceType: String): AgentPayService {
+        return applicationContext.getBean(sourceType + "Agent")?.let {
+            it as AgentPayService
+        } ?: throw TransactionCheckException(TradeErrorCode.BUSINESS_DEAL_ERROR,
+                "支付类型<$sourceType>未定义")
+    }
+
     /**
      * ============================================================================
      *                           市民卡【交易确认】
@@ -209,7 +218,8 @@ class ConsumeAPIController {
     @PostMapping("/citizencard/payfinish")
     fun citizencardPayinit(@Valid @RequestBody param: CitizenCardPayfinishParam): ResponseEntity<Any> {
         val dtl = transactionService.wip(param.refno)
-        val resp = citizenCardPayAgent.pay(dtl)
+        val service = createAgentService(TradeDict.PAYTYPE_CITIZEN_CARD)
+        val resp = service.pay(dtl)
         when (resp.code) {
             AgentCode.SUCCESS ->
                 transactionService.success(dtl.refno, resp.agentRefno, false).let {
@@ -261,48 +271,32 @@ class ConsumeAPIController {
 
             val cancelTrans = builder.cancelInit(mainDtl.refno, transactionService)
             transactionService.wip(cancelTrans.refno)
-            when {
-                TradeDict.PAYTYPE_BALANCE == mainDtl.sourceType -> {
-                    //余额支付，直接撤销
-                    transactionService.success(cancelTrans.refno)
+            val service = createAgentService(mainDtl.sourceType)
+            val resp = service.pay(cancelTrans)
+            when (resp.code) {
+                AgentCode.SUCCESS -> {
+                    transactionService.success(cancelTrans.refno, resp.agentRefno, false)
 
                     return ResponseEntity.ok(ResponseBodyBuilder.create()
                             .success(PayReverseResponse(cancelTrans.refno), "交易撤销成功"))
-
                 }
-                TradeDict.PAYTYPE_CITIZEN_CARD == mainDtl.sourceType -> {
-                    val resp = citizenCardPayAgent.pay(cancelTrans)
-                    when (resp.code) {
-                        AgentCode.SUCCESS -> {
-                            transactionService.success(cancelTrans.refno, resp.agentRefno, false)
-
-                            return ResponseEntity.ok(ResponseBodyBuilder.create()
-                                    .success(PayReverseResponse(cancelTrans.refno), "交易撤销成功"))
-                        }
-                        AgentCode.NEED_QUERY -> {
-                            //待查询
-                            citizencardQueryResultTask.queryResult(cancelTrans.refno, 0)
-                            return ResponseEntity.ok(ResponseBodyBuilder.create()
-                                    .fail(PayReverseResponse(cancelTrans.refno),
-                                            TradeErrorCode.WAIT_QUERY_RESULT, "请查询撤销结果"))
-                        }
-                        else -> transactionService.fail(cancelTrans.refno,
-                                "${resp.agentCode}-${resp.agentMsg}").let {
-                            return ResponseEntity.ok(ResponseBodyBuilder.create()
-                                    .fail(PayReverseResponse(cancelTrans.refno),
-                                            TradeErrorCode.WAIT_QUERY_RESULT, "请查询撤销结果"))
-                        }
-                    }
+                AgentCode.NEED_QUERY -> {
+                    //待查询
+                    citizencardQueryResultTask.queryResult(cancelTrans.refno, 0)
+                    return ResponseEntity.ok(ResponseBodyBuilder.create()
+                            .fail(PayReverseResponse(cancelTrans.refno),
+                                    TradeErrorCode.WAIT_QUERY_RESULT, "请查询撤销结果"))
+                }
+                else -> transactionService.fail(cancelTrans.refno,
+                        "${resp.agentCode}-${resp.agentMsg}").let {
+                    return ResponseEntity.ok(ResponseBodyBuilder.create()
+                            .fail(PayReverseResponse(cancelTrans.refno),
+                                    TradeErrorCode.WAIT_QUERY_RESULT, "请查询撤销结果"))
                 }
-                else -> return ResponseEntity.ok(ResponseBodyBuilder.create()
-                        .fail(PayReverseResponse(cancelTrans.refno),
-                                TradeErrorCode.BUSINESS_DEAL_ERROR, "暂不支持支付方式[${mainDtl.sourceType}]的流水撤销"))
             }
 
-
-        } ?: return ResponseEntity.ok(ResponseBodyBuilder.create()
-                .fail(PayReverseResponse(),
-                        TradeErrorCode.BUSINESS_DEAL_ERROR, "流水不存在"))
+        } ?: return ResponseEntity.ok(ResponseBodyBuilder.create().fail(PayReverseResponse(),
+                TradeErrorCode.BUSINESS_DEAL_ERROR, "流水不存在"))
     }
 
     /**
@@ -331,41 +325,31 @@ class ConsumeAPIController {
             }
             val refundTrans = builder.refundInit(mainDtl.refno, param.refundAmount / 100.0, transactionService)
             transactionService.wip(refundTrans.refno)
-            when {
-                TradeDict.PAYTYPE_BALANCE == mainDtl.sourceType -> {
-                    //余额支付，直接撤销
-                    transactionService.success(refundTrans.refno)
+            val service = createAgentService(mainDtl.sourceType)
+            val resp = service.refund(refundTrans)
 
-                    return ResponseEntity.ok(ResponseBodyBuilder.create()
-                            .success(PayReverseResponse(refundTrans.refno), "交易退款成功"))
+            when (resp.code) {
+                AgentCode.SUCCESS -> {
+                    transactionService.success(refundTrans.refno, resp.agentRefno, false)
 
+                    return ResponseEntity.ok(ResponseBodyBuilder.create()
+                            .success(PayReverseResponse(refundTrans.refno), "交易撤销成功"))
                 }
-                TradeDict.PAYTYPE_CITIZEN_CARD == mainDtl.sourceType -> {
-
-                    val resp = citizencardPayService.cardPayRefund(refundTrans.refno, refundTrans.accdate, mainDtl.refno, MoneyUtil.YuanToFen(mainDtl.personDtl.amount))
-                    when {
-                        YnrccUtil.CODE_SUCCESS == resp.code -> {
-                            transactionService.success(refundTrans.refno, resp.bankjourno, false)
-
-                            return ResponseEntity.ok(ResponseBodyBuilder.create()
-                                    .success(PayReverseResponse(refundTrans.refno), "交易退款成功"))
-                        }
-                        YnrccUtil.CODE_EXCEPTION == resp.code -> {
-                            //待查询
-                            citizencardQueryResultTask.queryResult(refundTrans.refno, 0)
-                            return ResponseEntity.ok(ResponseBodyBuilder.create()
-                                    .data("refundRefno", refundTrans.refno)
-                                    .fail(TradeErrorCode.WAIT_QUERY_RESULT, "请查询退款结果"))
-                        }
-                        else -> transactionService.fail(refundTrans.refno, resp.message).let {
-                            return ResponseEntity.ok(ResponseBodyBuilder.create()
-                                    .fail(TradeErrorCode.BUSINESS_DEAL_ERROR, "交易退款失败-${resp.message}"))
-                        }
-                    }
+                AgentCode.NEED_QUERY -> {
+                    //待查询
+                    citizencardQueryResultTask.queryResult(refundTrans.refno, 0)
+                    return ResponseEntity.ok(ResponseBodyBuilder.create()
+                            .fail(PayReverseResponse(refundTrans.refno),
+                                    TradeErrorCode.WAIT_QUERY_RESULT, "请查询撤销结果"))
+                }
+                else -> transactionService.fail(refundTrans.refno,
+                        "${resp.agentCode}-${resp.agentMsg}").let {
+                    return ResponseEntity.ok(ResponseBodyBuilder.create()
+                            .fail(PayReverseResponse(refundTrans.refno),
+                                    TradeErrorCode.WAIT_QUERY_RESULT, "请查询撤销结果"))
                 }
-                else -> return ResponseEntity.ok(ResponseBodyBuilder.create()
-                        .fail(TradeErrorCode.BUSINESS_DEAL_ERROR, "暂不支持支付方式[${mainDtl.sourceType}]的流水退款"))
             }
+
         } ?: return ResponseEntity.ok(ResponseBodyBuilder.create()
                 .fail(TradeErrorCode.TRANSACTION_NOT_EXISTS, "流水不存在"))
     }