package com.ruoyi.web.controller.product;
|
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
import com.alibaba.fastjson2.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.common.core.controller.BaseController;
|
import com.ruoyi.common.core.domain.AjaxResult;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.common.core.page.TableDataInfo;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.im.comm.Result;
|
import com.ruoyi.im.service.InsuranceProductService;
|
import com.ruoyi.im.service.MedicalInsuranceAccountService;
|
import com.ruoyi.im.service.impl.InsurancePositionServiceImpl;
|
import com.ruoyi.im.util.PayService;
|
import com.ruoyi.im.util.RedisDistributedLock;
|
import com.ruoyi.im.util.UserPolicyUtils;
|
import com.ruoyi.system.domain.*;
|
import com.ruoyi.system.domain.dto.PayCallbackDTO;
|
import com.ruoyi.system.domain.dto.SubordinateInformationDto;
|
import com.ruoyi.system.domain.dto.UserPolicyDto;
|
import com.ruoyi.im.service.UserPolicyService;
|
import com.ruoyi.system.domain.out.UserTeamAndPositionOut;
|
import com.ruoyi.system.service.PaymentRecordService;
|
import com.ruoyi.system.service.UserAccountService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.catalina.User;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.validation.Valid;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.nio.charset.StandardCharsets;
|
import java.security.MessageDigest;
|
import java.security.NoSuchAlgorithmException;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@RestController
|
@RequestMapping("/userPolicy")
|
@Slf4j
|
public class UserPolicyController extends BaseController {
|
|
@Autowired
|
UserPolicyService userPolicyService;
|
|
@Autowired
|
MedicalInsuranceAccountService medicalInsuranceAccountService;
|
|
@Autowired
|
UserAccountService userAccountService;
|
|
@Autowired
|
InsurancePositionServiceImpl insurancePositionService;
|
|
@Autowired
|
private RedisDistributedLock redisDistributedLock;
|
|
@Autowired
|
InsuranceProductService insuranceProductService;
|
|
@Autowired
|
PaymentRecordService paymentRecordService;
|
|
@Value("${pay.key}")
|
private String key;
|
|
/**
|
* 保险购买申请
|
*/
|
@PostMapping("/purchaseApplication")
|
public Result purchaseApplication(UserPolicyDto dto) {
|
synchronized (dto.getAccount()) {
|
// 生成锁的key：基于用户ID和产品ID，防止同一用户同时购买同一产品
|
String lockKey = redisDistributedLock.generateLockKey(dto.getAccount(), dto.getProductId());
|
|
boolean lockAcquired = false;
|
try {
|
// 尝试获取分布式锁：等待10秒，锁过期30秒
|
lockAcquired = redisDistributedLock.tryLock(lockKey, 30L, 10L);
|
|
if (!lockAcquired) {
|
return Result.error("操作过于频繁，请稍后重试");
|
}
|
|
// 执行购买逻辑
|
return userPolicyService.purchaseApplication(dto);
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
return Result.error("购买失败");
|
} finally {
|
// 释放锁
|
if (lockAcquired) {
|
redisDistributedLock.releaseLock(lockKey);
|
}
|
}
|
}
|
}
|
|
|
|
/**
|
* 根据用户id查询保单
|
*/
|
@GetMapping("/updateGender")
|
public AjaxResult updateGender(@RequestParam(value = "id") Integer id,@RequestParam(value = "gender") UserPolicy.Gender gender) {
|
try {
|
UserPolicy userPolicy = userPolicyService.getById(id);
|
if(ObjectUtil.isEmpty(userPolicy)){
|
AjaxResult.error("保单不存在！");
|
}
|
userPolicy.setGender(gender);
|
userPolicyService.updateById(userPolicy);
|
return AjaxResult.success("修改成功");
|
}catch (Exception e){
|
e.printStackTrace();
|
return AjaxResult.error("修改失败！");
|
}
|
}
|
|
/**
|
* 根据用户id查询保单
|
*/
|
@GetMapping("/getPolicyById")
|
public Result getPolicyById(@RequestParam(value = "account") String account) {
|
try {
|
UserAccount userAccount = userAccountService.getOne(new LambdaQueryWrapper<UserAccount>()
|
.eq(UserAccount::getAccount,account));
|
List<UserPolicy> list = userPolicyService.list(new LambdaQueryWrapper<UserPolicy>()
|
.eq(UserPolicy::getUserId, userAccount.getId())
|
.eq(UserPolicy::getPayStatus,2)
|
.eq(UserPolicy::getApprovalStatus,1)
|
);
|
return Result.success(list);
|
}catch (Exception e){
|
e.printStackTrace();
|
return Result.error("查询失败");
|
}
|
}
|
|
/**
|
* 保单列表
|
*/
|
@GetMapping("/list")
|
public TableDataInfo list(@RequestParam(value = "account",required = false) String account,
|
@RequestParam(value = "state",defaultValue = "0") Integer state,
|
@RequestParam(value = "productName",required = false) String productName) {
|
startPage();
|
|
LambdaQueryWrapper<UserPolicy> wrapper = new LambdaQueryWrapper<>();
|
|
// 产品名称模糊查询
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(account)) {
|
wrapper.like(UserPolicy::getAccount, account);
|
}
|
|
// 产品代码模糊查询
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(productName)) {
|
wrapper.like(UserPolicy::getProductName, productName);
|
}
|
|
// 审批状态
|
if (state != null && state == 3) {
|
wrapper.ne(UserPolicy::getApprovalStatus, 0);
|
}else{
|
wrapper.eq(UserPolicy::getApprovalStatus, 0);
|
wrapper.eq(UserPolicy::getPayStatus,2);
|
}
|
|
// 按创建时间倒序排列
|
wrapper.orderByDesc(UserPolicy::getCreatedAt);
|
|
List<UserPolicy> list = userPolicyService.list(wrapper);
|
return getDataTable(list);
|
}
|
|
|
/**
|
* 支付记录列表
|
*/
|
@GetMapping("/PaymentRecordList")
|
public TableDataInfo PaymentRecordList( @RequestParam(value = "account",required = false) String account,
|
@RequestParam(value = "payOrdeNo",required = false) String payOrdeNo,
|
@RequestParam(value = "paymentStatus",required = false) Integer paymentStatus) {
|
startPage();
|
|
LambdaQueryWrapper<PaymentRecord> wrapper = new LambdaQueryWrapper<>();
|
|
if (StringUtils.isNotEmpty(account)) {
|
wrapper.eq(PaymentRecord::getAccount, account);
|
}
|
// 产品名称模糊查询
|
if (StringUtils.isNotEmpty(payOrdeNo)) {
|
wrapper.eq(PaymentRecord::getPayOrdeNo, payOrdeNo);
|
}
|
if (paymentStatus != null) {
|
wrapper.eq(PaymentRecord::getPaymentStatus, paymentStatus);
|
}
|
// 按创建时间倒序排列
|
wrapper.orderByDesc(PaymentRecord::getCreateTime);
|
|
List<PaymentRecord> list = paymentRecordService.list(wrapper);
|
return getDataTable(list);
|
}
|
|
/**
|
* 保单审批
|
*/
|
@GetMapping("/examine")
|
@Transactional
|
public AjaxResult examine(@RequestParam(value = "id") Integer id,
|
@RequestParam(value = "approvalStatus") Integer approvalStatus,
|
@RequestParam(value = "message",required = false) String message) {
|
try {
|
UserPolicy userPolicy = userPolicyService.getById(id);
|
if(ObjectUtil.isEmpty(userPolicy)){
|
return AjaxResult.error("订单不存在");
|
}
|
if(userPolicy.getApprovalStatus() != 0){
|
return AjaxResult.error("订单已审批！");
|
}
|
if(approvalStatus == 2 && StringUtils.isEmpty(message)){
|
return AjaxResult.error("驳回理由不能为空！");
|
}
|
if(userPolicy.getPayStatus() != 3 && userPolicy.getPayStatus() != 2){
|
return AjaxResult.error("保单未支付完成，不能进行审批！");
|
}
|
UserAccount userAccount = userAccountService.getById(userPolicy.getUserId());
|
if(approvalStatus == 2){
|
userPolicy.setApprovalStatus(approvalStatus);
|
userPolicy.setMessage(message);
|
userPolicy.setUpdatedAt(new Date());
|
userPolicyService.updateById(userPolicy);
|
|
userAccount.setBalance(userAccount.getBalance().add(userPolicy.getPremium()));
|
userAccountService.updateById(userAccount);
|
return AjaxResult.success("审批成功");
|
}
|
|
//计算到期时间
|
LocalDate expirationTime = calculateInsuranceEndDate(LocalDate.now(), userPolicy.getTerm());
|
//保险金领取到期时间
|
LocalDate insuranceBenefitExpiryDate = calculateInsuranceEndDateToDay(LocalDate.now(), userPolicy.getNumberDays());
|
|
userPolicy.setApprovalStatus(approvalStatus);
|
userPolicy.setMessage(message);
|
userPolicy.setStartDate(LocalDate.now());
|
userPolicy.setEndDate(expirationTime.minusDays(1));
|
userPolicy.setInsuranceBenefitExpiryDate(insuranceBenefitExpiryDate);
|
userPolicy.setPolicyStatus(UserPolicy.PolicyStatus.ACTIVE);
|
userPolicy.setUpdatedAt(new Date());
|
userPolicyService.updateById(userPolicy);
|
|
|
//每天可领
|
BigDecimal amountClaimed = userPolicy.getCoverageAmount()
|
.divide(new BigDecimal(userPolicy.getNumberDays()), 4, RoundingMode.HALF_UP);
|
|
MedicalInsuranceAccount medicalInsuranceAccount = new MedicalInsuranceAccount();
|
medicalInsuranceAccount.setUserId(userPolicy.getUserId());
|
medicalInsuranceAccount.setPolicyId(userPolicy.getId());
|
medicalInsuranceAccount.setProductId(userPolicy.getProductId());
|
medicalInsuranceAccount.setTotalQuota(userPolicy.getCoverageAmount());
|
medicalInsuranceAccount.setRemainingBalance(BigDecimal.ZERO);
|
medicalInsuranceAccount.setAmountClaimed(amountClaimed);
|
medicalInsuranceAccount.setAlreadyReceived(BigDecimal.ZERO);
|
medicalInsuranceAccount.setAmountAlreadyUsed(BigDecimal.ZERO);
|
medicalInsuranceAccount.setEffectiveDate(userPolicy.getStartDate());
|
medicalInsuranceAccount.setInsuranceBenefitExpiryDate(userPolicy.getInsuranceBenefitExpiryDate());
|
medicalInsuranceAccount.setExpiryDate(userPolicy.getEndDate());
|
medicalInsuranceAccount.setAccountStatus(MedicalInsuranceAccount.AccountStatus.ACTIVE);
|
medicalInsuranceAccount.setCreatedAt(new Date());
|
medicalInsuranceAccount.setUpdatedAt(new Date());
|
medicalInsuranceAccountService.save(medicalInsuranceAccount);
|
|
//判断上级用户职位达成
|
if(approvalStatus == 1){
|
if(StringUtils.isNotEmpty(userAccount.getInvitationAccount())){
|
//上级
|
UserAccount superiorUser = userAccountService.getOne(new LambdaQueryWrapper<UserAccount>()
|
.eq(UserAccount::getAccount, userAccount.getInvitationAccount())
|
);
|
//查询上级的所有下级
|
List<UserAccount> userAccountList = userAccountService.list(new LambdaQueryWrapper<UserAccount>()
|
.eq(UserAccount::getInvitationAccount, superiorUser.getAccount())
|
);
|
if(userAccountList.size() == 0){
|
return AjaxResult.success("审批成功");
|
}
|
List<Integer> idList = userAccountList.stream()
|
.map(UserAccount::getId)
|
.collect(Collectors.toList());
|
//查询下级的保单
|
List<UserPolicy> userPolicyList = userPolicyService.list(new LambdaQueryWrapper<>(UserPolicy.class)
|
.in(UserPolicy::getUserId, idList)
|
);
|
// 手动将当前审批的保单加入到列表中（因为事务隔离可能查不到）
|
userPolicyList.add(userPolicy);
|
if(userPolicyList.size() == 0){
|
return AjaxResult.success("审批成功");
|
}
|
//生效保单数量
|
long activePolicies = UserPolicyUtils.countActivePolicies(userPolicyList);
|
//查询所有职位
|
List<InsurancePosition> positions = insurancePositionService.list();
|
positions.forEach(f->{
|
if(activePolicies >= f.getNumberPeople()){
|
superiorUser.setPosition(f.getPosition());
|
superiorUser.setAgreedTime(LocalDate.now());
|
}
|
});
|
userAccountService.updateById(superiorUser);
|
}
|
return AjaxResult.success("审批成功");
|
}
|
return AjaxResult.success("审批成功");
|
}catch (Exception e){
|
e.printStackTrace();
|
// 手动设置回滚
|
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
return AjaxResult.error("审批失败！");
|
}
|
}
|
|
/**
|
* 计算保险到期日按天
|
* @param startDate 保险开始日期
|
* @param termDays 保险天数
|
* @return 保险到期日期
|
*/
|
public static LocalDate calculateInsuranceEndDateToDay(LocalDate startDate, int termDays) {
|
return calculateDateAfterDays(startDate, termDays);
|
}
|
|
/**
|
* 计算指定天数后的日期
|
* @param startDate 开始日期
|
* @param daysToAdd 要添加的天数
|
* @return 计算后的日期
|
*/
|
public static LocalDate calculateDateAfterDays(LocalDate startDate, int daysToAdd) {
|
if (startDate == null) {
|
throw new IllegalArgumentException("开始日期不能为空");
|
}
|
return startDate.plusDays(daysToAdd);
|
}
|
|
/**
|
* 计算保险到期日
|
* @param startDate 保险开始日期
|
* @param termYears 保险年限
|
* @return 保险到期日期
|
*/
|
public static LocalDate calculateInsuranceEndDate(LocalDate startDate, int termYears) {
|
return calculateDateAfterYears(startDate, termYears);
|
}
|
|
/**
|
* 根据基准日期和年限推算日期
|
*/
|
public static LocalDate calculateDateAfterYears(LocalDate baseDate, int years) {
|
validateBaseDate(baseDate);
|
return baseDate.plusYears(years);
|
}
|
|
/**
|
* 验证基准日期
|
*/
|
private static void validateBaseDate(LocalDate baseDate) {
|
if (baseDate == null) {
|
throw new IllegalArgumentException("基准日期不能为null");
|
}
|
}
|
|
|
|
@PostMapping("/notify")
|
public String payNotify(@RequestBody PayCallbackDTO callbackDTO) {
|
try {
|
log.info("收到支付回调通知: {}", JSON.toJSONString(callbackDTO));
|
|
// 1. 验证签名
|
if (!verifySign(callbackDTO)) {
|
log.error("签名验证失败: {}", callbackDTO.getOrderId());
|
return "签名验证失败";
|
}
|
|
// 2. 根据订单号查询保单
|
UserPolicy userPolicy = userPolicyService.getOne(new LambdaQueryWrapper<UserPolicy>()
|
.eq(UserPolicy::getOrderNo, callbackDTO.getOrderId()));
|
if (userPolicy == null) {
|
log.error("订单不存在: {}", callbackDTO.getOrderId());
|
return "订单不存在";
|
}
|
if(userPolicy.getPayStatus() == 2){
|
log.error("订单已支付完成: {}", callbackDTO.getOrderId());
|
return "订单已支付完成";
|
}
|
// 3. 根据订单状态处理业务逻辑
|
boolean processResult = processPayResult(callbackDTO, userPolicy);
|
|
return processResult ? "success" : "fail";
|
|
} catch (Exception e) {
|
log.error("支付回调处理异常: {}", e.getMessage(), e);
|
return "FAIL";
|
}
|
}
|
|
private boolean verifySign(PayCallbackDTO callbackDTO) {
|
try {
|
Map<String, Object> params = new HashMap<>();
|
params.put("channelCode", callbackDTO.getChannelCode());
|
params.put("orderId", callbackDTO.getOrderId());
|
params.put("orderMoney", callbackDTO.getOrderMoney());
|
params.put("orderStatus", callbackDTO.getOrderStatus());
|
params.put("userCode", callbackDTO.getUserCode());
|
|
String generatedSign = generateCallbackSign(params);
|
return generatedSign.equalsIgnoreCase(callbackDTO.getSign());
|
} catch (Exception e) {
|
log.error("签名验证异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
private String generateCallbackSign(Map<String, Object> params) {
|
try {
|
List<String> keys = new ArrayList<>(params.keySet());
|
Collections.sort(keys);
|
|
StringBuilder stringA = new StringBuilder();
|
for (String key : keys) {
|
Object value = params.get(key);
|
if (value != null && !"".equals(value.toString().trim()) && !"sign".equals(key)) {
|
if (stringA.length() > 0) {
|
stringA.append("&");
|
}
|
stringA.append(key).append("=").append(value.toString());
|
}
|
}
|
|
String stringSignTemp = stringA.toString() + "&key=" + key;
|
String md5Result = md5(stringSignTemp);
|
return md5Result.toLowerCase();
|
|
} catch (Exception e) {
|
throw new RuntimeException("生成回调签名失败: " + e.getMessage());
|
}
|
}
|
|
private boolean processPayResult(PayCallbackDTO callbackDTO, UserPolicy userPolicy) {
|
try {
|
switch (callbackDTO.getOrderStatus()) {
|
case 2: // 已支付
|
return handlePaySuccess(callbackDTO, userPolicy);
|
case 3: // 超时/过期
|
return handlePayTimeout(callbackDTO, userPolicy);
|
default:
|
log.info("订单状态未完成: {}, 状态: {}", callbackDTO.getOrderId(), callbackDTO.getOrderStatus());
|
return true;
|
}
|
} catch (Exception e) {
|
log.error("处理支付结果异常: {}", e.getMessage(), e);
|
return false;
|
}
|
}
|
|
private boolean handlePaySuccess(PayCallbackDTO callbackDTO, UserPolicy userPolicy) {
|
if (userPolicy.getPayStatus() == 2) {
|
log.info("订单已支付，无需重复处理: {}", callbackDTO.getOrderId());
|
return true;
|
}
|
|
userPolicy.setPayStatus(2); // 2-支付成功
|
userPolicy.setPolicyStatus(UserPolicy.PolicyStatus.ACTIVE);
|
userPolicy.setUpdatedAt(new Date());
|
|
boolean updateResult = userPolicyService.updateById(userPolicy);
|
PaymentRecord paymentRecord = paymentRecordService.getOne(new LambdaQueryWrapper<PaymentRecord>()
|
.eq(PaymentRecord::getPayOrdeNo, callbackDTO.getOrderId())
|
);
|
if(ObjectUtil.isNotEmpty(paymentRecord)){
|
paymentRecord.setPaymentStatus(PaymentRecord.PaymentStatus.PAID.getCode());
|
paymentRecordService.updateById(paymentRecord);
|
}
|
if (updateResult) {
|
log.info("支付成功处理完成: {}", callbackDTO.getOrderId());
|
return true;
|
} else {
|
log.error("更新保单状态失败: {}", callbackDTO.getOrderId());
|
return false;
|
}
|
}
|
|
private boolean handlePayTimeout(PayCallbackDTO callbackDTO, UserPolicy userPolicy) {
|
userPolicy.setPayStatus(3); // 3-支付超时/过期
|
userPolicy.setPolicyStatus(UserPolicy.PolicyStatus.EXPIRED);
|
userPolicy.setUpdatedAt(new Date());
|
|
boolean updateResult = userPolicyService.updateById(userPolicy);
|
PaymentRecord paymentRecord = paymentRecordService.getOne(new LambdaQueryWrapper<PaymentRecord>()
|
.eq(PaymentRecord::getPayOrdeNo, callbackDTO.getOrderId())
|
);
|
if(ObjectUtil.isNotEmpty(paymentRecord)){
|
paymentRecord.setPaymentStatus(PaymentRecord.PaymentStatus.EXPIRED.getCode());
|
paymentRecordService.updateById(paymentRecord);
|
}
|
if (updateResult) {
|
log.info("支付超时处理完成: {}", callbackDTO.getOrderId());
|
return true;
|
} else {
|
log.error("更新保单超时状态失败: {}", callbackDTO.getOrderId());
|
return false;
|
}
|
}
|
|
private String md5(String input) {
|
try {
|
MessageDigest md = MessageDigest.getInstance("MD5");
|
byte[] messageDigest = md.digest(input.getBytes(StandardCharsets.UTF_8));
|
|
StringBuilder hexString = new StringBuilder();
|
for (byte b : messageDigest) {
|
String hex = Integer.toHexString(0xff & b);
|
if (hex.length() == 1) {
|
hexString.append('0');
|
}
|
hexString.append(hex);
|
}
|
return hexString.toString();
|
} catch (NoSuchAlgorithmException e) {
|
throw new RuntimeException("MD5加密失败", e);
|
}
|
}
|
|
/**
|
* 保单列表
|
*/
|
@GetMapping("/deleteRecordById")
|
public AjaxResult PaymentRecordList(@RequestParam(value = "id",required = false) Integer id) {
|
// 查询所有创建时间超过5分钟且状态为待支付的订单
|
PaymentRecord byId = paymentRecordService.getById(id);
|
if(ObjectUtil.isEmpty(byId)){
|
return AjaxResult.error("订单不存在！");
|
}
|
if(byId.getPaymentStatus() == 2){
|
return AjaxResult.error("订单已支付，禁止删除");
|
}
|
UserPolicy userPolicy = userPolicyService.getById(byId.getOrderId());
|
if(ObjectUtil.isEmpty(userPolicy)){
|
return AjaxResult.error("保单不存在！");
|
}
|
if(userPolicy.getPayStatus() == 2){
|
return AjaxResult.error("订单已支付，禁止删除");
|
}
|
|
paymentRecordService.removeById(byId);
|
userPolicyService.removeById(userPolicy);
|
return AjaxResult.success("删除成功");
|
}
|
|
}
|
