leietal/senmesh-zc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
ran.shang
2025-06-11 09:42:13 +08:00
commit 7e38b8d971
1935 changed files with 132836 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/main/java/com/newyetai/alitaforward/common/mq/constant/ForwardMqConstants.java Normal file
View File

@@ -0,0 +1,15 @@
package com.newyetai.alitaforward.common.mq.constant;
import com.newyetai.common.constant.CommonConstants;
import com.newyetai.common.constant.SystemCodeEnum;
/**
* mq常量类(routingkey)
* @author sr on 2021-08-09
*/
public interface ForwardMqConstants {
/** 用户中心系统mq前缀 **/
String MQ_PREFIX = SystemCodeEnum.ALITA_FORWARD.getName() + CommonConstants.POINT;
}

29
src/main/java/com/newyetai/alitaforward/verification/constants/FactorVerificationSourceTypeEnum.java Normal file
View File

@@ -0,0 +1,29 @@
package com.newyetai.alitaforward.verification.constants;
/**
* @author czy
* @date 2021-06-21
*/
public enum FactorVerificationSourceTypeEnum {
FXQ("放心签", 1),
CL("创蓝", 2),
SYS("系统", 3);
private final String desc;
private final Integer type;
FactorVerificationSourceTypeEnum(String desc, Integer type) {
this.desc = desc;
this.type = type;
}
public String getDesc() {
return desc;
}
public Integer getType() {
return type;
}
}

33
src/main/java/com/newyetai/alitaforward/verification/constants/VerificationTypeEnum.java Normal file
View File

@@ -0,0 +1,33 @@
package com.newyetai.alitaforward.verification.constants;
import com.newyetai.alitaforward.common.mq.constant.ForwardMqConstants;
public enum VerificationTypeEnum {
/** 二要素认证 */
TWO("real_name_two_verification"),
/** 银行卡三要素认证 */
THREE("three_verification"),
/** 手机三要素认证 **/
PHONE_THREE("phone_three_verification"),
/** 银行卡四要素认证 **/
FOUR("four_verification");
private String fullname;
VerificationTypeEnum(String fullname){
this.fullname = fullname;
}
public String getFullName() {
return this.fullname;
}
public String getAsyncKey() {
return ForwardMqConstants.MQ_PREFIX + this.fullname ;
}
public String getStatusChangeKey() {
return getAsyncKey() + "_status_update";
}
}

64
src/main/java/com/newyetai/alitaforward/verification/consumer/providers/SystemFourFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,64 @@
package com.newyetai.alitaforward.verification.consumer.providers;
import cn.hutool.json.JSONUtil;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.PhoneThreeVerify;
import com.newyetai.alitaforward.verification.factor.ThreeVerify;
import com.newyetai.alitaforward.verification.service.FourFactorVerificationProvider;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.mq.dto.TopicMqMessage;
import com.newyetai.usercenter.user.consumer.FourFactorVerifyStatusUpdateHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class SystemFourFactorVerificationProvider implements FourFactorVerificationProvider {
@Autowired
private FourFactorVerifyStatusUpdateHandler fourFactorVerifyStatusUpdateHandler;
@Override
public void onMessage(TopicMqMessage<FourFactorVerificationDTO> message) {
log.info("系统手机号四要素处理->生成三要素数据 开始,参数：{}", JSONUtil.toJsonStr(message));
FourFactorVerificationDTO verificationDTO = message.getData();
Integer status = verificationDTO.getStatus();
if (!AuthStatusEnum.AUTH_SUCCESS.getType().equals(status)) {
return;
}
fourFactorVerifyStatusUpdateHandler.onMessage(verificationDTO);
try {
ThreeFactorVerificationDTO threeFactorVerificationDTO = ThreeFactorVerificationDTO.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.bankAccountNo(verificationDTO.getBankAccountNo())
.build();
threeFactorVerificationDTO.setStatus(verificationDTO.getStatus());
threeVerify.autoVerify(threeFactorVerificationDTO);
} catch (Exception e) {
log.info("系统手机号四要素处理->生成三要素数据 异常,", e);
}
try {
PhoneThreeFactorVerificationDTO phoneThreeFactorVerificationDTO = PhoneThreeFactorVerificationDTO.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.phone(verificationDTO.getPhone())
.build();
phoneThreeFactorVerificationDTO.setStatus(verificationDTO.getStatus());
phoneThreeVerify.autoVerify(phoneThreeFactorVerificationDTO);
} catch (Exception e) {
log.info("系统手机号四要素处理->生成手机三要素数据 异常,", e);
}
}
@Autowired
private PhoneThreeVerify phoneThreeVerify;
@Autowired
private ThreeVerify threeVerify;
}

46
src/main/java/com/newyetai/alitaforward/verification/consumer/providers/SystemPhoneThreeFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,46 @@
package com.newyetai.alitaforward.verification.consumer.providers;
import cn.hutool.json.JSONUtil;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.RealNameTwoVerify;
import com.newyetai.alitaforward.verification.service.PhoneThreeFactorVerificationProvider;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.mq.dto.TopicMqMessage;
import com.newyetai.usercenter.user.consumer.PhoneThreeFactorVerifyStatusUpdateHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class SystemPhoneThreeFactorVerificationProvider implements PhoneThreeFactorVerificationProvider {
@Autowired
private RealNameTwoVerify realNameTwoVerify;
@Autowired
private PhoneThreeFactorVerifyStatusUpdateHandler phoneThreeFactorVerifyStatusUpdateHandler;
@Override
public void onMessage(TopicMqMessage<PhoneThreeFactorVerificationDTO> message) {
log.info("系统手机号三要素成功处理->生成二要素数据 开始,参数：{}", JSONUtil.toJsonStr(message));
PhoneThreeFactorVerificationDTO verificationDTO = message.getData();
Integer status = verificationDTO.getStatus();
if (!AuthStatusEnum.AUTH_SUCCESS.getType().equals(status)) {
return;
}
phoneThreeFactorVerifyStatusUpdateHandler.onMessage(verificationDTO);
try {
RealNameTwoFactorVerificationDTO realNameTwoFactorVerificationDTO = RealNameTwoFactorVerificationDTO.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.build();
realNameTwoFactorVerificationDTO.setStatus(status);
realNameTwoVerify.autoVerify(realNameTwoFactorVerificationDTO);
} catch (Exception e) {
log.info("系统手机号三要素处理->生成二要素数据 异常,", e);
}
}
}

46
src/main/java/com/newyetai/alitaforward/verification/consumer/providers/SystemThreeFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,46 @@
package com.newyetai.alitaforward.verification.consumer.providers;
import cn.hutool.json.JSONUtil;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.RealNameTwoVerify;
import com.newyetai.alitaforward.verification.service.ThreeFactorVerificationProvider;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.mq.dto.TopicMqMessage;
import com.newyetai.usercenter.user.consumer.ThreeFactorVerifyStatusUpdateHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class SystemThreeFactorVerificationProvider implements ThreeFactorVerificationProvider {
@Autowired
private RealNameTwoVerify realNameTwoVerify;
@Autowired
private ThreeFactorVerifyStatusUpdateHandler threeFactorVerifyStatusUpdateHandler;
@Override
public void onMessage(TopicMqMessage<ThreeFactorVerificationDTO> message) {
log.info("系统三要素成功处理->生成二要素数据 开始,参数：{}", JSONUtil.toJsonStr(message));
ThreeFactorVerificationDTO verificationDTO = message.getData();
Integer status = verificationDTO.getStatus();
if (!AuthStatusEnum.AUTH_SUCCESS.getType().equals(status)) {
return;
}
threeFactorVerifyStatusUpdateHandler.onMessage(verificationDTO);
try {
RealNameTwoFactorVerificationDTO realNameTwoFactorVerificationDTO = RealNameTwoFactorVerificationDTO.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.build();
realNameTwoFactorVerificationDTO.setStatus(verificationDTO.getStatus());
realNameTwoVerify.autoVerify(realNameTwoFactorVerificationDTO);
} catch (Exception e) {
log.info("系统三要素处理->生成二要素数据 异常,", e);
}
}
}

214
src/main/java/com/newyetai/alitaforward/verification/controller/FactorVerificationContorller.java Normal file
View File

@@ -0,0 +1,214 @@
package com.newyetai.alitaforward.verification.controller;
import com.newyetai.alitaforward.verification.dto.*;
import com.newyetai.alitaforward.verification.factor.FourVerify;
import com.newyetai.alitaforward.verification.factor.PhoneThreeVerify;
import com.newyetai.alitaforward.verification.factor.RealNameTwoVerify;
import com.newyetai.alitaforward.verification.factor.ThreeVerify;
import com.newyetai.alitaforward.verification.service.BankCardVerificationService;
import com.newyetai.common.AlitaResult;
import com.newyetai.tkmybatis.pojo.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* @author czy
* @date 2021-06-21
*/
@Api("要素认证")
@RestController
@RequestMapping("factor_verify")
public class FactorVerificationContorller {
@Autowired
private FourVerify fourVerify;
@Autowired
private BankCardVerificationService bankCardVerificationService;
@Autowired
private RealNameTwoVerify realNameTwoVerify;
@Autowired
private ThreeVerify threeVerify;
@Autowired
private PhoneThreeVerify phoneThreeVerify;
@ApiOperation("二要素认证（同步）")
@PostMapping("/real_name/two/sync")
public AlitaResult<RealNameTwoFactorVerificationDTO> syncRealNameTwoAuthenticate(
@Validated @RequestBody RealNameTwoFactorVerificationDTO verificationInfo) {
return AlitaResult.success(realNameTwoVerify.sync(verificationInfo));
}
@ApiOperation("二要素认证（批量、同步）")
@PostMapping("/real_name/two/sync/batch")
public AlitaResult<List<RealNameTwoFactorVerificationDTO>> syncRealNameTwoAuthenticate(
@Validated @RequestBody List<RealNameTwoFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(realNameTwoVerify.sync(verificationInfoList));
}
@ApiOperation("二要素认证（异步）")
@PostMapping("/real_name/two/async")
public AlitaResult<RealNameTwoFactorVerificationDTO> asyncRealNameTwoAuthenticate(
@Validated @RequestBody RealNameTwoFactorVerificationDTO verificationInfo) {
return AlitaResult.success(realNameTwoVerify.async(verificationInfo));
}
@ApiOperation("二要素认证（批量、异步）")
@PostMapping("/real_name/two/async/batch")
public AlitaResult<List<RealNameTwoFactorVerificationDTO>> asyncRealNameTwoAuthenticate(
@Validated @RequestBody List<RealNameTwoFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(realNameTwoVerify.async(verificationInfoList));
}
@ApiOperation("手机三要素认证（同步）")
@PostMapping("/phone/three/sync")
public AlitaResult<PhoneThreeFactorVerificationDTO> syncPhoneThreeAuthenticate(
@Validated @RequestBody PhoneThreeFactorVerificationDTO verificationInfo) {
return AlitaResult.success(phoneThreeVerify.sync(verificationInfo));
}
@ApiOperation("手机三要素认证（批量、同步）")
@PostMapping("/phone/three/sync/batch")
public AlitaResult<List<PhoneThreeFactorVerificationDTO>> syncPhoneThreeAuthenticate(
@Validated @RequestBody List<PhoneThreeFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(phoneThreeVerify.sync(verificationInfoList));
}
@ApiOperation("手机三要素认证（异步）")
@PostMapping("/phone/three/async")
public AlitaResult<PhoneThreeFactorVerificationDTO> asyncPhoneThreeAuthenticate(
@Validated @RequestBody PhoneThreeFactorVerificationDTO verificationInfo) {
return AlitaResult.success(phoneThreeVerify.async(verificationInfo));
}
@ApiOperation("手机三要素认证（批量、异步）")
@PostMapping("/phone/three/async/batch")
public AlitaResult<List<PhoneThreeFactorVerificationDTO>> asyncPhoneThreeAuthenticate(
@Validated @RequestBody List<PhoneThreeFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(phoneThreeVerify.async(verificationInfoList));
}
@ApiOperation("三要素认证（同步）")
@PostMapping("/three/sync")
public AlitaResult<ThreeFactorVerificationDTO> syncThreeAuthenticate(
@Validated @RequestBody ThreeFactorVerificationDTO verificationInfo) {
return AlitaResult.success(threeVerify.sync(verificationInfo));
}
@ApiOperation("三要素认证（批量、同步）")
@PostMapping("/three/sync/batch")
public AlitaResult<List<ThreeFactorVerificationDTO>> syncThreeAuthenticate(
@Validated @RequestBody List<ThreeFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(threeVerify.sync(verificationInfoList));
}
@ApiOperation("三要素认证（异步）")
@PostMapping("/three/async")
public AlitaResult<ThreeFactorVerificationDTO> asyncThreeAuthenticate(
@Validated @RequestBody ThreeFactorVerificationDTO verificationInfo) {
return AlitaResult.success(threeVerify.async(verificationInfo));
}
@ApiOperation("三要素认证（批量、异步）")
@PostMapping("/three/async/batch")
public AlitaResult<List<ThreeFactorVerificationDTO>> asyncThreeAuthenticate(
@Validated @RequestBody List<ThreeFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(threeVerify.async(verificationInfoList));
}
@ApiOperation("获取匹配请求内容的三要素认证数据")
@PostMapping("/match_three/list")
public AlitaResult<List<ThreeFactorVerificationDTO>> queryMatchThreeList(@RequestBody List<FactorVerificationQueryDTO> queryDtoList){
return AlitaResult.success(threeVerify.queryListByData(queryDtoList));
};
@ApiOperation("三要素认证根据id获取")
@PostMapping("/three/find/id")
public AlitaResult<ThreeFactorVerificationDTO> threeFindById(@RequestParam("id") Long id){
return AlitaResult.success(threeVerify.findById(id));
};
@ApiOperation("三要素认证根据查询条件获取列表")
@PostMapping("/three/list")
public AlitaResult<List<ThreeFactorVerificationDTO>> threeList(@RequestBody FactorVerificationQueryDTO query){
query.setNeedPage(Boolean.FALSE);
return AlitaResult.success(threeVerify.list(query));
};
@ApiOperation("三要素认证根据查询条件获取列表（分页）")
@PostMapping("/three/page")
public AlitaResult<Page<ThreeFactorVerificationDTO>> threePage(@RequestBody FactorVerificationQueryDTO query){
threeVerify.list(query);
return AlitaResult.success(query.getPageResult());
};
@ApiOperation("四要素认证（同步）")
@PostMapping("/four/sync")
public AlitaResult<FourFactorVerificationDTO> syncFourAuthenticate(
@Validated @RequestBody FourFactorVerificationDTO verificationInfoList) {
return AlitaResult.success(fourVerify.sync(verificationInfoList));
}
@ApiOperation("四要素认证（批量、同步）")
@PostMapping("/four/sync/batch")
public AlitaResult<List<FourFactorVerificationDTO>> syncFourAuthenticate(
@Validated @RequestBody List<FourFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(fourVerify.sync(verificationInfoList));
}
@ApiOperation("四要素认证（异步）")
@PostMapping("/four/async")
public AlitaResult<FourFactorVerificationDTO> asyncFourAuthenticate(
@Validated @RequestBody FourFactorVerificationDTO verificationInfoList) {
return AlitaResult.success(fourVerify.async(verificationInfoList));
}
@ApiOperation("四要素认证（批量、异步）")
@PostMapping("/four/async/batch")
public AlitaResult<List<FourFactorVerificationDTO>> asyncFourAuthenticate(
@Validated @RequestBody List<FourFactorVerificationDTO> verificationInfoList) {
return AlitaResult.success(fourVerify.async(verificationInfoList));
}
@ApiOperation("四要素认证根据id获取")
@PostMapping("/four/find/id")
public AlitaResult<FourFactorVerificationDTO> fourFindById(@RequestParam("id") Long id){
return AlitaResult.success(fourVerify.findById(id));
};
@ApiOperation("获取匹配请求内容的四要素认证数据")
@PostMapping("/match_four/list")
public AlitaResult<List<FourFactorVerificationDTO>> queryMatchFourList(@RequestBody List<FactorVerificationQueryDTO> queryDtoList){
return AlitaResult.success(fourVerify.queryListByData(queryDtoList));
};
@ApiOperation("四要素认证根据查询条件获取列表")
@PostMapping("/four/list")
public AlitaResult<List<FourFactorVerificationDTO>> fourList(@RequestBody FactorVerificationQueryDTO query){
query.setNeedPage(Boolean.FALSE);
return AlitaResult.success(fourVerify.list(query));
};
@ApiOperation("四要素认证根据查询条件获取列表（分页）")
@PostMapping("/four/page")
public AlitaResult<Page<FourFactorVerificationDTO>> fourPage(@RequestBody FactorVerificationQueryDTO query){
fourVerify.list(query);
return AlitaResult.success(query.getPageResult());
};
@ApiOperation("白名单管理-->三、四要素查询合并为银行卡查询")
@PostMapping("/bank_card/page")
AlitaResult<List<BankCordVerificationResDTO>> bankCardPage(String cardNo,Integer status){
return AlitaResult.success(bankCardVerificationService.list(cardNo, status));
}
}

36
src/main/java/com/newyetai/alitaforward/verification/dao/BankCardVerificationMapper.java Normal file
View File

@@ -0,0 +1,36 @@
package com.newyetai.alitaforward.verification.dao;
import com.newyetai.alitaforward.verification.dto.BankCordVerificationResDTO;
import com.newyetai.alitaforward.verification.factor.four.entity.BankCardFourVerification;
import com.newyetai.tkmybatis.mybatis.MyMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/**
* @author fzp
* @date 2021年9月6日13:42:17
*/
public interface BankCardVerificationMapper{
/**
* 白名单管理-->三、四要素查询合并为银行卡查询
* @param cardNo
*/
@Select("select "
+ " t.id,t.card_no,t.real_name,t.bank_account_no,'' as phone,'三要素' as `type`, "
+ " (case t.authentication_source when '1' then '放心签' when '2' then '创蓝' when '3' then '系统' else '' end) as source, "
+ " t.status,t.fail_reason,t.deleted "
+ "from bank_card_three_verification t "
+ "where t.deleted = 0 and t.card_no = #{cardNo} "
+ "union all "
+ "select "
+ " f.id,f.card_no,f.real_name,f.bank_account_no,f.phone,'四要素' as `type`, "
+ " (case f.authentication_source when '1' then '放心签' when '2' then '创蓝' when '3' then '系统' else '' end) as source, "
+ " f.status,f.fail_reason,f.deleted "
+ "from bank_card_four_verification f "
+ "where f.deleted = 0 and f.card_no = #{cardNo} ")
List<BankCordVerificationResDTO> list(@Param("cardNo") String cardNo);
}

47
src/main/java/com/newyetai/alitaforward/verification/dto/BankCordVerificationResDTO.java Normal file
View File

@@ -0,0 +1,47 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
/**
* @author fzp
* @date 三、四要素合并银行卡查询
*/
@ApiModel("三、四要素合并银行卡查询")
@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class BankCordVerificationResDTO extends BaseDTO {
private static final long serialVersionUID = 4820612112161649806L;
@ApiModelProperty("姓名")
private String realName;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("银行卡号")
private String bankAccountNo;
@ApiModelProperty("手机号")
private String phone;
@ApiModelProperty("要素类型")
private String type;
@ApiModelProperty("认证来源 1系统，2放心签，3创蓝")
private String source;
@ApiModelProperty("认证状态(1-未认证 2-认证中 3-认证成功 4-认证失败)")
private Integer status;
@ApiModelProperty("失败原因")
private String failReason;
}

37
src/main/java/com/newyetai/alitaforward/verification/dto/FactorVerificationDTO.java Normal file
View File

@@ -0,0 +1,37 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author czy
* @date 2021-06-17
*/
@ApiModel("要素认证DTO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
@SuperBuilder
public class FactorVerificationDTO extends BaseDTO {
private static final long serialVersionUID = 2838128328843902963L;
@ApiModelProperty("认证状态(1-未认证 2-认证中 3-认证成功 4-认证失败)")
private Integer status;
@ApiModelProperty("认证来源")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
}

47
src/main/java/com/newyetai/alitaforward/verification/dto/FactorVerificationQueryDTO.java Normal file
View File

@@ -0,0 +1,47 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.annotation.trimAndUpper.TrimAndUpper;
import com.newyetai.common.dto.PageQueryDTO;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import java.util.Set;
/**
* @author czy
* @date 2021-07-01
*/
@EqualsAndHashCode(callSuper = true)
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class FactorVerificationQueryDTO extends PageQueryDTO {
private static final long serialVersionUID = -2357416347060650749L;
private Long id;
private Set<Long> ids;
@ApiModelProperty("姓名")
@TrimAndUpper
private String realName;
@ApiModelProperty("证件号")
@TrimAndUpper
private String cardNo;
@ApiModelProperty("银行卡号")
@TrimAndUpper
private String bankAccountNo;
@ApiModelProperty("手机号")
@TrimAndUpper
private String phone;
@ApiModelProperty("认证状态(1-未认证 2-认证中 3-认证成功 4-认证失败)")
private Integer status;
}

45
src/main/java/com/newyetai/alitaforward/verification/dto/FourFactorVerificationDTO.java Normal file
View File

@@ -0,0 +1,45 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.annotation.trimAndUpper.TrimAndUpper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
/**
* @author czy
* @date 2021-06-17
*/
@ApiModel("四要素认证DTO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class FourFactorVerificationDTO extends FactorVerificationDTO {
private static final long serialVersionUID = -5514764157174505641L;
@ApiModelProperty("姓名")
@NotBlank(message = "姓名不能为空")
@TrimAndUpper
private String realName;
@ApiModelProperty("证件号")
@NotBlank(message = "证件号不能为空")
@TrimAndUpper
private String cardNo;
@ApiModelProperty("银行卡号")
@NotBlank(message = "银行卡号不能为空")
@TrimAndUpper
private String bankAccountNo;
@ApiModelProperty("手机号")
@NotBlank(message = "手机号不能为空")
@TrimAndUpper
private String phone;
}

40
src/main/java/com/newyetai/alitaforward/verification/dto/PhoneThreeFactorVerificationDTO.java Normal file
View File

@@ -0,0 +1,40 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.annotation.trimAndUpper.TrimAndUpper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.SuperBuilder;
import javax.validation.constraints.NotBlank;
/**
* @author czy
* @date 2021-06-17
*/
@EqualsAndHashCode(callSuper = true)
@ApiModel("手机号三要素认证DTO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
public class PhoneThreeFactorVerificationDTO extends FactorVerificationDTO {
private static final long serialVersionUID = 1594482919800883278L;
@ApiModelProperty("姓名")
@NotBlank(message = "姓名不能为空")
@TrimAndUpper
private String realName;
@ApiModelProperty("证件号")
@NotBlank(message = "证件号不能为空")
@TrimAndUpper
private String cardNo;
@ApiModelProperty("手机号")
@NotBlank(message = "手机号不能为空")
@TrimAndUpper
private String phone;
}

35
src/main/java/com/newyetai/alitaforward/verification/dto/RealNameTwoFactorVerificationDTO.java Normal file
View File

@@ -0,0 +1,35 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.annotation.trimAndUpper.TrimAndUpper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.SuperBuilder;
import javax.validation.constraints.NotBlank;
/**
* 二要素认证DTO
*
* @author Administrator
* @date 2022/07/22
*/
@ApiModel("二要素认证DTO")
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class RealNameTwoFactorVerificationDTO extends FactorVerificationDTO {
private static final long serialVersionUID = -2114148883543603016L;
@ApiModelProperty("姓名")
@NotBlank(message = "姓名不能为空")
@TrimAndUpper
private String realName;
@ApiModelProperty("证件号")
@NotBlank(message = "证件号不能为空")
@TrimAndUpper
private String cardNo;
}

39
src/main/java/com/newyetai/alitaforward/verification/dto/ThreeFactorVerificationDTO.java Normal file
View File

@@ -0,0 +1,39 @@
package com.newyetai.alitaforward.verification.dto;
import com.newyetai.common.annotation.trimAndUpper.TrimAndUpper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.SuperBuilder;
import javax.validation.constraints.NotBlank;
/**
* @author czy
* @date 2021-06-17
*/
@ApiModel("三要素认证DTO")
@Data
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
@EqualsAndHashCode(callSuper = true)
public class ThreeFactorVerificationDTO extends FactorVerificationDTO {
private static final long serialVersionUID = 656164023756231640L;
@ApiModelProperty("姓名")
@NotBlank(message = "姓名不能为空")
@TrimAndUpper
private String realName;
@ApiModelProperty("证件号")
@NotBlank(message = "证件号不能为空")
@TrimAndUpper
private String cardNo;
@ApiModelProperty("银行卡号")
@NotBlank(message = "银行卡号不能为空")
@TrimAndUpper
private String bankAccountNo;
}

240
src/main/java/com/newyetai/alitaforward/verification/factor/AbstractVerify.java Normal file
View File

@@ -0,0 +1,240 @@
package com.newyetai.alitaforward.verification.factor;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationDTO;
import com.newyetai.alitaforward.verification.source.FactorVerificationSourceService;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.common.exception.util.Assert;
import com.newyetai.common.util.EnvironmentUtils;
import com.newyetai.common.util.JsonUtils;
import com.newyetai.frame.redis.dto.LockDTO;
import com.newyetai.frame.redis.redisson.RedissonUtils;
import com.newyetai.mq.consumer.handler.ITopicMqHandler;
import com.newyetai.mq.dto.TopicMqMessage;
import com.newyetai.mq.util.MqSendUtils;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
/**
* 要素校验顶层接口
*
* @author cheny
* @date 2022/08/11
*/
@Slf4j
@Component
@SuppressWarnings("rawtypes,unchecked")
public abstract class AbstractVerify<T extends FactorVerificationDTO> implements IVerify<T>, ITopicMqHandler<T>{
private static final Integer DEFAULT_TYPE = FactorVerificationSourceTypeEnum.CL.getType();
static final Map<Integer, FactorVerificationSourceService> SOURCE_SERVICE_MAP = Maps.newConcurrentMap();
/**
* 终态通知key
* @return
* @author sr on 2023-11-27
*/
final String statusChangeRoutingKey() {
return getType().getStatusChangeKey();
}
@Override
public final String getRoutingKey() {
return getType().getAsyncKey();
}
@Override
public final void onMessage(TopicMqMessage<T> message) {
T verificationDTO = message.getData();
log.info("【MQ】异步处理认证开始，参数：{}", JsonUtils.toJsonString(verificationDTO));
if (verificationDTO == null) {
return;
}
try {
T sync = this.sync(verificationDTO);
log.info("【MQ】异步处理认证结束，参数：{}", JsonUtils.toJsonString(sync));
} catch (Exception e) {
log.info("【MQ】异步处理认证异常", e);
}
}
// 幂等创建
abstract T createAndGet(T t);
/**
* 得到锁
*
* @param t t
* @return {@link LockDTO}
*/
abstract LockDTO getLock(T t);
// 上一级认证创建
abstract void autoVerify(T t);
/**
* 同步校验前置hook
*
* @param t t
* @return {@link T}
*/
protected T syncBeforeVerify(T t) {
// 认证源根据配置文件不同调用不同SDK 1放心签、2创蓝
String source = EnvironmentUtils.getProperty("alita.authenticationSource");
int authenticationSource = DEFAULT_TYPE;
try {
authenticationSource = Integer.parseInt(source);
//如果不是这两种认证源,用默认的源
if (!(FactorVerificationSourceTypeEnum.CL.getType().equals(authenticationSource)
|| FactorVerificationSourceTypeEnum.FXQ.getType().equals(authenticationSource))) {
authenticationSource = DEFAULT_TYPE;
}
} catch (NumberFormatException e) {
//doNothing
}
t.setAuthenticationSource(authenticationSource);
return t;
}
/**
* 真正执行校验逻辑的方法
*
* @param verifyDto 验证dto
* @return {@link T}
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public T doSyncVerify(T verifyDto) {
String failReason = verifyDto.getFailReason();
//如果校验失败了 直接返回
if (StringUtils.isNotEmpty(failReason)) {
return verifyDto;
}
//拿锁
LockDTO lockDTO = getLock(verifyDto);
try {
Assert.isTrue(RedissonUtils.tryLock(lockDTO), "要素认证正在处理中,请稍后再试");
T preVerifyDto = createAndGet(verifyDto);
//如果不是待认证的数直接返回
if (!AuthStatusEnum.NOT_AUTH.getType().equals(preVerifyDto.getStatus())) {
return preVerifyDto;
}
return realVerification(preVerifyDto);
} finally {
RedissonUtils.unlock(lockDTO);
}
}
abstract T realVerification(T verificationDTO);
T syncVerifyWrapper(T t) {
T beforeVerify = syncBeforeVerify(t);
T doVerify = (T) ((AbstractVerify) AopContext.currentProxy()).doSyncVerify(beforeVerify);
Integer status = doVerify.getStatus();
//如果执行到了终态 发送消息通知
if (AuthStatusEnum.AUTH_FAIL.getType().equals(status)
|| AuthStatusEnum.AUTH_SUCCESS.getType().equals(status)) {
log.info("【MQ】通知认证状态变更，参数：{}", JSONUtil.toJsonStr(doVerify));
MqSendUtils.send(statusChangeRoutingKey(), doVerify);
}
return doVerify;
}
/**
* 同步校验
*
* @param list 列表
* @return {@link List}<{@link T}>
*/
@Override
public List<T> sync(List<T> list) {
if (CollectionUtils.isEmpty(list)) {
return Lists.newArrayList();
}
return list.stream().map(this::syncVerifyWrapper).collect(Collectors.toList());
}
// -------------------------------------------------------- async -------------------------------------------------------
/**
* 异步校验前置hook
*
* @param t t
* @return {@link T}
*/
protected T asyncBeforeVerify(T t) {
return syncBeforeVerify(t);
}
/**
* 真正执行校验逻辑的方法
*
* @param verifyDto 验证dto
* @return {@link T}
*/
protected T doAsyncVerify(T verifyDto) {
String failReason = verifyDto.getFailReason();
//如果校验失败了 直接返回
if (StringUtils.isNotEmpty(failReason)) {
return verifyDto;
}
//拿锁
LockDTO lockDTO = getLock(verifyDto);
try {
Assert.isTrue(RedissonUtils.tryLock(lockDTO), "要素认证正在处理中,请稍后再试");
T preVerifyDto = createAndGet(verifyDto);
//如果不是待认证的数直接返回
if (AuthStatusEnum.NOT_AUTH.getType().equals(preVerifyDto.getStatus())) {
//mq异步处理认证
log.info("async【MQ】要素认证异步处理,参数：{}", JSONUtil.toJsonStr(preVerifyDto));
MqSendUtils.send(getRoutingKey(), preVerifyDto);
}
return preVerifyDto;
} finally {
RedissonUtils.unlock(lockDTO);
}
}
T asyncVerifyWrapper(T t) {
T beforeVerify = asyncBeforeVerify(t);
T doVerify = doAsyncVerify(beforeVerify);
Integer status = doVerify.getStatus();
//如果执行到了终态 发送消息通知
if (AuthStatusEnum.AUTH_FAIL.getType().equals(status)
|| AuthStatusEnum.AUTH_SUCCESS.getType().equals(status)) {
log.info("【MQ】通知认证状态变更，参数：{}", JSONUtil.toJsonStr(doVerify));
MqSendUtils.send(statusChangeRoutingKey(), doVerify);
}
return doVerify;
}
@Override
public List<T> async(List<T> list) {
if (CollectionUtils.isEmpty(list)) {
return Lists.newArrayList();
}
return list.stream().map(this::asyncVerifyWrapper).collect(Collectors.toList());
}
}

176
src/main/java/com/newyetai/alitaforward/verification/factor/FourVerify.java Normal file
View File

@@ -0,0 +1,176 @@
package com.newyetai.alitaforward.verification.factor;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import com.google.common.collect.Lists;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.four.dao.FourVerificationMapper;
import com.newyetai.alitaforward.verification.factor.four.entity.BankCardFourVerification;
import com.newyetai.alitaforward.verification.factor.four.mapstruct.FourVerificationMapMapper;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.common.exception.util.Assert;
import com.newyetai.common.util.UserContextHolder;
import com.newyetai.common.validation.util.ValidateUtils;
import com.newyetai.frame.redis.aop.annotation.AutoUnLock;
import com.newyetai.frame.redis.dto.LockDTO;
import com.newyetai.frame.redis.redisson.RedissonUtils;
import com.newyetai.mq.util.MqSendUtils;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Component
public class FourVerify extends AbstractVerify<FourFactorVerificationDTO> implements IQueryVerify<FourFactorVerificationDTO> {
@Resource
private FourVerificationMapper fourVerificationMapper;
@Override
protected FourFactorVerificationDTO syncBeforeVerify(FourFactorVerificationDTO verificationDTO) {
StringJoiner stringJoiner = new StringJoiner("、");
if (!ValidateUtils.checkRealName(verificationDTO.getRealName())) {
stringJoiner.add("姓名格式有误");
}
if (!ValidateUtils.isIdCard(verificationDTO.getCardNo())) {
stringJoiner.add("证件号格式有误");
}
if (StringUtils.isBlank(verificationDTO.getBankAccountNo())) {
stringJoiner.add("银行卡号为空");
}
if (StringUtils.isBlank(verificationDTO.getPhone())) {
stringJoiner.add("手机号为空");
}
String failReason = stringJoiner.toString();
if (StringUtils.isNotBlank(failReason)) {
verificationDTO.setFailReason(failReason);
} else {
//校验成功调用
super.syncBeforeVerify(verificationDTO);
}
return verificationDTO;
}
@Override
FourFactorVerificationDTO createAndGet(FourFactorVerificationDTO verificationDTO) {
BankCardFourVerification bankCardFourVerification = fourVerificationMapper.selectInfo(verificationDTO);
if (bankCardFourVerification == null) {
//认证库不存在，以默认状态入库——"未认证"
verificationDTO.setStatus(AuthStatusEnum.NOT_AUTH.getType());
bankCardFourVerification = FourVerificationMapMapper.INSTANCE.toEntity(verificationDTO);
fourVerificationMapper.saveEntity(bankCardFourVerification);
}
return FourVerificationMapMapper.INSTANCE.toDto(bankCardFourVerification);
}
@Override
LockDTO getLock(FourFactorVerificationDTO verificationDTO) {
return LockDTO.builder().methodName("verify:four").tryLockWaitTime(0L)
.arg(verificationDTO.getRealName())
.arg(verificationDTO.getCardNo())
.arg(verificationDTO.getBankAccountNo())
.arg(verificationDTO.getPhone())
.build();
}
@Override
@AutoUnLock
public void autoVerify(FourFactorVerificationDTO verificationDTO) {
//拿锁
LockDTO lockDTO = getLock(verificationDTO);
Assert.isTrue(RedissonUtils.tryLockAutomatically(lockDTO), "请勿重复校验四要素");
BankCardFourVerification verificationEntity = fourVerificationMapper.selectInfo(verificationDTO);
if (Objects.nonNull(verificationEntity)) {
if (AuthStatusEnum.AUTH_SUCCESS.getType().equals(verificationEntity.getStatus())) {
return;
}
verificationEntity.setAuthenticationSource(FactorVerificationSourceTypeEnum.SYS.getType());
verificationEntity.setStatus(AuthStatusEnum.AUTH_SUCCESS.getType());
fourVerificationMapper.updateEntitySelective(verificationEntity,
UserContextHolder.getLoginUserId());
} else {
verificationEntity =
BankCardFourVerification.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.phone(verificationDTO.getPhone())
.bankAccountNo(verificationDTO.getBankAccountNo())
.authenticationSource(FactorVerificationSourceTypeEnum.SYS.getType())
.status(AuthStatusEnum.AUTH_SUCCESS.getType())
.build();
fourVerificationMapper.saveEntity(verificationEntity);
}
log.info("【MQ】通知认证状态变更，参数：{}", JSONUtil.toJsonStr(verificationDTO));
MqSendUtils.send(statusChangeRoutingKey(), verificationDTO);
}
@Override
public List<FourFactorVerificationDTO> list(FactorVerificationQueryDTO queryDTO) {
return fourVerificationMapper.list(queryDTO);
}
@Override
public List<FourFactorVerificationDTO> queryListByData(List<FactorVerificationQueryDTO> queryDTOList) {
List<FourFactorVerificationDTO> resultList = Lists
.newArrayListWithCapacity(queryDTOList.size());
if (CollectionUtils.isEmpty(queryDTOList)) {
return resultList;
}
List<FourFactorVerificationDTO> bankCardThreeVerifications = fourVerificationMapper
.findFinishStatusData();
Map<String, FourFactorVerificationDTO> threeVerificationMap = bankCardThreeVerifications
.stream().collect(
Collectors.toMap(k -> k.getRealName() + k.getCardNo() + k.getBankAccountNo() + k.getPhone(), v -> v, (v1, v2) -> v1));
for (FactorVerificationQueryDTO queryDTO : queryDTOList) {
FourFactorVerificationDTO FourFactorVerificationDTO = threeVerificationMap
.get(queryDTO.getRealName() + queryDTO.getCardNo() + queryDTO.getBankAccountNo() + queryDTO
.getPhone());
if (FourFactorVerificationDTO != null) {
resultList.add(FourFactorVerificationDTO);
}
}
return resultList;
}
@Override
public FourFactorVerificationDTO findById(Long id) {
FourFactorVerificationDTO fourFactorVerificationDTO = null;
BankCardFourVerification entity = fourVerificationMapper.getById(id);
if (entity != null) {
fourFactorVerificationDTO = FourVerificationMapMapper.INSTANCE.toDto(entity);
}
return fourFactorVerificationDTO;
}
@Override
FourFactorVerificationDTO realVerification(FourFactorVerificationDTO verificationDTO) {
Integer authenticationSource = verificationDTO.getAuthenticationSource();
SOURCE_SERVICE_MAP.get(authenticationSource).fourVerify(verificationDTO);
//更新状态
BankCardFourVerification entity = FourVerificationMapMapper.INSTANCE
.toEntity(verificationDTO);
fourVerificationMapper.updateEntitySelective(entity, UserContextHolder.getLoginUserId());
return verificationDTO;
}
@Override
public VerificationTypeEnum getType() {
return VerificationTypeEnum.FOUR;
}
}

42
src/main/java/com/newyetai/alitaforward/verification/factor/IQueryVerify.java Normal file
View File

@@ -0,0 +1,42 @@
package com.newyetai.alitaforward.verification.factor;
import com.newyetai.alitaforward.verification.dto.FactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import java.util.List;
/**
* 要素查询顶层接口
*
* @author cheny
* @date 2022/08/11
*/
public interface IQueryVerify<T extends FactorVerificationDTO> {
/**
* 根据参数查list
*
* @param queryDTO 查询DTO
* @return {@link List}<{@link T}>
*/
List<T> list(FactorVerificationQueryDTO queryDTO);
/**
* 根据传来的数据，查出认证库中存在的数据
*
* @param queryDTOList 查询DTO集合
* @return {@link List}<{@link T}>
*/
List<T> queryListByData(List<FactorVerificationQueryDTO> queryDTOList);
/**
* 根据id获取
*
* @param id id
* @return {@link T}
*/
T findById(Long id);
}

48
src/main/java/com/newyetai/alitaforward/verification/factor/IVerify.java Normal file
View File

@@ -0,0 +1,48 @@
package com.newyetai.alitaforward.verification.factor;
import java.util.ArrayList;
import java.util.List;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
/**
* 要素校验顶层接口
*
* @author cheny
* @date 2022/08/11
*/
public interface IVerify<T> {
/**
* 同步校验
*
* @param list 列表
* @return {@link List}<{@link T}>
*/
List<T> sync(List<T> list);
/**
* 异步校验
*
* @param list 列表
* @return {@link List}<{@link T}>
*/
List<T> async(List<T> list);
default T sync(T t) {
List<T> syncSingle = new ArrayList<>(1);
syncSingle.add(t);
return sync(syncSingle).get(0);
}
default T async(T t) {
List<T> asyncSingle = new ArrayList<>(1);
asyncSingle.add(t);
return async(asyncSingle).get(0);
}
VerificationTypeEnum getType();
}

170
src/main/java/com/newyetai/alitaforward/verification/factor/PhoneThreeVerify.java Normal file
View File

@@ -0,0 +1,170 @@
package com.newyetai.alitaforward.verification.factor;
import cn.hutool.json.JSONUtil;
import com.google.common.collect.Lists;
import com.newyetai.alitaforward.common.mq.constant.ForwardMqConstants;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.phoneThree.dao.PhoneThreeVerificationMapper;
import com.newyetai.alitaforward.verification.factor.phoneThree.entity.PhoneThreeVerification;
import com.newyetai.alitaforward.verification.factor.phoneThree.mapstruct.PhoneThreeVerificationMapMapper;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.common.exception.util.Assert;
import com.newyetai.common.util.UserContextHolder;
import com.newyetai.common.validation.util.ValidateUtils;
import com.newyetai.frame.redis.aop.annotation.AutoUnLock;
import com.newyetai.frame.redis.dto.LockDTO;
import com.newyetai.frame.redis.redisson.RedissonUtils;
import com.newyetai.mq.util.MqSendUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.stream.Collectors;
@Slf4j
@Component
public class PhoneThreeVerify extends AbstractVerify<PhoneThreeFactorVerificationDTO> implements IQueryVerify<PhoneThreeFactorVerificationDTO> {
@Resource
private PhoneThreeVerificationMapper phoneThreeVerificationMapper;
@Override
protected PhoneThreeFactorVerificationDTO syncBeforeVerify(PhoneThreeFactorVerificationDTO verificationDTO) {
StringJoiner stringJoiner = new StringJoiner("、");
if (!ValidateUtils.checkRealName(verificationDTO.getRealName())) {
stringJoiner.add("姓名格式有误");
}
if (!ValidateUtils.isIdCard(verificationDTO.getCardNo())) {
stringJoiner.add("证件号格式有误");
}
if (StringUtils.isBlank(verificationDTO.getPhone())) {
stringJoiner.add("手机号为空");
}
String failReason = stringJoiner.toString();
if (StringUtils.isNotBlank(failReason)) {
verificationDTO.setFailReason(failReason);
} else {
//校验成功调用
super.syncBeforeVerify(verificationDTO);
}
return verificationDTO;
}
@Override
PhoneThreeFactorVerificationDTO createAndGet(PhoneThreeFactorVerificationDTO verificationDTO) {
PhoneThreeVerification entity = phoneThreeVerificationMapper.find(verificationDTO);
if (entity == null) {
//认证库不存在，以默认状态入库——"未认证"
verificationDTO.setStatus(AuthStatusEnum.NOT_AUTH.getType());
entity = PhoneThreeVerificationMapMapper.INSTANCE.exchange(verificationDTO);
phoneThreeVerificationMapper.saveEntity(entity);
}
return PhoneThreeVerificationMapMapper.INSTANCE.exchange(entity);
}
@Override
LockDTO getLock(PhoneThreeFactorVerificationDTO verificationDTO) {
return LockDTO.builder()
.methodName("verify:three:phone")
.tryLockWaitTime(0L)
.arg(verificationDTO.getRealName())
.arg(verificationDTO.getCardNo())
.arg(verificationDTO.getPhone())
.build();
}
@Override
@AutoUnLock
public void autoVerify(PhoneThreeFactorVerificationDTO verificationDTO) {
//拿锁
LockDTO lockDTO = getLock(verificationDTO);
Assert.isTrue(RedissonUtils.tryLockAutomatically(lockDTO), "请勿重复校验手机三要素");
PhoneThreeVerification verificationEntity = phoneThreeVerificationMapper.find(verificationDTO);
if (Objects.nonNull(verificationEntity)) {
if (!AuthStatusEnum.NOT_AUTH.getType().equals(verificationEntity.getStatus())) {
return;
}
verificationEntity.setAuthenticationSource(FactorVerificationSourceTypeEnum.SYS.getType());
verificationEntity.setStatus(verificationDTO.getStatus());
phoneThreeVerificationMapper.updateEntitySelective(verificationEntity,
UserContextHolder.getLoginUserId());
} else {
verificationEntity =
PhoneThreeVerification.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.phone(verificationDTO.getPhone())
.authenticationSource(FactorVerificationSourceTypeEnum.SYS.getType())
.status(verificationDTO.getStatus())
.build();
phoneThreeVerificationMapper.saveEntity(verificationEntity);
}
log.info("【MQ】通知认证状态变更，参数：{}", JSONUtil.toJsonStr(verificationDTO));
MqSendUtils.send(statusChangeRoutingKey(), verificationDTO);
}
@Override
public List<PhoneThreeFactorVerificationDTO> list(FactorVerificationQueryDTO queryDTO) {
return phoneThreeVerificationMapper.list(queryDTO);
}
@Override
public List<PhoneThreeFactorVerificationDTO> queryListByData(List<FactorVerificationQueryDTO> queryDTOList) {
List<PhoneThreeFactorVerificationDTO> resultList = Lists
.newArrayListWithCapacity(queryDTOList.size());
if (CollectionUtils.isEmpty(queryDTOList)) {
return resultList;
}
List<PhoneThreeFactorVerificationDTO> bankCardThreeVerifications = phoneThreeVerificationMapper
.findFinishStatusData();
Map<String, PhoneThreeFactorVerificationDTO> threeVerificationMap = bankCardThreeVerifications
.stream().collect(
Collectors.toMap(k -> k.getRealName() + k.getCardNo() + k.getPhone(), v -> v, (v1, v2) -> v1));
for (FactorVerificationQueryDTO queryDTO : queryDTOList) {
PhoneThreeFactorVerificationDTO PhoneThreeFactorVerificationDTO = threeVerificationMap
.get(queryDTO.getRealName() + queryDTO.getCardNo() + queryDTO.getPhone());
if (PhoneThreeFactorVerificationDTO != null) {
resultList.add(PhoneThreeFactorVerificationDTO);
}
}
return resultList;
}
@Override
public PhoneThreeFactorVerificationDTO findById(Long id) {
PhoneThreeFactorVerificationDTO threeFactorVerificationDTO = null;
PhoneThreeVerification entity = phoneThreeVerificationMapper.getById(id);
if (entity != null) {
threeFactorVerificationDTO = PhoneThreeVerificationMapMapper.INSTANCE.exchange(entity);
}
return threeFactorVerificationDTO;
}
@Override
PhoneThreeFactorVerificationDTO realVerification(
PhoneThreeFactorVerificationDTO verificationDTO) {
Integer authenticationSource = verificationDTO.getAuthenticationSource();
SOURCE_SERVICE_MAP.get(authenticationSource).phoneThreeVerify(verificationDTO);
//更新状态
PhoneThreeVerification entity = PhoneThreeVerificationMapMapper.INSTANCE.exchange(verificationDTO);
phoneThreeVerificationMapper.updateEntitySelective(entity, UserContextHolder.getLoginUserId());
return verificationDTO;
}
@Override
public VerificationTypeEnum getType() {
return VerificationTypeEnum.PHONE_THREE;
}
}

165
src/main/java/com/newyetai/alitaforward/verification/factor/RealNameTwoVerify.java Normal file
View File

@@ -0,0 +1,165 @@
package com.newyetai.alitaforward.verification.factor;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import com.google.common.collect.Lists;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.two.convert.RealNameTwoVerificationConvert;
import com.newyetai.alitaforward.verification.factor.two.dao.RealNameTwoVerificationMapper;
import com.newyetai.alitaforward.verification.factor.two.entity.RealNameTwoVerification;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.common.exception.util.Assert;
import com.newyetai.common.util.UserContextHolder;
import com.newyetai.common.validation.util.ValidateUtils;
import com.newyetai.frame.redis.aop.annotation.AutoUnLock;
import com.newyetai.frame.redis.dto.LockDTO;
import com.newyetai.frame.redis.redisson.RedissonUtils;
import com.newyetai.mq.util.MqSendUtils;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Component
public class RealNameTwoVerify extends AbstractVerify<RealNameTwoFactorVerificationDTO> implements IQueryVerify<RealNameTwoFactorVerificationDTO> {
@Resource
private RealNameTwoVerificationMapper realNameTwoVerificationMapper;
@Override
protected RealNameTwoFactorVerificationDTO syncBeforeVerify(RealNameTwoFactorVerificationDTO verificationDTO) {
StringJoiner stringJoiner = new StringJoiner("、");
if (!ValidateUtils.checkRealName(verificationDTO.getRealName())) {
stringJoiner.add("姓名格式有误");
}
if (!ValidateUtils.isIdCard(verificationDTO.getCardNo())) {
stringJoiner.add("证件号格式有误");
}
String failReason = stringJoiner.toString();
if (StringUtils.isNotBlank(failReason)) {
verificationDTO.setFailReason(failReason);
} else {
//校验成功调用
super.syncBeforeVerify(verificationDTO);
}
return verificationDTO;
}
@Override
RealNameTwoFactorVerificationDTO createAndGet(RealNameTwoFactorVerificationDTO verificationDTO) {
RealNameTwoVerification entity = realNameTwoVerificationMapper.selectInfo(verificationDTO);
if (entity == null) {
//认证库不存在，以默认状态入库——"未认证"
verificationDTO.setStatus(AuthStatusEnum.NOT_AUTH.getType());
entity = RealNameTwoVerificationConvert.INSTANCE.convert(verificationDTO);
realNameTwoVerificationMapper.saveEntity(entity);
}
return RealNameTwoVerificationConvert.INSTANCE.convertDTO(entity);
}
@Override
LockDTO getLock(RealNameTwoFactorVerificationDTO verificationDTO) {
return LockDTO.builder()
.methodName("verify:real_name:two")
.tryLockWaitTime(0L)
.arg(verificationDTO.getRealName())
.arg(verificationDTO.getCardNo())
.build();
}
@Override
@AutoUnLock
public void autoVerify(RealNameTwoFactorVerificationDTO verificationDTO) {
//拿锁
LockDTO lockDTO = getLock(verificationDTO);
Assert.isTrue(RedissonUtils.tryLockAutomatically(lockDTO), "请勿重复校验二要素");
RealNameTwoVerification realNameTwoVerification = realNameTwoVerificationMapper.selectInfo(verificationDTO);
if (Objects.nonNull(realNameTwoVerification)) {
if (!AuthStatusEnum.NOT_AUTH.getType().equals(realNameTwoVerification.getStatus())) {
return;
}
realNameTwoVerification.setAuthenticationSource(FactorVerificationSourceTypeEnum.SYS.getType());
realNameTwoVerification.setStatus(verificationDTO.getStatus());
realNameTwoVerificationMapper.updateEntitySelective(realNameTwoVerification,
UserContextHolder.getLoginUserId());
} else {
realNameTwoVerification =
RealNameTwoVerification.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.authenticationSource(FactorVerificationSourceTypeEnum.SYS.getType())
.status(verificationDTO.getStatus())
.build();
realNameTwoVerificationMapper.saveEntity(realNameTwoVerification);
}
log.info("【MQ】通知认证状态变更，参数：{}", JSONUtil.toJsonStr(verificationDTO));
MqSendUtils.send(statusChangeRoutingKey(), verificationDTO);
}
@Override
public List<RealNameTwoFactorVerificationDTO> list(FactorVerificationQueryDTO queryDTO) {
return realNameTwoVerificationMapper.list(queryDTO);
}
@Override
public List<RealNameTwoFactorVerificationDTO> queryListByData(List<FactorVerificationQueryDTO> queryDTOList) {
List<RealNameTwoFactorVerificationDTO> resultList = Lists
.newArrayListWithCapacity(queryDTOList.size());
if (CollectionUtils.isEmpty(queryDTOList)) {
return resultList;
}
List<RealNameTwoFactorVerificationDTO> bankCardThreeVerifications = realNameTwoVerificationMapper
.findFinishStatusData();
Map<String, RealNameTwoFactorVerificationDTO> threeVerificationMap = bankCardThreeVerifications
.stream().collect(
Collectors.toMap(k -> k.getRealName() + k.getCardNo(), v -> v, (v1, v2) -> v1));
for (FactorVerificationQueryDTO queryDTO : queryDTOList) {
RealNameTwoFactorVerificationDTO RealNameTwoFactorVerificationDTO = threeVerificationMap
.get(queryDTO.getRealName() + queryDTO.getCardNo());
if (RealNameTwoFactorVerificationDTO != null) {
resultList.add(RealNameTwoFactorVerificationDTO);
}
}
return resultList;
}
@Override
public RealNameTwoFactorVerificationDTO findById(Long id) {
RealNameTwoFactorVerificationDTO threeFactorVerificationDTO = null;
RealNameTwoVerification entity = realNameTwoVerificationMapper.getById(id);
if (entity != null) {
threeFactorVerificationDTO = RealNameTwoVerificationConvert.INSTANCE.convertDTO(entity);
}
return threeFactorVerificationDTO;
}
@Override
RealNameTwoFactorVerificationDTO realVerification(RealNameTwoFactorVerificationDTO verificationDTO) {
Integer authenticationSource = verificationDTO.getAuthenticationSource();
SOURCE_SERVICE_MAP.get(authenticationSource).twoVerify(verificationDTO);
RealNameTwoVerification entity = RealNameTwoVerificationConvert.INSTANCE.convert(verificationDTO);
realNameTwoVerificationMapper.updateEntitySelective(entity, UserContextHolder.getLoginUserId());
return verificationDTO;
}
@Override
public VerificationTypeEnum getType() {
return VerificationTypeEnum.TWO;
}
}

171
src/main/java/com/newyetai/alitaforward/verification/factor/ThreeVerify.java Normal file
View File

@@ -0,0 +1,171 @@
package com.newyetai.alitaforward.verification.factor;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import com.google.common.collect.Lists;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.three.dao.ThreeVerificationMapper;
import com.newyetai.alitaforward.verification.factor.three.entity.BankCardThreeVerification;
import com.newyetai.alitaforward.verification.factor.three.mapstruct.ThreeVerificationMapMapper;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.common.exception.util.Assert;
import com.newyetai.common.util.UserContextHolder;
import com.newyetai.common.validation.util.ValidateUtils;
import com.newyetai.frame.redis.aop.annotation.AutoUnLock;
import com.newyetai.frame.redis.dto.LockDTO;
import com.newyetai.frame.redis.redisson.RedissonUtils;
import com.newyetai.mq.util.MqSendUtils;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Component
public class ThreeVerify extends AbstractVerify<ThreeFactorVerificationDTO> implements IQueryVerify<ThreeFactorVerificationDTO> {
@Resource
private ThreeVerificationMapper threeVerificationMapper;
@Override
protected ThreeFactorVerificationDTO syncBeforeVerify(ThreeFactorVerificationDTO verificationDTO) {
StringJoiner stringJoiner = new StringJoiner("、");
if (!ValidateUtils.checkRealName(verificationDTO.getRealName())) {
stringJoiner.add("姓名格式有误");
}
if (!ValidateUtils.isIdCard(verificationDTO.getCardNo())) {
stringJoiner.add("证件号格式有误");
}
if (StringUtils.isBlank(verificationDTO.getBankAccountNo())) {
stringJoiner.add("银行卡号为空");
}
String failReason = stringJoiner.toString();
if (StringUtils.isNotBlank(failReason)) {
verificationDTO.setFailReason(failReason);
} else {
//校验成功调用
super.syncBeforeVerify(verificationDTO);
}
return verificationDTO;
}
@Override
ThreeFactorVerificationDTO createAndGet(ThreeFactorVerificationDTO verificationDTO) {
BankCardThreeVerification entity = threeVerificationMapper.find(verificationDTO);
if (entity == null) {
//认证库不存在，以默认状态入库——"未认证"
verificationDTO.setStatus(AuthStatusEnum.NOT_AUTH.getType());
entity = ThreeVerificationMapMapper.INSTANCE.toEntity(verificationDTO);
threeVerificationMapper.saveEntity(entity);
}
return ThreeVerificationMapMapper.INSTANCE.toDto(entity);
}
@Override
@AutoUnLock
public void autoVerify(ThreeFactorVerificationDTO verificationDTO) {
//拿锁
LockDTO lockDTO = getLock(verificationDTO);
Assert.isTrue(RedissonUtils.tryLockAutomatically(lockDTO), "请勿重复校验三要素");
BankCardThreeVerification verificationEntity = threeVerificationMapper.find(verificationDTO);
if (Objects.nonNull(verificationEntity)) {
if (!AuthStatusEnum.NOT_AUTH.getType().equals(verificationEntity.getStatus())) {
return;
}
verificationEntity.setAuthenticationSource(FactorVerificationSourceTypeEnum.SYS.getType());
verificationEntity.setStatus(verificationDTO.getStatus());
threeVerificationMapper.updateEntitySelective(verificationEntity,
UserContextHolder.getLoginUserId());
} else {
verificationEntity =
BankCardThreeVerification.builder()
.realName(verificationDTO.getRealName())
.cardNo(verificationDTO.getCardNo())
.bankAccountNo(verificationDTO.getBankAccountNo())
.authenticationSource(FactorVerificationSourceTypeEnum.SYS.getType())
.status(verificationDTO.getStatus())
.build();
threeVerificationMapper.saveEntity(verificationEntity);
}
log.info("【MQ】通知认证状态变更，参数：{}", JSONUtil.toJsonStr(verificationDTO));
MqSendUtils.send(statusChangeRoutingKey(), verificationDTO);
}
@Override
LockDTO getLock(ThreeFactorVerificationDTO verificationDTO) {
return LockDTO.builder()
.methodName("verify:three")
.tryLockWaitTime(0L)
.arg(verificationDTO.getRealName())
.arg(verificationDTO.getCardNo())
.arg(verificationDTO.getBankAccountNo())
.build();
}
@Override
public List<ThreeFactorVerificationDTO> list(FactorVerificationQueryDTO queryDTO) {
return threeVerificationMapper.list(queryDTO);
}
@Override
public List<ThreeFactorVerificationDTO> queryListByData(List<FactorVerificationQueryDTO> queryDTOList) {
List<ThreeFactorVerificationDTO> resultList = Lists
.newArrayListWithCapacity(queryDTOList.size());
if (CollectionUtils.isEmpty(queryDTOList)) {
return resultList;
}
List<ThreeFactorVerificationDTO> bankCardThreeVerifications = threeVerificationMapper
.findFinishStatusData();
Map<String, ThreeFactorVerificationDTO> threeVerificationMap = bankCardThreeVerifications
.stream().collect(
Collectors.toMap(k -> k.getRealName() + k.getCardNo() + k.getBankAccountNo(), v -> v, (v1, v2) -> v1));
for (FactorVerificationQueryDTO queryDTO : queryDTOList) {
ThreeFactorVerificationDTO threeFactorVerificationDTO = threeVerificationMap
.get(queryDTO.getRealName() + queryDTO.getCardNo() + queryDTO.getBankAccountNo());
if (threeFactorVerificationDTO != null) {
resultList.add(threeFactorVerificationDTO);
}
}
return resultList;
}
@Override
public ThreeFactorVerificationDTO findById(Long id) {
ThreeFactorVerificationDTO threeFactorVerificationDTO = null;
BankCardThreeVerification entity = threeVerificationMapper.getById(id);
if (entity != null) {
threeFactorVerificationDTO = ThreeVerificationMapMapper.INSTANCE.toDto(entity);
}
return threeFactorVerificationDTO;
}
@Override
ThreeFactorVerificationDTO realVerification(ThreeFactorVerificationDTO verificationDTO) {
Integer authenticationSource = verificationDTO.getAuthenticationSource();
SOURCE_SERVICE_MAP.get(authenticationSource).threeVerify(verificationDTO);
//更新状态
BankCardThreeVerification entity = ThreeVerificationMapMapper.INSTANCE
.toEntity(verificationDTO);
threeVerificationMapper.updateEntitySelective(entity, UserContextHolder.getLoginUserId());
return verificationDTO;
}
@Override
public VerificationTypeEnum getType() {
return VerificationTypeEnum.THREE;
}
}

18
src/main/java/com/newyetai/alitaforward/verification/factor/VerifyConfig.java Normal file
View File

@@ -0,0 +1,18 @@
package com.newyetai.alitaforward.verification.factor;
import com.newyetai.alitaforward.verification.source.FactorVerificationSourceService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import java.util.List;
@Configuration
public class VerifyConfig {
@Autowired
private void autowiredFactorVerificationSourceService(List<FactorVerificationSourceService> sourceServices) {
for (FactorVerificationSourceService sourceService : sourceServices) {
AbstractVerify.SOURCE_SERVICE_MAP.put(sourceService.getSourceType().getType(), sourceService);
}
}
}

30
src/main/java/com/newyetai/alitaforward/verification/factor/four/dao/FourVerificationMapper.java Normal file
View File

@@ -0,0 +1,30 @@
package com.newyetai.alitaforward.verification.factor.four.dao;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.four.entity.BankCardFourVerification;
import com.newyetai.tkmybatis.mybatis.MyMapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
* @author czy
* @date 2021-06-17
*/
public interface FourVerificationMapper extends MyMapper<BankCardFourVerification> {
/**
* 根据四要素查询数据
* @param params
* @return
*/
BankCardFourVerification selectInfo(@Param("params") FourFactorVerificationDTO params);
@Select("select * from bank_card_four_verification where deleted = false and status in (2,3)")
List<FourFactorVerificationDTO> findFinishStatusData();
List<FourFactorVerificationDTO> list(@Param("params") FactorVerificationQueryDTO factorVerificationQueryDTO);
}

51
src/main/java/com/newyetai/alitaforward/verification/factor/four/entity/BankCardFourVerification.java Normal file
View File

@@ -0,0 +1,51 @@
package com.newyetai.alitaforward.verification.factor.four.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.newyetai.common.entity.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
/**
* @author czy
* @date 2021-06-17
*/
@ApiModel("四要素认证库")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@EqualsAndHashCode(callSuper = true)
@TableName("bank_card_four_verification")
public class BankCardFourVerification extends BaseEntity {
@ApiModelProperty("姓名")
private String realName;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("银行卡号")
private String bankAccountNo;
@ApiModelProperty("手机号")
private String phone;
@ApiModelProperty("认证状态(1-未认证 2-认证中 3-认证成功 4-认证失败)")
private Integer status;
@ApiModelProperty("认证来源")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
}

44
src/main/java/com/newyetai/alitaforward/verification/factor/four/mapper/BankCardFourVerificationMapper.xml Normal file
View File

@@ -0,0 +1,44 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newyetai.alitaforward.verification.factor.four.dao.FourVerificationMapper">
<select id="selectInfo" resultType="com.newyetai.alitaforward.verification.factor.four.entity.BankCardFourVerification">
select
*
from
bank_card_four_verification
where
deleted = 0
and real_name = #{params.realName}
and card_no = #{params.cardNo}
and bank_account_no = #{params.bankAccountNo}
and phone = #{params.phone}
</select>
<select id="list" resultType="com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO">
select
*
from
bank_card_four_verification
<where>
AND deleted = 0
<if test="params.id != null">
and id = #{params.id}
</if>
<if test='params.realName != null and params.realName != ""'>
and real_name = #{params.realName}
</if>
<if test='params.cardNo != null and params.cardNo != ""'>
and card_no = #{params.cardNo}
</if>
<if test='params.bankAccountNo != null and params.bankAccountNo != ""'>
and bank_account_no = #{params.bankAccountNo}
</if>
<if test='params.phone != null and params.phone != ""'>
and phone = #{params.phone}
</if>
</where>
</select>
</mapper>

62
src/main/java/com/newyetai/alitaforward/verification/factor/four/mapstruct/FourVerificationMapMapper.java Normal file
View File

@@ -0,0 +1,62 @@
package com.newyetai.alitaforward.verification.factor.four.mapstruct;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.four.entity.BankCardFourVerification;
import com.newyetai.sdk.fangxinqian.dto.BankCardFourRequestDTO;
import com.newyetai.sdk.fangxinqian.dto.BankCardThreeRequestDTO;
import java.util.List;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
/**
* @author czy
* @date 2021-06-17
*/
@Mapper
public interface FourVerificationMapMapper {
FourVerificationMapMapper INSTANCE = Mappers.getMapper(
FourVerificationMapMapper.class);
/**
* dto to entity
*
* @param fourVerificationDTO
* @return
* @author czy on 2021-06-17
*/
BankCardFourVerification toEntity(
FourFactorVerificationDTO fourVerificationDTO);
/**
* dtoList to entityList
*
* @param threeVerificationDTOList
* @return
* @author czy on 2021-06-17
*/
List<BankCardFourVerification> toEntityList(
List<FourFactorVerificationDTO> threeVerificationDTOList);
/**
* entity to dto
*
* @param threeVerification
* @return
* @author czy on 2021-06-17
*/
FourFactorVerificationDTO toDto(
BankCardFourVerification threeVerification);
/**
* entityList to dtoList
*
* @param fourVerificationEntityList
* @return
* @author czy on 2021-06-17
*/
List<FourFactorVerificationDTO> toDtoList(
List<BankCardFourVerification> fourVerificationEntityList);
}

30
src/main/java/com/newyetai/alitaforward/verification/factor/phoneThree/dao/PhoneThreeVerificationMapper.java Normal file
View File

@@ -0,0 +1,30 @@
package com.newyetai.alitaforward.verification.factor.phoneThree.dao;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.phoneThree.entity.PhoneThreeVerification;
import com.newyetai.tkmybatis.mybatis.MyMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/**
* @author czy
* @date 2021-06-17
*/
public interface PhoneThreeVerificationMapper extends MyMapper<PhoneThreeVerification> {
/**
* 根据三要素查询数据
* @param params
* @return
*/
PhoneThreeVerification find(@Param("params") PhoneThreeFactorVerificationDTO params);
@Select("select * from phone_three_verification where deleted = false")
List<PhoneThreeFactorVerificationDTO> findFinishStatusData();
List<PhoneThreeFactorVerificationDTO> list(@Param("params") FactorVerificationQueryDTO factorVerificationQueryDTO);
}

42
src/main/java/com/newyetai/alitaforward/verification/factor/phoneThree/entity/PhoneThreeVerification.java Normal file
View File

@@ -0,0 +1,42 @@
package com.newyetai.alitaforward.verification.factor.phoneThree.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.newyetai.common.entity.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
/**
* @author czy
* @date 2021-06-17
*/
@ApiModel("手机号三要素认证库")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@EqualsAndHashCode(callSuper = true)
@TableName("phone_three_verification")
public class PhoneThreeVerification extends BaseEntity {
private static final long serialVersionUID = 1033289792676234200L;
@ApiModelProperty("姓名")
private String realName;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("银行卡号")
private String phone;
@ApiModelProperty("认证状态(1-未认证 2-认证中 3-认证成功 4-认证失败)")
private Integer status;
@ApiModelProperty("认证来源")
private Integer authenticationSource;
@ApiModelProperty("失败原因")
private String failReason;
}

44
src/main/java/com/newyetai/alitaforward/verification/factor/phoneThree/mapper/PhoneThreeVerificationMapper.xml Normal file
View File

@@ -0,0 +1,44 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newyetai.alitaforward.verification.factor.phoneThree.dao.PhoneThreeVerificationMapper">
<select id="find" resultType="com.newyetai.alitaforward.verification.factor.phoneThree.entity.PhoneThreeVerification">
select
*
from
phone_three_verification
where
deleted = 0
and real_name = #{params.realName}
and card_no = #{params.cardNo}
and phone = #{params.phone}
</select>
<select id="list" resultType="com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO">
select
*
from
phone_three_verification
<where>
AND deleted = 0
<if test="params.id != null">
and id = #{params.id}
</if>
<if test='params.realName != null and params.realName != ""'>
and real_name = #{params.realName}
</if>
<if test='params.cardNo != null and params.cardNo != ""'>
and card_no = #{params.cardNo}
</if>
<if test='params.phone != null and params.phone != ""'>
and phone = #{params.phone}
</if>
<if test='params.status != null and params.status != ""'>
and status = #{params.status}
</if>
</where>
</select>
</mapper>

21
src/main/java/com/newyetai/alitaforward/verification/factor/phoneThree/mapstruct/PhoneThreeVerificationMapMapper.java Normal file
View File

@@ -0,0 +1,21 @@
package com.newyetai.alitaforward.verification.factor.phoneThree.mapstruct;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.phoneThree.entity.PhoneThreeVerification;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* @author czy
* @date 2021-06-17
*/
@Mapper
public interface PhoneThreeVerificationMapMapper {
PhoneThreeVerificationMapMapper INSTANCE = Mappers.getMapper(
PhoneThreeVerificationMapMapper.class);
PhoneThreeFactorVerificationDTO exchange(PhoneThreeVerification verification);
PhoneThreeVerification exchange(PhoneThreeFactorVerificationDTO verificationDTO);
}

29
src/main/java/com/newyetai/alitaforward/verification/factor/three/dao/ThreeVerificationMapper.java Normal file
View File

@@ -0,0 +1,29 @@
package com.newyetai.alitaforward.verification.factor.three.dao;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.three.entity.BankCardThreeVerification;
import com.newyetai.tkmybatis.mybatis.MyMapper;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
* @author czy
* @date 2021-06-17
*/
public interface ThreeVerificationMapper extends MyMapper<BankCardThreeVerification> {
/**
* 根据三要素查询数据
* @param params
* @return
*/
BankCardThreeVerification find(@Param("params") ThreeFactorVerificationDTO params);
@Select("select * from bank_card_three_verification where deleted = false")
List<ThreeFactorVerificationDTO> findFinishStatusData();
List<ThreeFactorVerificationDTO> list(@Param("params") FactorVerificationQueryDTO factorVerificationQueryDTO);
}

45
src/main/java/com/newyetai/alitaforward/verification/factor/three/entity/BankCardThreeVerification.java Normal file
View File

@@ -0,0 +1,45 @@
package com.newyetai.alitaforward.verification.factor.three.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.newyetai.common.entity.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
/**
* @author czy
* @date 2021-06-17
*/
@ApiModel("三要素认证库")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@EqualsAndHashCode(callSuper = true)
@TableName("bank_card_three_verification")
public class BankCardThreeVerification extends BaseEntity {
private static final long serialVersionUID = 1178897458908696195L;
@ApiModelProperty("姓名")
private String realName;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("银行卡号")
private String bankAccountNo;
@ApiModelProperty("认证状态(1-未认证 2-认证中 3-认证成功 4-认证失败)")
private Integer status;
@ApiModelProperty("认证来源")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
}

50
src/main/java/com/newyetai/alitaforward/verification/factor/three/mapper/BankCardThreeVerificationMapper.xml Normal file
View File

@@ -0,0 +1,50 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newyetai.alitaforward.verification.factor.three.dao.ThreeVerificationMapper">
<select id="find" resultType="com.newyetai.alitaforward.verification.factor.three.entity.BankCardThreeVerification">
select
*
from
bank_card_three_verification
where
deleted = 0
and real_name = #{params.realName}
and card_no = #{params.cardNo}
and bank_account_no = #{params.bankAccountNo}
</select>
<select id="list" resultType="com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO">
select
*
from
bank_card_three_verification
<where>
AND deleted = 0
<if test="params.id != null">
and id = #{params.id}
</if>
<if test="params.ids != null and params.ids.size() != 0">
and id IN
<foreach collection="params.ids" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</if>
<if test='params.realName != null and params.realName != ""'>
and real_name = #{params.realName}
</if>
<if test='params.cardNo != null and params.cardNo != ""'>
and card_no = #{params.cardNo}
</if>
<if test='params.bankAccountNo != null and params.bankAccountNo != ""'>
and bank_account_no = #{params.bankAccountNo}
</if>
<if test='params.status != null and params.status != ""'>
and status = #{params.status}
</if>
</where>
</select>
</mapper>

60
src/main/java/com/newyetai/alitaforward/verification/factor/three/mapstruct/ThreeVerificationMapMapper.java Normal file
View File

@@ -0,0 +1,60 @@
package com.newyetai.alitaforward.verification.factor.three.mapstruct;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.three.entity.BankCardThreeVerification;
import java.util.List;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* @author czy
* @date 2021-06-17
*/
@Mapper
public interface ThreeVerificationMapMapper {
ThreeVerificationMapMapper INSTANCE = Mappers.getMapper(
ThreeVerificationMapMapper.class);
/**
* dto to entity
*
* @param threeVerificationDTO
* @return
* @author czy on 2021-06-17
*/
BankCardThreeVerification toEntity(
ThreeFactorVerificationDTO threeVerificationDTO);
/**
* dtoList to entityList
*
* @param threeVerificationDTOList
* @return
* @author czy on 2021-06-17
*/
List<BankCardThreeVerification> toEntityList(
List<ThreeFactorVerificationDTO> threeVerificationDTOList);
/**
* entity to dto
*
* @param threeVerification
* @return
* @author czy on 2021-06-17
*/
ThreeFactorVerificationDTO toDto(
BankCardThreeVerification threeVerification);
/**
* entityList to dtoList
*
* @param threeVerificationEntityList
* @return
* @author czy on 2021-06-17
*/
List<ThreeFactorVerificationDTO> toDtoList(
List<BankCardThreeVerification> threeVerificationEntityList);
}

28
src/main/java/com/newyetai/alitaforward/verification/factor/two/convert/RealNameTwoVerificationConvert.java Normal file
View File

@@ -0,0 +1,28 @@
package com.newyetai.alitaforward.verification.factor.two.convert;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.two.dto.RealNameTwoVerificationDTO;
import com.newyetai.alitaforward.verification.factor.two.dto.RealNameTwoVerificationOperatorDTO;
import com.newyetai.alitaforward.verification.factor.two.entity.RealNameTwoVerification;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@Mapper
public interface RealNameTwoVerificationConvert {
RealNameTwoVerificationConvert INSTANCE = Mappers.getMapper(RealNameTwoVerificationConvert.class);
RealNameTwoVerification convert(RealNameTwoVerificationDTO dto);
RealNameTwoVerificationDTO convert(RealNameTwoVerification entity);
RealNameTwoFactorVerificationDTO convertDTO(RealNameTwoVerification entity);
RealNameTwoVerification convert(RealNameTwoVerificationOperatorDTO dto);
RealNameTwoVerification convert(RealNameTwoFactorVerificationDTO dto);
}

39
src/main/java/com/newyetai/alitaforward/verification/factor/two/dao/RealNameTwoVerificationMapper.java Normal file
View File

@@ -0,0 +1,39 @@
package com.newyetai.alitaforward.verification.factor.two.dao;
import com.newyetai.alitaforward.verification.dto.FactorVerificationQueryDTO;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.factor.two.dto.RealNameTwoVerificationDTO;
import com.newyetai.alitaforward.verification.factor.two.dto.RealNameTwoVerificationPageQueryDTO;
import com.newyetai.alitaforward.verification.factor.two.entity.RealNameTwoVerification;
import com.newyetai.tkmybatis.mybatis.MyMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@Mapper
public interface RealNameTwoVerificationMapper extends MyMapper<RealNameTwoVerification> {
/**
* 根据二要素查询数据
*
* @param params
* @return
*/
RealNameTwoVerification selectInfo(@Param("param") RealNameTwoFactorVerificationDTO params);
List<RealNameTwoVerificationDTO> page(
@Param("param") RealNameTwoVerificationPageQueryDTO queryDTO);
List<RealNameTwoFactorVerificationDTO> list(@Param("param") FactorVerificationQueryDTO queryDTO);
@Select("select * from real_name_two_verification where deleted = false")
List<RealNameTwoFactorVerificationDTO> findFinishStatusData();
}

41
src/main/java/com/newyetai/alitaforward/verification/factor/two/dto/RealNameTwoVerificationDTO.java Normal file
View File

@@ -0,0 +1,41 @@
package com.newyetai.alitaforward.verification.factor.two.dto;
import com.newyetai.common.dto.BaseDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.SuperBuilder;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@ApiModel("二要素认证表")
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class RealNameTwoVerificationDTO extends BaseDTO {
private static final long serialVersionUID = 1L;
@ApiModelProperty("姓名")
private String realName;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("状态（1待认证 2认证中 3认证成功 4认证失败）")
private Integer status;
@ApiModelProperty("认证来源（1放心签、2创蓝 3系统）")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
}

45
src/main/java/com/newyetai/alitaforward/verification/factor/two/dto/RealNameTwoVerificationOperatorDTO.java Normal file
View File

@@ -0,0 +1,45 @@
package com.newyetai.alitaforward.verification.factor.two.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@ApiModel("二要素认证表")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RealNameTwoVerificationOperatorDTO implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
@ApiModelProperty("姓名")
private String realName;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("状态（1待认证 2认证中 3认证成功 4认证失败）")
private Integer status;
@ApiModelProperty("认证来源（1放心签、2创蓝 3系统）")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
}

67
src/main/java/com/newyetai/alitaforward/verification/factor/two/dto/RealNameTwoVerificationPageQueryDTO.java Normal file
View File

@@ -0,0 +1,67 @@
package com.newyetai.alitaforward.verification.factor.two.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.newyetai.common.dto.PageQueryDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@ApiModel("二要素认证表")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class RealNameTwoVerificationPageQueryDTO extends PageQueryDTO<RealNameTwoVerificationDTO> {
private static final long serialVersionUID = 1L;
@ApiModelProperty("ID")
private Long id;
@ApiModelProperty("姓名 （模糊匹配）")
private String realNameLike;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("状态（1待认证 2认证中 3认证成功 4认证失败）")
private Integer status;
@ApiModelProperty("认证来源（1放心签、2创蓝 3系统）")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
@ApiModelProperty("创建时间起,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date createTimeStart;
@ApiModelProperty("创建时间止,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date createTimeEnd;
@ApiModelProperty("更新时间起,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date updateTimeStart;
@ApiModelProperty("更新时间止,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date updateTimeEnd;
}

69
src/main/java/com/newyetai/alitaforward/verification/factor/two/dto/RealNameTwoVerificationQueryDTO.java Normal file
View File

@@ -0,0 +1,69 @@
package com.newyetai.alitaforward.verification.factor.two.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@ApiModel("二要素认证表")
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RealNameTwoVerificationQueryDTO implements Serializable {
private static final long serialVersionUID = 1L;
@ApiModelProperty("ID")
private Long id;
@ApiModelProperty("姓名 （模糊匹配）")
private String realNameLike;
@ApiModelProperty("证件号")
private String cardNo;
@ApiModelProperty("状态（1待认证 2认证中 3认证成功 4认证失败）")
private Integer status;
@ApiModelProperty("认证来源（1放心签、2创蓝 3系统）")
private Integer authenticationSource;
@ApiModelProperty("调用数据")
private String invokeData;
@ApiModelProperty("失败原因")
private String failReason;
@ApiModelProperty("创建时间起,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date createTimeStart;
@ApiModelProperty("创建时间止,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date createTimeEnd;
@ApiModelProperty("更新时间起,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date updateTimeStart;
@ApiModelProperty("更新时间止,格式 （yyyy-MM-dd HH:mm:ss）")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date updateTimeEnd;
}

40
src/main/java/com/newyetai/alitaforward/verification/factor/two/entity/RealNameTwoVerification.java Normal file
View File

@@ -0,0 +1,40 @@
package com.newyetai.alitaforward.verification.factor.two.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.newyetai.common.entity.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
/**
* 二要素认证表
*
* @author chenyun chenyun.home@outlook.com
* @since 1.0.0 2022-07-22
*/
@TableName("real_name_two_verification")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class RealNameTwoVerification extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 姓名 */
private String realName;
/** 证件号 */
private String cardNo;
/** 状态（1待认证 2认证中 3认证成功 4认证失败） */
private Integer status;
/** 认证来源（1放心签、2创蓝 3系统） */
private Integer authenticationSource;
/** 调用数据 */
private String invokeData;
/** 失败原因 */
private String failReason;
}

81
src/main/java/com/newyetai/alitaforward/verification/factor/two/mapper/RealNameTwoVerificationMapper.xml Normal file
View File

@@ -0,0 +1,81 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.newyetai.alitaforward.verification.factor.two.dao.RealNameTwoVerificationMapper">
<select id="list" resultType="com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO">
select
*
from
real_name_two_verification
<where>
AND deleted = 0
<if test="params.id != null">
and id = #{params.id}
</if>
<if test='params.realName != null and params.realName != ""'>
and real_name = #{params.realName}
</if>
<if test='params.cardNo != null and params.cardNo != ""'>
and card_no = #{params.cardNo}
</if>
<if test='params.status != null and params.status != ""'>
and status = #{params.status}
</if>
</where>
</select>
<select id="page" resultType="com.newyetai.alitaforward.verification.factor.two.dto.RealNameTwoVerificationDTO">
SELECT t.*
<include refid="queryFromSql"></include>
</select>
<select id="selectInfo"
resultType="com.newyetai.alitaforward.verification.factor.two.entity.RealNameTwoVerification">
SELECT t.*
FROM real_name_two_verification t
WHERE t.deleted = 0
AND t.real_name = #{param.realName}
AND t.card_no = #{param.cardNo}
</select>
<sql id="queryFromSql">
FROM
real_name_two_verification t
WHERE t.deleted = 0
<if test='param.id != null'>
AND t.id = #{param.id}
</if>
<if test='param.realNameLike != null and param.realNameLike.trim() != ""'>
<bind name="realNameLike" value="'%' + param.realNameLike + '%'"/>
AND t.real_name like #{realNameLike}
</if>
<if test='param.cardNo != null and param.cardNo.trim() != ""'>
AND t.card_no = #{param.cardNo}
</if>
<if test='param.status != null'>
AND t.status = #{param.status}
</if>
<if test='param.authenticationSource != null'>
AND t.authentication_source = #{param.authenticationSource}
</if>
<if test='param.invokeData != null and param.invokeData.trim() != ""'>
AND t.invoke_data = #{param.invokeData}
</if>
<if test='param.failReason != null and param.failReason.trim() != ""'>
AND t.fail_reason = #{param.failReason}
</if>
<if test='param.createTimeStart != null'>
AND t.create_time &gt;= #{param.createTimeStart}
</if>
<if test='param.createTimeEnd != null'>
AND t.create_time &lt;= #{param.createTimeEnd}
</if>
<if test='param.updateTimeStart != null'>
AND t.update_time &gt;= #{param.updateTimeStart}
</if>
<if test='param.updateTimeEnd != null'>
AND t.update_time &lt;= #{param.updateTimeEnd}
</if>
ORDER BY t.id DESC
</sql>
</mapper>

14
src/main/java/com/newyetai/alitaforward/verification/service/BankCardVerificationService.java Normal file
View File

@@ -0,0 +1,14 @@
package com.newyetai.alitaforward.verification.service;
import com.newyetai.alitaforward.verification.dto.BankCordVerificationResDTO;
import java.util.List;
public interface BankCardVerificationService {
/**
* 白名单管理-->三、四要素查询合并为银行卡查询
* @param cardNo
*/
List<BankCordVerificationResDTO> list(String cardNo,Integer status);
}

17
src/main/java/com/newyetai/alitaforward/verification/service/FourFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,17 @@
package com.newyetai.alitaforward.verification.service;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.mq.consumer.handler.ITopicMqHandler;
/**
* @author czy
* @date 2021-06-22
*/
public interface FourFactorVerificationProvider extends ITopicMqHandler<FourFactorVerificationDTO> {
default String getRoutingKey(){
return VerificationTypeEnum.FOUR.getStatusChangeKey();
}
}

17
src/main/java/com/newyetai/alitaforward/verification/service/PhoneThreeFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,17 @@
package com.newyetai.alitaforward.verification.service;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.mq.consumer.handler.ITopicMqHandler;
/**
* @author czy
* @date 2021-06-22
*/
public interface PhoneThreeFactorVerificationProvider extends ITopicMqHandler<PhoneThreeFactorVerificationDTO> {
default String getRoutingKey(){
return VerificationTypeEnum.PHONE_THREE.getStatusChangeKey();
}
}

17
src/main/java/com/newyetai/alitaforward/verification/service/RealNameTwoFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,17 @@
package com.newyetai.alitaforward.verification.service;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.mq.consumer.handler.ITopicMqHandler;
/**
* @author czy
* @date 2021-06-22
*/
public interface RealNameTwoFactorVerificationProvider extends ITopicMqHandler<RealNameTwoFactorVerificationDTO> {
default String getRoutingKey(){
return VerificationTypeEnum.TWO.getStatusChangeKey();
}
}

17
src/main/java/com/newyetai/alitaforward/verification/service/ThreeFactorVerificationProvider.java Normal file
View File

@@ -0,0 +1,17 @@
package com.newyetai.alitaforward.verification.service;
import com.newyetai.alitaforward.verification.constants.VerificationTypeEnum;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.mq.consumer.handler.ITopicMqHandler;
/**
* @author czy
* @date 2021-06-22
*/
public interface ThreeFactorVerificationProvider extends ITopicMqHandler<ThreeFactorVerificationDTO> {
default String getRoutingKey(){
return VerificationTypeEnum.THREE.getStatusChangeKey();
}
}

35
src/main/java/com/newyetai/alitaforward/verification/service/impl/BankCardVerificationServiceImpl.java Normal file
View File

@@ -0,0 +1,35 @@
package com.newyetai.alitaforward.verification.service.impl;
import com.newyetai.alitaforward.verification.dao.BankCardVerificationMapper;
import com.newyetai.alitaforward.verification.dto.BankCordVerificationResDTO;
import com.newyetai.alitaforward.verification.service.BankCardVerificationService;
import com.newyetai.common.exception.BusinessException;
import com.newyetai.common.exception.util.Assert;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class BankCardVerificationServiceImpl implements BankCardVerificationService {
@Autowired
BankCardVerificationMapper bankCardVerificationMapper;
/**
* 白名单管理-->三、四要素查询合并为银行卡查询
* @param cardNo
*/
public List<BankCordVerificationResDTO> list(String cardNo,Integer status){
if(StringUtils.isBlank(cardNo)){
throw new BusinessException("身份证号不能为空");
}
List<BankCordVerificationResDTO> bankCordVerificationResDTOList = bankCardVerificationMapper.list(cardNo);
if(status != null){
return bankCordVerificationResDTOList.stream().
filter(f -> f.getStatus() != null && f.getStatus() == status).collect(Collectors.toList());
}
return bankCordVerificationResDTOList;
}
}

34
src/main/java/com/newyetai/alitaforward/verification/source/FactorVerificationSourceService.java Normal file
View File

@@ -0,0 +1,34 @@
package com.newyetai.alitaforward.verification.source;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.common.exception.BusinessException;
/**
* 要素认证源 - 顶层接口
*
* @author cheny
* @date 2022/08/11
*/
public interface FactorVerificationSourceService {
FactorVerificationSourceTypeEnum getSourceType();
default RealNameTwoFactorVerificationDTO twoVerify(RealNameTwoFactorVerificationDTO verificationDTO) {
throw new BusinessException("二要素不支持的该认证源:" + getSourceType());
}
default ThreeFactorVerificationDTO threeVerify(ThreeFactorVerificationDTO verificationDTO){
throw new BusinessException("银行卡三要素不支持的该认证源:" + getSourceType());
}
default PhoneThreeFactorVerificationDTO phoneThreeVerify(PhoneThreeFactorVerificationDTO verificationDTO){
throw new BusinessException("手机号三要素不支持的该认证源:" + getSourceType());
}
default FourFactorVerificationDTO fourVerify(FourFactorVerificationDTO verificationDTO){
throw new BusinessException("银行卡四要素不支持的该认证源:" + getSourceType());
}
}

119
src/main/java/com/newyetai/alitaforward/verification/source/cl/ClAuthenticateSourceServiceImpl.java Normal file
View File

@@ -0,0 +1,119 @@
package com.newyetai.alitaforward.verification.source.cl;
import java.util.Objects;
import java.util.Optional;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.source.FactorVerificationSourceService;
import com.newyetai.alitaforward.verification.source.cl.mapstruct.ClMapMapper;
import com.newyetai.common.AlitaResult;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.sdk.chuanglan.dto.BankCardFourRequestDTO;
import com.newyetai.sdk.chuanglan.dto.BankCardThreeRequestDTO;
import com.newyetai.sdk.chuanglan.dto.ChuangLanResultDTO;
import com.newyetai.sdk.chuanglan.dto.PhoneThreeRequestDTO;
import com.newyetai.sdk.chuanglan.dto.RealNameTwoBaseRequestDTO;
import com.newyetai.sdk.chuanglan.service.ChuangLanService;
import com.newyetai.sdk.common.constant.SdkConstants;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
/**
* 创蓝认证源
*
* @author cheny
* @date 2022/08/11
*/
@Slf4j
@Service
@SuppressWarnings("unchecked")
public class ClAuthenticateSourceServiceImpl implements FactorVerificationSourceService {
@Override
public RealNameTwoFactorVerificationDTO twoVerify(RealNameTwoFactorVerificationDTO verificationDTO) {
RealNameTwoBaseRequestDTO requestDTO = ClMapMapper.INSTANCE.toTwoRequestDTO(verificationDTO);
log.info("执行创蓝运营商二要素认证：{}", JSONUtil.toJsonStr(requestDTO));
AlitaResult<ChuangLanResultDTO> result = chuangLanService.checkRealNameTwoBase(requestDTO);
handlerResult(result, verificationDTO);
return verificationDTO;
}
@Override
public PhoneThreeFactorVerificationDTO phoneThreeVerify(PhoneThreeFactorVerificationDTO verificationDTO) {
PhoneThreeRequestDTO phoneThreeRequestDTO = ClMapMapper.INSTANCE
.toPhoneThreeRequestDTO(verificationDTO);
log.info("执行创蓝运营商三要素认证：{}", JSONUtil.toJsonStr(phoneThreeRequestDTO));
AlitaResult<ChuangLanResultDTO> result = chuangLanService.checkPhoneThree(phoneThreeRequestDTO);
handlerResult(result, verificationDTO);
return verificationDTO;
}
@Override
public ThreeFactorVerificationDTO threeVerify(
ThreeFactorVerificationDTO verificationDTO) {
BankCardThreeRequestDTO bankCardThreeRequestDTO = ClMapMapper.INSTANCE
.toThreeRequestDTO(verificationDTO);
log.info("执行创蓝三要素认证：{}", JSONUtil.toJsonStr(bankCardThreeRequestDTO));
AlitaResult<ChuangLanResultDTO> result = chuangLanService.checkBankCardThree(bankCardThreeRequestDTO);
handlerResult(result, verificationDTO);
return verificationDTO;
}
@Override
public FourFactorVerificationDTO fourVerify(
FourFactorVerificationDTO verificationDTO) {
//调用放心签
BankCardFourRequestDTO bankCardFourRequestDTO = ClMapMapper.INSTANCE
.toFourRequestDTO(verificationDTO);
log.info("执行创蓝四要素认证：{}", JSONUtil.toJsonStr(bankCardFourRequestDTO));
AlitaResult<ChuangLanResultDTO> result = chuangLanService.checkBankCardFour(bankCardFourRequestDTO);
handlerResult(result, verificationDTO);
return verificationDTO;
}
/**
* 处理结果
*
* @param result 结果
* @param verificationDTO 验证dto
*/
private void handlerResult(AlitaResult<ChuangLanResultDTO> result, FactorVerificationDTO verificationDTO) {
verificationDTO.setInvokeData(Optional.ofNullable(result.getData()).map(ChuangLanResultDTO::getJsonData).orElse(""));
AuthStatusEnum targetStatus = null;
if (SdkConstants.SDK_INVOKE_NOT_REACH_CODE.equals(result.getCode())) {
// 接口调起失败，未拿到返回结果，视为未调起
verificationDTO.setFailReason("调用异常，未调起第三方");
} else {
if (Boolean.TRUE.equals(result.getSuccess()) && Boolean.TRUE.equals(result.getData().getStatus())) {
targetStatus = AuthStatusEnum.AUTH_SUCCESS;
} else {
targetStatus = AuthStatusEnum.AUTH_FAIL;
verificationDTO.setFailReason(result.getMsg());
}
}
if (Objects.nonNull(targetStatus)) {
verificationDTO.setStatus(targetStatus.getType());
}
}
@Resource(name = ChuangLanService.BEAN_ID)
private ChuangLanService chuangLanService;
@Override
public FactorVerificationSourceTypeEnum getSourceType() {
return FactorVerificationSourceTypeEnum.CL;
}
}

76
src/main/java/com/newyetai/alitaforward/verification/source/cl/mapstruct/ClMapMapper.java Normal file
View File

@@ -0,0 +1,76 @@
package com.newyetai.alitaforward.verification.source.cl.mapstruct;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.PhoneThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.RealNameTwoFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.sdk.chuanglan.dto.BankCardFourRequestDTO;
import com.newyetai.sdk.chuanglan.dto.BankCardThreeRequestDTO;
import com.newyetai.sdk.chuanglan.dto.PhoneThreeRequestDTO;
import com.newyetai.sdk.chuanglan.dto.RealNameTwoBaseRequestDTO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @author czy
* @date 2021-06-23
*/
@Mapper
public interface ClMapMapper {
ClMapMapper INSTANCE = Mappers.getMapper(ClMapMapper.class);
/**
* dto转创蓝三要素认证请求对象
*
* @param dto 验证dto
* @return {@link RealNameTwoBaseRequestDTO}
*/
@Mappings(value = {
@Mapping(target = "name", source = "dto.realName"),
@Mapping(target = "idNum", source = "dto.cardNo")
})
RealNameTwoBaseRequestDTO toTwoRequestDTO(RealNameTwoFactorVerificationDTO dto);
/**
* dto转创蓝三要素认证请求对象
*
* @param dto
* @return {@link BankCardThreeRequestDTO}
*/
@Mappings(value = {
@Mapping(target = "name", source = "dto.realName"),
@Mapping(target = "idNum", source = "dto.cardNo"),
@Mapping(target = "cardNo", source = "dto.bankAccountNo")
})
BankCardThreeRequestDTO toThreeRequestDTO(ThreeFactorVerificationDTO dto);
/**
* dto转创蓝三要素认证请求对象
*
* @param dto dto
* @return {@link PhoneThreeRequestDTO}
*/
@Mappings(value = {
@Mapping(target = "name", source = "dto.realName"),
@Mapping(target = "idNum", source = "dto.cardNo"),
@Mapping(target = "mobile", source = "dto.phone")
})
PhoneThreeRequestDTO toPhoneThreeRequestDTO(PhoneThreeFactorVerificationDTO dto);
/**
* dto转创蓝四要素认证请求对象
*
* @param dto
* @return {@link BankCardFourRequestDTO}
*/
@Mappings(value = {
@Mapping(target = "name", source = "dto.realName"),
@Mapping(target = "idNum", source = "dto.cardNo"),
@Mapping(target = "cardNo", source = "dto.bankAccountNo"),
@Mapping(target = "mobile", source = "dto.phone")
})
BankCardFourRequestDTO toFourRequestDTO(FourFactorVerificationDTO dto);
}

88
src/main/java/com/newyetai/alitaforward/verification/source/fxq/FxqAuthenticateSourceServiceImpl.java Normal file
View File

@@ -0,0 +1,88 @@
package com.newyetai.alitaforward.verification.source.fxq;
import java.util.Objects;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.newyetai.alitaforward.verification.constants.FactorVerificationSourceTypeEnum;
import com.newyetai.alitaforward.verification.dto.FactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.alitaforward.verification.source.FactorVerificationSourceService;
import com.newyetai.alitaforward.verification.source.fxq.mapstruct.FxqMapMapper;
import com.newyetai.common.AlitaResult;
import com.newyetai.common.constant.AuthStatusEnum;
import com.newyetai.sdk.common.constant.SdkConstants;
import com.newyetai.sdk.fangxinqian.dto.BankCardFourRequestDTO;
import com.newyetai.sdk.fangxinqian.dto.BankCardThreeRequestDTO;
import com.newyetai.sdk.fangxinqian.service.FangXinQianService;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
/**
* @author czy
* @date 2021-06-21
*/
@Slf4j
@Service
public class FxqAuthenticateSourceServiceImpl implements FactorVerificationSourceService {
@Override
public ThreeFactorVerificationDTO threeVerify(
ThreeFactorVerificationDTO threeFactorVerificationDTO) {
BankCardThreeRequestDTO bankCardThreeRequestDto =
FxqMapMapper.INSTANCE.toThreeRequestDTO(threeFactorVerificationDTO);
log.info("执行放心签三要素认证：{}", JSONUtil.toJsonStr(bankCardThreeRequestDto));
AlitaResult<Boolean> result = fangXinQianService.checkBankCardThree(bankCardThreeRequestDto);
handlerResult(result, threeFactorVerificationDTO);
return threeFactorVerificationDTO;
}
@Override
public FourFactorVerificationDTO fourVerify(
FourFactorVerificationDTO fourFactorVerificationDTO) {
//调用放心签
BankCardFourRequestDTO bankCardFourRequestDTO = FxqMapMapper.INSTANCE
.toFourRequestDTO(fourFactorVerificationDTO);
log.info("执行放心签四要素认证：{}", JSONUtil.toJsonStr(bankCardFourRequestDTO));
AlitaResult<Boolean> result = fangXinQianService.checkBankCardFour(bankCardFourRequestDTO);
handlerResult(result, fourFactorVerificationDTO);
return fourFactorVerificationDTO;
}
/**
* 处理结果
*
* @param result 结果
* @param verificationDTO 验证dto
*/
private void handlerResult(AlitaResult<Boolean> result, FactorVerificationDTO verificationDTO) {
AuthStatusEnum targetStatus = null;
if (SdkConstants.SDK_INVOKE_NOT_REACH_CODE.equals(result.getCode())) {
// 接口调起失败，未拿到返回结果，视为未调起
verificationDTO.setFailReason("调用异常，未调起第三方");
} else {
if (Boolean.TRUE.equals(result.getSuccess()) && Boolean.TRUE.equals(result.getData())) {
targetStatus = AuthStatusEnum.AUTH_SUCCESS;
} else {
targetStatus = AuthStatusEnum.AUTH_FAIL;
verificationDTO.setFailReason(result.getMsg());
}
}
if (Objects.nonNull(targetStatus)) {
verificationDTO.setStatus(targetStatus.getType());
}
}
@Resource(name = FangXinQianService.BEAN_ID)
private FangXinQianService fangXinQianService;
@Override
public FactorVerificationSourceTypeEnum getSourceType() {
return FactorVerificationSourceTypeEnum.FXQ;
}
}

49
src/main/java/com/newyetai/alitaforward/verification/source/fxq/mapstruct/FxqMapMapper.java Normal file
View File

@@ -0,0 +1,49 @@
package com.newyetai.alitaforward.verification.source.fxq.mapstruct;
import com.newyetai.alitaforward.verification.dto.FourFactorVerificationDTO;
import com.newyetai.alitaforward.verification.dto.ThreeFactorVerificationDTO;
import com.newyetai.sdk.fangxinqian.dto.BankCardFourRequestDTO;
import com.newyetai.sdk.fangxinqian.dto.BankCardThreeRequestDTO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @author czy
* @date 2021-06-23
*/
@Mapper
public interface FxqMapMapper {
FxqMapMapper INSTANCE = Mappers.getMapper(
FxqMapMapper.class);
/**
* dto转放心签三要素认证请求对象
*
* @param dto
* @return {@link BankCardThreeRequestDTO}
*/
@Mappings(value = {
@Mapping(target = "name", source = "dto.realName"),
@Mapping(target = "identityCode", source = "dto.cardNo"),
@Mapping(target = "bankcardNumber", source = "dto.bankAccountNo")
})
BankCardThreeRequestDTO toThreeRequestDTO(ThreeFactorVerificationDTO dto);
/**
* dto转放心签四要素认证请求对象
*
* @param dto
* @return {@link BankCardFourRequestDTO}
*/
@Mappings(value = {
@Mapping(target = "name", source = "dto.realName"),
@Mapping(target = "identityCode", source = "dto.cardNo"),
@Mapping(target = "bankcardNumber", source = "dto.bankAccountNo"),
@Mapping(target = "phoneNumber", source = "dto.phone")
})
BankCardFourRequestDTO toFourRequestDTO(FourFactorVerificationDTO dto);
}