Skip to content

Y
yd-csf
Commit 01a1bb96 by zhangxingmin
Options

push

parent 6d84d763
Showing with 2585 additions and 2 deletions
yd-csf-api/src/main/java/com/yd/csf/api/controller/ApiPremiumReconciliationController.java 0 → 100644
package com.yd.csf.api.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiPremiumReconciliationService;
import com.yd.csf.feign.client.premiumreconciliation.ApiPremiumReconciliationFeignClient;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.request.premiumreconciliation.ApiCalculateRemainingUnpaidAmountRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationAddRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationPageRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationResultEditRequest;
import com.yd.csf.feign.response.premiumreconciliation.ApiCalculateRemainingUnpaidAmountResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationDetailResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationPageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 保费对账记录信息
*
* @author zxm
* @since 2025-12-26
*/
@RestController
@RequestMapping("/premiumReconciliation")
@Validated
public class ApiPremiumReconciliationController implements ApiPremiumReconciliationFeignClient {
@Autowired
private ApiPremiumReconciliationService apiPremiumReconciliationService;
/**
* 分页列表查询-保费对账记录信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiPremiumReconciliationPageResponse>> page(ApiPremiumReconciliationPageRequest request) {
return apiPremiumReconciliationService.page(request);
}
/**
* 添加-保费对账记录信息（聚合信息添加）
* @param request
* @return
*/
@Override
public Result add(ApiPremiumReconciliationAddRequest request) {
return apiPremiumReconciliationService.add(request);
}
/**
* 编辑-单个保费对账记录信息
* @param request
* @return
*/
@Override
public Result edit(ApiPremiumReconciliationDto request) {
return apiPremiumReconciliationService.edit(request);
}
/**
* 详情-保费对账记录信息
* @param premiumReconciliationBizId 保费对账记录表唯一业务ID
* @return
*/
@Override
public Result<ApiPremiumReconciliationDetailResponse> detail(String premiumReconciliationBizId) {
return apiPremiumReconciliationService.detail(premiumReconciliationBizId);
}
/**
* 计算待付金额-保费对账记录信息
* @param request
* @return
*/
@Override
public Result<ApiCalculateRemainingUnpaidAmountResponse> calculateRemainingUnpaidAmount(ApiCalculateRemainingUnpaidAmountRequest request) {
return apiPremiumReconciliationService.calculateRemainingUnpaidAmount(request);
}
/**
* 设置认定结果-保费对账记录信息
* @param request
* @return
*/
@Override
public Result editResult(ApiPremiumReconciliationResultEditRequest request) {
return apiPremiumReconciliationService.editResult(request);
}
}
yd-csf-api/src/main/java/com/yd/csf/api/controller/ApiPremiumRemittanceController.java 0 → 100644
package com.yd.csf.api.controller;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiPremiumRemittanceService;
import com.yd.csf.feign.client.premiumremittance.ApiPremiumRemittanceFeignClient;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 保费对账-汇款记录信息
*
* @author zxm
* @since 2025-12-26
*/
@RestController
@RequestMapping("/premiumRemittance")
@Validated
public class ApiPremiumRemittanceController implements ApiPremiumRemittanceFeignClient {
@Autowired
private ApiPremiumRemittanceService apiPremiumRemittanceService;
/**
* 添加-单个保费对账汇款记录信息
* @param request
* @return
*/
@Override
public Result add(ApiPremiumRemittanceDto request) {
return apiPremiumRemittanceService.add(request);
}
/**
* 编辑-单个保费对账汇款记录信息
* @param request
* @return
*/
@Override
public Result edit(ApiPremiumRemittanceDto request) {
return apiPremiumRemittanceService.edit(request);
}
/**
* 详情-保费对账汇款记录信息
* @param premiumRemittanceBizId 保费对账-汇款记录表唯一业务ID
* @return
*/
@Override
public Result<ApiPremiumRemittanceDto> detail(String premiumRemittanceBizId) {
return apiPremiumRemittanceService.detail(premiumRemittanceBizId);
}
/**
* 删除-单个保费对账汇款记录信息
* @param premiumRemittanceBizId
* @return
*/
@Override
public Result del(String premiumRemittanceBizId) {
return apiPremiumRemittanceService.del(premiumRemittanceBizId);
}
}
yd-csf-api/src/main/java/com/yd/csf/api/controller/ApiPremiumRemittanceFileController.java 0 → 100644
package com.yd.csf.api.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiPremiumRemittanceFileService;
import com.yd.csf.feign.client.premiumremittancefile.ApiPremiumRemittanceFileFeignClient;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 保费对账-汇款记录附件信息
*
* @author zxm
* @since 2025-12-26
*/
@RestController
@RequestMapping("/premiumRemittanceFile")
@Validated
public class ApiPremiumRemittanceFileController implements ApiPremiumRemittanceFileFeignClient {
@Autowired
private ApiPremiumRemittanceFileService apiPremiumRemittanceFileService;
/**
* 分页列表查询-保费汇款记录附件信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiPremiumRemittanceFilePageResponse>> page(ApiPremiumRemittanceFilePageRequest request) {
return apiPremiumRemittanceFileService.page(request);
}
/**
* 添加-保费汇款记录附件信息
* @param request
* @return
*/
@Override
public Result add(ApiPremiumRemittanceFileDto request) {
return apiPremiumRemittanceFileService.add(request);
}
/**
* 编辑-保费汇款记录附件信息
* @param request
* @return
*/
@Override
public Result edit(ApiPremiumRemittanceFileDto request) {
return apiPremiumRemittanceFileService.edit(request);
}
/**
* 删除-保费汇款记录附件信息
* @param premiumRemittanceFileBizId
* @return
*/
@Override
public Result del(String premiumRemittanceFileBizId) {
return apiPremiumRemittanceFileService.del(premiumRemittanceFileBizId);
}
}
yd-csf-api/src/main/java/com/yd/csf/api/service/ApiPremiumReconciliationService.java 0 → 100644
package com.yd.csf.api.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.request.premiumreconciliation.ApiCalculateRemainingUnpaidAmountRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationAddRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationPageRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationResultEditRequest;
import com.yd.csf.feign.response.premiumreconciliation.ApiCalculateRemainingUnpaidAmountResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationDetailResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationPageResponse;
import com.yd.csf.service.model.PremiumReconciliation;
public interface ApiPremiumReconciliationService {
Result<IPage<ApiPremiumReconciliationPageResponse>> page(ApiPremiumReconciliationPageRequest request);
Result add(ApiPremiumReconciliationAddRequest request);
Result edit(ApiPremiumReconciliationDto request);
Result<ApiPremiumReconciliationDetailResponse> detail(String premiumReconciliationBizId);
Result<ApiCalculateRemainingUnpaidAmountResponse> calculateRemainingUnpaidAmount(ApiCalculateRemainingUnpaidAmountRequest request);
Result editResult(ApiPremiumReconciliationResultEditRequest request);
Result<PremiumReconciliation> checkPremiumReconciliationIsExist(String expectedCommissionRatioBizId);
}
yd-csf-api/src/main/java/com/yd/csf/api/service/ApiPremiumRemittanceFileService.java 0 → 100644
package com.yd.csf.api.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse;
import com.yd.csf.service.model.PremiumRemittanceFile;
import java.util.List;
public interface ApiPremiumRemittanceFileService {
Result<IPage<ApiPremiumRemittanceFilePageResponse>> page(ApiPremiumRemittanceFilePageRequest request);
Result add(ApiPremiumRemittanceFileDto request);
Result edit(ApiPremiumRemittanceFileDto request);
Result del(String premiumRemittanceFileBizId);
Result addPremiumRemittanceFileList(List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList,
String premiumRemittanceBizId);
Result savePremiumRemittanceFileList(List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList,
String premiumRemittanceBizId);
Result delByPremiumRemittanceBizId(String premiumRemittanceBizId);
List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList(String premiumRemittanceBizId);
Result<PremiumRemittanceFile> checkPremiumRemittanceFileIsExist(String premiumRemittanceFileBizId);
}
yd-csf-api/src/main/java/com/yd/csf/api/service/ApiPremiumRemittanceService.java 0 → 100644
package com.yd.csf.api.service;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import com.yd.csf.service.model.PremiumRemittance;
import java.util.List;
public interface ApiPremiumRemittanceService {
Result add(ApiPremiumRemittanceDto request);
Result edit(ApiPremiumRemittanceDto request);
Result<ApiPremiumRemittanceDto> detail(String premiumRemittanceBizId);
Result del(String premiumRemittanceBizId);
Result addPremiumRemittanceList(List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList,
String premiumReconciliationBizId);
List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList(String premiumReconciliationBizId);
Result<PremiumRemittance> checkPremiumRemittanceIsExist(String premiumRemittanceBizId);
}
yd-csf-api/src/main/java/com/yd/csf/api/service/impl/ApiPremiumReconciliationServiceImpl.java 0 → 100644
package com.yd.csf.api.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.base.feign.client.exchangerate.ApiExchangeRateFeignClient;
import com.yd.base.feign.request.exchangerate.ApiExchangeRateConvertRequest;
import com.yd.base.feign.response.exchangerate.ApiExchangeRateConvertResponse;
import com.yd.common.enums.CommonEnum;
import com.yd.common.exception.BusinessException;
import com.yd.common.result.Result;
import com.yd.common.utils.RandomStringGenerator;
import com.yd.csf.api.service.ApiPremiumReconciliationService;
import com.yd.csf.api.service.ApiPremiumRemittanceService;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import com.yd.csf.feign.enums.ReconciliationStatusEnum;
import com.yd.csf.feign.request.premiumreconciliation.ApiCalculateRemainingUnpaidAmountRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationAddRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationPageRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationResultEditRequest;
import com.yd.csf.feign.response.premiumreconciliation.ApiCalculateRemainingUnpaidAmountResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationDetailResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationPageResponse;
import com.yd.csf.service.dto.PremiumReconciliationDto;
import com.yd.csf.service.model.Policy;
import com.yd.csf.service.model.PremiumReconciliation;
import com.yd.csf.service.service.IPremiumReconciliationService;
import com.yd.csf.service.service.PolicyService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;
import java.util.Objects;
@Slf4j
@Service
public class ApiPremiumReconciliationServiceImpl implements ApiPremiumReconciliationService {
@Autowired
private PolicyService policyService;
@Autowired
private IPremiumReconciliationService iPremiumReconciliationService;
@Autowired
private ApiPremiumRemittanceService apiPremiumRemittanceService;
@Autowired
private ApiExchangeRateFeignClient apiExchangeRateFeignClient;
/**
* 分页列表查询-保费对账记录信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiPremiumReconciliationPageResponse>> page(ApiPremiumReconciliationPageRequest request) {
return null;
}
/**
* 添加-保费对账记录信息
* @param request
* @return
*/
@Override
public Result add(ApiPremiumReconciliationAddRequest request) {
//保费对账信息
ApiPremiumReconciliationDto apiPremiumReconciliationDto = request.getApiPremiumReconciliationDto();
//校验保单信息是否存在
Policy policy = policyService.queryOne(apiPremiumReconciliationDto.getPolicyNo());
if (Objects.isNull(policy)) {
throw new BusinessException("保单信息不存在");
}
//获取保单当前期数 TODO
PremiumReconciliation premiumReconciliation = new PremiumReconciliation();
//申请人
premiumReconciliation.setApplicant(apiPremiumReconciliationDto.getApplicant());
//当前期数 TODO
// premiumReconciliation.setCurrentIssueNumber();
//保单受保人（被保人）
premiumReconciliation.setInsured(policy.getInsured());
//保险公司名称
premiumReconciliation.setInsurer(policy.getInsurer());
//保单号
premiumReconciliation.setPolicyNo(policy.getPolicyNo());
//保费对账记录表唯一业务ID
premiumReconciliation.setPremiumReconciliationBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_PREMIUM_RECONCILIATION.getCode()));
//对账状态 - 保司对账中
premiumReconciliation.setReconciliationStatus(ReconciliationStatusEnum.BS_DZZ.getItemValue());
iPremiumReconciliationService.saveOrUpdate(premiumReconciliation);
//添加-保费对账汇款记录列表
apiPremiumRemittanceService.addPremiumRemittanceList(request.getApiPremiumRemittanceDtoList(),
premiumReconciliation.getPremiumReconciliationBizId());
return Result.success();
}
/**
* 编辑-单个保费对账记录信息
* @param request
* @return
*/
@Override
public Result edit(ApiPremiumReconciliationDto request) {
if (StringUtils.isBlank(request.getPremiumReconciliationBizId())) {
throw new BusinessException("保费对账记录表唯一业务ID不能为空");
}
//校验保费对账记录信息是否存在
Result<PremiumReconciliation> result = checkPremiumReconciliationIsExist(request.getPremiumReconciliationBizId());
PremiumReconciliation premiumReconciliation = result.getData();
BeanUtils.copyProperties(request,premiumReconciliation);
iPremiumReconciliationService.saveOrUpdate(premiumReconciliation);
return Result.success();
}
/**
* 详情-保费对账记录信息
* @param premiumReconciliationBizId 保费对账记录表唯一业务ID
* @return
*/
@Override
public Result<ApiPremiumReconciliationDetailResponse> detail(String premiumReconciliationBizId) {
ApiPremiumReconciliationDetailResponse response = new ApiPremiumReconciliationDetailResponse();
//校验保费对账记录信息是否存在
Result<PremiumReconciliation> result = checkPremiumReconciliationIsExist(premiumReconciliationBizId);
PremiumReconciliation premiumReconciliation = result.getData();
ApiPremiumReconciliationDto apiPremiumReconciliationDto = new ApiPremiumReconciliationDto();
BeanUtils.copyProperties(premiumReconciliation,apiPremiumReconciliationDto);
response.setApiPremiumReconciliationDto(apiPremiumReconciliationDto);
//保费对账-汇款记录列表
List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList = apiPremiumRemittanceService.apiPremiumRemittanceDtoList(premiumReconciliationBizId);
response.setApiPremiumRemittanceDtoList(apiPremiumRemittanceDtoList);
return Result.success(response);
}
/**
* 计算待付金额-保费对账记录信息
* @param request
* @return
*/
@Override
public Result<ApiCalculateRemainingUnpaidAmountResponse> calculateRemainingUnpaidAmount(ApiCalculateRemainingUnpaidAmountRequest request) {
//校验保费对账记录信息是否存在
Result<PremiumReconciliation> result = checkPremiumReconciliationIsExist(request.getPremiumReconciliationBizId());
PremiumReconciliation premiumReconciliation = result.getData();
//查询保单信息
Policy policy = policyService.queryOne(premiumReconciliation.getPolicyNo());
if (Objects.isNull(policy)) {
throw new BusinessException("保单信息不存在");
}
//获取保单币种
String policyCurrency = policy.getCurrency();
if (StringUtils.isBlank(policyCurrency)) {
throw new BusinessException("保单币种不能为空");
}
//验证保单币种是否支持 - 通过Feign客户端调用
Result<Boolean> currencySupportedResult = apiExchangeRateFeignClient.isCurrencySupportedResult(policyCurrency);
if (currencySupportedResult.getCode() != 200 || Boolean.FALSE.equals(currencySupportedResult.getData())) {
throw new BusinessException("保单币种不支持: " + policyCurrency);
}
//将当次保司认定金额转换为保单币种的金额
String recognizedCurrency = request.getRecognizedCurrency();
if (StringUtils.isBlank(recognizedCurrency)) {
throw new BusinessException("当次保司认定币种不能为空");
}
//验证认定币种是否支持 - 通过Feign客户端调用
Result<Boolean> recognizedCurrencySupportedResult = apiExchangeRateFeignClient.isCurrencySupportedResult(recognizedCurrency);
if (recognizedCurrencySupportedResult.getCode() != 200 || Boolean.FALSE.equals(recognizedCurrencySupportedResult.getData())) {
throw new BusinessException("认定币种不支持: " + recognizedCurrency);
}
//转换当次保司认定金额到保单币种的金额 - 通过Feign客户端调用
BigDecimal currentRecognizedAmount = request.getRecognizedAmount();
BigDecimal currentRecognizedAmountInPolicyCurrency;
if (recognizedCurrency.equalsIgnoreCase(policyCurrency)) {
// 币种相同，直接使用原金额
currentRecognizedAmountInPolicyCurrency = currentRecognizedAmount;
} else {
// 币种不相同，调用汇率服务进行转换
ApiExchangeRateConvertRequest convertRequest = new ApiExchangeRateConvertRequest();
//被转换金额
convertRequest.setAmount(currentRecognizedAmount);
//被转换币种
convertRequest.setFromCurrency(recognizedCurrency);
//转换币种
convertRequest.setToCurrency(policyCurrency);
// 可以根据需要设置交易日期或汇率日期，这里null查询最新汇率日期的汇率转换
convertRequest.setTransactionDate(null);
// convertRequest.setTransactionDate(request.getTransactionDate());
Result<ApiExchangeRateConvertResponse> convertResult = apiExchangeRateFeignClient.convert(convertRequest);
if (convertResult.getCode() != 200) {
throw new BusinessException("币种转换失败: " + convertResult.getMsg());
}
currentRecognizedAmountInPolicyCurrency = convertResult.getData().getConvertedAmount();
}
//根据当前期数和保单号，查询非当前保费对账记录的保司认定金额之和
List<PremiumReconciliation> premiumReconciliationList = iPremiumReconciliationService.queryList(PremiumReconciliationDto.builder()
.premiumReconciliationBizId(request.getPremiumReconciliationBizId())
.currentIssueNumber(premiumReconciliation.getCurrentIssueNumber())
.isExcludeMy(true)
.build());
//计算非当前保费对账记录的保司认定金额之和（转换为保单币种）
BigDecimal otherRecognizedAmountSumInPolicyCurrency = BigDecimal.ZERO;
if (!CollectionUtils.isEmpty(premiumReconciliationList)) {
for (PremiumReconciliation pr : premiumReconciliationList) {
if (pr.getRecognizedAmount() != null && StringUtils.isNotBlank(pr.getRecognizedCurrency())) {
//将每条记录的认定金额转换为保单币种
BigDecimal convertedAmount;
if (pr.getRecognizedCurrency().equalsIgnoreCase(policyCurrency)) {
// 币种相同，直接使用
convertedAmount = pr.getRecognizedAmount();
} else {
// 调用汇率服务进行转换
ApiExchangeRateConvertRequest prConvertRequest = new ApiExchangeRateConvertRequest();
prConvertRequest.setAmount(pr.getRecognizedAmount());
prConvertRequest.setFromCurrency(pr.getRecognizedCurrency());
prConvertRequest.setToCurrency(policyCurrency);
Result<ApiExchangeRateConvertResponse> prConvertResult = apiExchangeRateFeignClient.convert(prConvertRequest);
if (prConvertResult.getCode() != 200) {
log.warn("保费对账记录币种转换失败，记录ID: {}, 原因: {}",
pr.getPremiumReconciliationBizId(), prConvertResult.getMsg());
continue; // 跳过转换失败的记录
}
convertedAmount = prConvertResult.getData().getConvertedAmount();
}
otherRecognizedAmountSumInPolicyCurrency = otherRecognizedAmountSumInPolicyCurrency.add(convertedAmount);
}
}
}
//计算总认定金额（保单币种）
BigDecimal totalRecognizedAmountInPolicyCurrency =
otherRecognizedAmountSumInPolicyCurrency.add(currentRecognizedAmountInPolicyCurrency);
//获取期交保费（如果为空则设为0）
BigDecimal paymentPremium = policy.getPaymentPremium() != null ?
policy.getPaymentPremium() : BigDecimal.ZERO;
//获取保单征费（转换为BigDecimal）
BigDecimal policyLevy = BigDecimal.ZERO;
if (StringUtils.isNotBlank(policy.getPolicyLevy())) {
try {
// 注意：保单征费的币种应该与保单币种一致，但这里可以再次确认
String policyLevyStr = policy.getPolicyLevy().trim();
// 如果保单征费包含币种信息，需要解析，这里假设是纯数字字符串
policyLevy = new BigDecimal(policyLevyStr);
} catch (NumberFormatException e) {
log.error("保单征费格式错误，policyLevy: {}", policy.getPolicyLevy());
throw new BusinessException("保单征费格式错误，无法计算");
}
}
//计算总额和剩余待付金额（均为保单币种）
BigDecimal totalPremium = paymentPremium.add(policyLevy);
BigDecimal remainingUnpaidAmount = totalPremium.subtract(totalRecognizedAmountInPolicyCurrency);
//如果剩余待付金额为负数，说明已超额支付，可以设为0或负数，根据业务需求
// 如果要求不能为负数，则取最大值
// remainingUnpaidAmount = remainingUnpaidAmount.max(BigDecimal.ZERO);
// 设置精度，保留2位小数，银行家舍入法
remainingUnpaidAmount = remainingUnpaidAmount.setScale(2, RoundingMode.HALF_EVEN);
//构建响应对象
ApiCalculateRemainingUnpaidAmountResponse response = new ApiCalculateRemainingUnpaidAmountResponse();
response.setRemainingUnpaidAmount(remainingUnpaidAmount);
response.setRemainingUnpaidCurrency(policyCurrency);
return Result.success(response);
}
/**
* 设置认定结果-保费对账记录信息
* @param request
* @return
*/
@Override
public Result editResult(ApiPremiumReconciliationResultEditRequest request) {
return null;
}
/**
* 校验保费对账记录信息是否存在
* @param premiumReconciliationBizId
* @return
*/
@Override
public Result<PremiumReconciliation> checkPremiumReconciliationIsExist(String premiumReconciliationBizId) {
PremiumReconciliation premiumReconciliation = iPremiumReconciliationService.queryOne(premiumReconciliationBizId);
if (Objects.isNull(premiumReconciliation)) {
//数据不存在
throw new BusinessException("保费对账记录信息不存在");
}
return Result.success(premiumReconciliation);
}
}
yd-csf-api/src/main/java/com/yd/csf/api/service/impl/ApiPremiumRemittanceFileServiceImpl.java 0 → 100644
package com.yd.csf.api.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.common.enums.CommonEnum;
import com.yd.common.exception.BusinessException;
import com.yd.common.result.Result;
import com.yd.common.utils.RandomStringGenerator;
import com.yd.csf.api.service.ApiPremiumRemittanceFileService;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse;
import com.yd.csf.service.model.PremiumRemittanceFile;
import com.yd.csf.service.service.IPremiumRemittanceFileService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
@Slf4j
@Service
public class ApiPremiumRemittanceFileServiceImpl implements ApiPremiumRemittanceFileService {
@Autowired
private IPremiumRemittanceFileService iPremiumRemittanceFileService;
/**
* 分页列表查询-保费汇款记录附件信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiPremiumRemittanceFilePageResponse>> page(ApiPremiumRemittanceFilePageRequest request) {
Page<ApiPremiumRemittanceFilePageResponse> page = new Page<>(request.getPageNo(), request.getPageSize());
IPage<ApiPremiumRemittanceFilePageResponse> iPage = iPremiumRemittanceFileService.page(page, request);
return Result.success(iPage);
}
/**
* 添加-保费汇款记录附件信息
* @param request
* @return
*/
@Override
public Result add(ApiPremiumRemittanceFileDto request) {
if (StringUtils.isBlank(request.getPremiumRemittanceBizId())) {
throw new BusinessException("保费对账-汇款记录表唯一业务ID不能为空");
}
PremiumRemittanceFile premiumRemittanceFile = new PremiumRemittanceFile();
BeanUtils.copyProperties(request,premiumRemittanceFile);
premiumRemittanceFile.setPremiumRemittanceBizId(request.getPremiumRemittanceBizId());
premiumRemittanceFile.setPremiumRemittanceFileBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_PREMIUM_REMITTANCE_FILE.getCode()));
iPremiumRemittanceFileService.saveOrUpdate(premiumRemittanceFile);
return Result.success();
}
/**
* 编辑-保费汇款记录附件信息
* @param request
* @return
*/
@Override
public Result edit(ApiPremiumRemittanceFileDto request) {
if (StringUtils.isBlank(request.getPremiumRemittanceBizId())) {
throw new BusinessException("保费对账-汇款记录表唯一业务ID不能为空");
}
if (StringUtils.isBlank(request.getPremiumRemittanceFileBizId())) {
throw new BusinessException("保费汇款记录附件表唯一业务ID不能为空");
}
Result<PremiumRemittanceFile> result = checkPremiumRemittanceFileIsExist(request.getPremiumRemittanceFileBizId());
PremiumRemittanceFile file = result.getData();
BeanUtils.copyProperties(request,file);
iPremiumRemittanceFileService.saveOrUpdate(file);
return Result.success();
}
/**
* 删除-保费汇款记录附件信息
* @param premiumRemittanceFileBizId
* @return
*/
@Override
public Result del(String premiumRemittanceFileBizId) {
Result<PremiumRemittanceFile> result = checkPremiumRemittanceFileIsExist(premiumRemittanceFileBizId);
PremiumRemittanceFile file = result.getData();
iPremiumRemittanceFileService.removeById(file.getId());
return Result.success();
}
/**
* 添加-保费对账汇款记录附件列表
* @param apiPremiumRemittanceFileDtoList
* @param premiumRemittanceBizId
* @return
*/
@Override
public Result addPremiumRemittanceFileList(List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList,
String premiumRemittanceBizId) {
if (CollectionUtils.isEmpty(apiPremiumRemittanceFileDtoList)) {
return Result.success();
}
List<PremiumRemittanceFile> addPremiumRemittanceFileList = apiPremiumRemittanceFileDtoList
.stream().map(dto -> {
PremiumRemittanceFile file = new PremiumRemittanceFile();
BeanUtils.copyProperties(dto,file);
file.setPremiumRemittanceBizId(premiumRemittanceBizId);
file.setPremiumRemittanceFileBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_PREMIUM_REMITTANCE_FILE.getCode()));
return file;
}).collect(Collectors.toList());
iPremiumRemittanceFileService.saveOrUpdateBatch(addPremiumRemittanceFileList);
return Result.success();
}
/**
* 保存-保费对账汇款记录附件列表
* @param apiPremiumRemittanceFileDtoList
* @param premiumRemittanceBizId
* @return
*/
@Override
public Result savePremiumRemittanceFileList(List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList,
String premiumRemittanceBizId) {
//先删后新增
iPremiumRemittanceFileService.delByPremiumRemittanceBizId(premiumRemittanceBizId);
//新增
if (CollectionUtils.isEmpty(apiPremiumRemittanceFileDtoList)) {
return Result.success();
}
List<PremiumRemittanceFile> saveList = apiPremiumRemittanceFileDtoList.stream().map(dto -> {
PremiumRemittanceFile file = new PremiumRemittanceFile();
BeanUtils.copyProperties(dto,file);
file.setPremiumRemittanceBizId(premiumRemittanceBizId);
file.setPremiumRemittanceFileBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_PREMIUM_REMITTANCE_FILE.getCode()));
return file;
}).collect(Collectors.toList());
iPremiumRemittanceFileService.saveOrUpdateBatch(saveList);
return Result.success();
}
/**
* 根据保费对账-汇款记录表唯一业务ID删除
* @param premiumRemittanceBizId
* @return
*/
@Override
public Result delByPremiumRemittanceBizId(String premiumRemittanceBizId) {
iPremiumRemittanceFileService.delByPremiumRemittanceBizId(premiumRemittanceBizId);
return Result.success();
}
/**
* 根据保费对账-汇款记录表唯一业务ID查询保费汇款记录附件列表
* @param premiumRemittanceBizId
* @return
*/
@Override
public List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList(String premiumRemittanceBizId) {
List<PremiumRemittanceFile> fileList = iPremiumRemittanceFileService.queryList(premiumRemittanceBizId);
if (CollectionUtils.isEmpty(fileList)) {
return new ArrayList<>();
}
List<ApiPremiumRemittanceFileDto> fileDtoList = fileList.stream().map(dto -> {
ApiPremiumRemittanceFileDto fileDto = new ApiPremiumRemittanceFileDto();
BeanUtils.copyProperties(dto,fileDto);
return fileDto;
}).collect(Collectors.toList());
return fileDtoList;
}
/**
* 校验保费汇款记录附件信息是否存在
* @param premiumRemittanceFileBizId
* @return
*/
@Override
public Result<PremiumRemittanceFile> checkPremiumRemittanceFileIsExist(String premiumRemittanceFileBizId) {
PremiumRemittanceFile premiumRemittanceFile = iPremiumRemittanceFileService.queryOne(premiumRemittanceFileBizId);
if (Objects.isNull(premiumRemittanceFile)) {
//数据不存在
throw new BusinessException("保费汇款记录附件信息不存在");
}
return Result.success(premiumRemittanceFile);
}
}
yd-csf-api/src/main/java/com/yd/csf/api/service/impl/ApiPremiumRemittanceServiceImpl.java 0 → 100644
package com.yd.csf.api.service.impl;
import com.yd.common.enums.CommonEnum;
import com.yd.common.exception.BusinessException;
import com.yd.common.result.Result;
import com.yd.common.utils.RandomStringGenerator;
import com.yd.csf.api.service.ApiPremiumRemittanceFileService;
import com.yd.csf.api.service.ApiPremiumRemittanceService;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import com.yd.csf.service.dto.PremiumRemittanceDto;
import com.yd.csf.service.model.PremiumRemittance;
import com.yd.csf.service.service.IPremiumRemittanceService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
@Slf4j
@Service
public class ApiPremiumRemittanceServiceImpl implements ApiPremiumRemittanceService {
@Autowired
private IPremiumRemittanceService iPremiumRemittanceService;
@Autowired
private ApiPremiumRemittanceFileService apiPremiumRemittanceFileService;
/**
* 添加-单个保费对账汇款记录信息
* @param request
* @return
*/
@Override
public Result add(ApiPremiumRemittanceDto request) {
if (StringUtils.isBlank(request.getPremiumReconciliationBizId())) {
throw new BusinessException("保费对账记录表唯一业务ID不能为空");
}
List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList = new ArrayList<>();
apiPremiumRemittanceDtoList.add(request);
//添加-保费对账汇款记录列表
addPremiumRemittanceList(apiPremiumRemittanceDtoList,request.getPremiumReconciliationBizId());
return Result.success();
}
/**
* 编辑-单个保费对账汇款记录信息
* @param request
* @return
*/
@Override
public Result edit(ApiPremiumRemittanceDto request) {
if (StringUtils.isBlank(request.getPremiumRemittanceBizId())) {
throw new BusinessException("保费对账-汇款记录表唯一业务ID不能为空");
}
Result<PremiumRemittance> result = checkPremiumRemittanceIsExist(request.getPremiumRemittanceBizId());
PremiumRemittance premiumRemittance = result.getData();
BeanUtils.copyProperties(request,premiumRemittance);
//支付凭证
premiumRemittance.setPaymentVoucher(!CollectionUtils.isEmpty(request.getPaymentVoucherList()) ? String.join(";",request.getPaymentVoucherList()) : "");
//账户证明
premiumRemittance.setAccountVerification(!CollectionUtils.isEmpty(request.getAccountVerificationList()) ? String.join(";",request.getAccountVerificationList()) : "");
iPremiumRemittanceService.saveOrUpdate(premiumRemittance);
//保存-保费对账汇款记录附件列表
apiPremiumRemittanceFileService.savePremiumRemittanceFileList(request.getApiPremiumRemittanceFileDtoList(),request.getPremiumRemittanceBizId());
return Result.success();
}
/**
* 详情-保费对账汇款记录信息
* @param premiumRemittanceBizId 保费对账-汇款记录表唯一业务ID
* @return
*/
@Override
public Result<ApiPremiumRemittanceDto> detail(String premiumRemittanceBizId) {
ApiPremiumRemittanceDto dto = new ApiPremiumRemittanceDto();
Result<PremiumRemittance> result = checkPremiumRemittanceIsExist(premiumRemittanceBizId);
PremiumRemittance premiumRemittance = result.getData();
BeanUtils.copyProperties(premiumRemittance,dto);
//其他资料列表
List<ApiPremiumRemittanceFileDto> fileDtoList = apiPremiumRemittanceFileService.apiPremiumRemittanceFileDtoList(premiumRemittanceBizId);
dto.setApiPremiumRemittanceFileDtoList(fileDtoList);
return Result.success(dto);
}
/**
* 删除-单个保费对账汇款记录信息
* @param premiumRemittanceBizId
* @return
*/
@Override
public Result del(String premiumRemittanceBizId) {
checkPremiumRemittanceIsExist(premiumRemittanceBizId);
//删除保费对账汇款记录附件列表
apiPremiumRemittanceFileService.delByPremiumRemittanceBizId(premiumRemittanceBizId);
//删除单个保费对账汇款记录信息
iPremiumRemittanceService.delByPremiumRemittanceBizId(premiumRemittanceBizId);
return Result.success();
}
/**
* 添加-保费对账汇款记录列表
* @param apiPremiumRemittanceDtoList
* @param premiumReconciliationBizId
* @return
*/
@Override
public Result addPremiumRemittanceList(List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList,
String premiumReconciliationBizId) {
if (CollectionUtils.isEmpty(apiPremiumRemittanceDtoList)) {
return Result.success();
}
//添加保费对账汇款记录列表
for (ApiPremiumRemittanceDto dto : apiPremiumRemittanceDtoList) {
PremiumRemittance premiumRemittance = new PremiumRemittance();
BeanUtils.copyProperties(dto,premiumRemittance);
//保费对账记录表唯一业务ID
premiumRemittance.setPremiumReconciliationBizId(premiumReconciliationBizId);
//保费对账-汇款记录表唯一业务ID
premiumRemittance.setPremiumRemittanceBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_PREMIUM_REMITTANCE.getCode()));
//支付凭证
premiumRemittance.setPaymentVoucher(!CollectionUtils.isEmpty(dto.getPaymentVoucherList()) ? String.join(";",dto.getPaymentVoucherList()) : "");
//账户证明
premiumRemittance.setAccountVerification(!CollectionUtils.isEmpty(dto.getAccountVerificationList()) ? String.join(";",dto.getAccountVerificationList()) : "");
iPremiumRemittanceService.saveOrUpdate(premiumRemittance);
//添加-保费对账汇款记录附件列表
apiPremiumRemittanceFileService.addPremiumRemittanceFileList(dto.getApiPremiumRemittanceFileDtoList()
,premiumRemittance.getPremiumRemittanceBizId());
}
return Result.success();
}
/**
* 根据保费对账记录表唯一业务ID查询保费对账-汇款记录
* @param premiumReconciliationBizId
* @return
*/
@Override
public List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList(String premiumReconciliationBizId) {
List<PremiumRemittance> list = iPremiumRemittanceService.queryList(PremiumRemittanceDto.builder()
.premiumReconciliationBizId(premiumReconciliationBizId).build());
if (CollectionUtils.isEmpty(list)){
return new ArrayList<>();
}
List<ApiPremiumRemittanceDto> dtoList = list.stream().map(dto -> {
ApiPremiumRemittanceDto remittanceDto = new ApiPremiumRemittanceDto();
BeanUtils.copyProperties(dto,remittanceDto);
return remittanceDto;
}).collect(Collectors.toList());
return dtoList;
}
/**
* 校验保费对账汇款记录信息是否存在
* @param premiumRemittanceBizId
* @return
*/
@Override
public Result<PremiumRemittance> checkPremiumRemittanceIsExist(String premiumRemittanceBizId) {
PremiumRemittance premiumRemittance = iPremiumRemittanceService.queryOne(premiumRemittanceBizId);
if (Objects.isNull(premiumRemittance)) {
//数据不存在
throw new BusinessException("保费对账汇款记录信息不存在");
}
return Result.success(premiumRemittance);
}
}
yd-csf-feign/src/main/java/com/yd/csf/feign/client/policyreceipt/ApiPolicyReceiptFeignClient.java
......@@ -6,6 +6,7 @@ import com.yd.csf.feign.request.policyreceipt.ApiPolicyReceiptAddRequest;
import com.yd.csf.feign.request.policyreceipt.ApiPolicyReceiptPageRequest;
import com.yd.csf.feign.response.policyreceipt.ApiPolicyReceiptDetailResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
......@@ -37,7 +38,7 @@ public interface ApiPolicyReceiptFeignClient {
* @return
*/
@PostMapping("/add")
Result add(@RequestBody ApiPolicyReceiptAddRequest request);
Result add(@Validated @RequestBody ApiPolicyReceiptAddRequest request);
/**
* 编辑-回执状态
......
yd-csf-feign/src/main/java/com/yd/csf/feign/client/premiumreconciliation/ApiPremiumReconciliationFeignClient.java 0 → 100644
package com.yd.csf.feign.client.premiumreconciliation;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.fallback.premiumreconciliation.ApiPremiumReconciliationFeignFallbackFactory;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationAddRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationPageRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationResultEditRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiCalculateRemainingUnpaidAmountRequest;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationDetailResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiCalculateRemainingUnpaidAmountResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-保费对账记录信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiPremiumReconciliationFeignFallbackFactory.class)
public interface ApiPremiumReconciliationFeignClient {
/**
* 分页列表查询-保费对账记录信息
* @param request
* @return
*/
@PostMapping("/page")
Result page(@RequestBody ApiPremiumReconciliationPageRequest request);
/**
* 添加-保费对账记录信息（聚合信息添加）
* @param request
* @return
*/
@PostMapping("/add")
Result add(@Validated @RequestBody ApiPremiumReconciliationAddRequest request);
/**
* 编辑-单个保费对账记录信息
* @param request
* @return
*/
@PutMapping("/edit")
Result edit(@Validated @RequestBody ApiPremiumReconciliationDto request);
/**
* 详情-保费对账记录信息
* @param premiumReconciliationBizId 保费对账记录表唯一业务ID
* @return
*/
@GetMapping("/detail")
Result<ApiPremiumReconciliationDetailResponse> detail(@NotBlank(message = "保费对账记录表唯一业务ID能为空") @RequestParam(value = "premiumReconciliationBizId") String premiumReconciliationBizId);
/**
* 计算待付金额-保费对账记录信息
* @param request
* @return
*/
@PostMapping("/calculate/remainingUnpaidAmount")
Result<ApiCalculateRemainingUnpaidAmountResponse> calculateRemainingUnpaidAmount(@Validated @RequestBody ApiCalculateRemainingUnpaidAmountRequest request);
/**
* 设置认定结果-保费对账记录信息
* @param request
* @return
*/
@PutMapping("/edit/result")
Result editResult(@Validated @RequestBody ApiPremiumReconciliationResultEditRequest request);
}
yd-csf-feign/src/main/java/com/yd/csf/feign/client/premiumremittance/ApiPremiumRemittanceFeignClient.java 0 → 100644
package com.yd.csf.feign.client.premiumremittance;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import com.yd.csf.feign.fallback.premiumremittance.ApiPremiumRemittanceFeignFallbackFactory;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-保费对账汇款记录信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiPremiumRemittanceFeignFallbackFactory.class)
public interface ApiPremiumRemittanceFeignClient {
/**
* 添加-单个保费对账汇款记录信息
* @param request
* @return
*/
@PostMapping("/add")
Result add(@Validated @RequestBody ApiPremiumRemittanceDto request);
/**
* 编辑-单个保费对账汇款记录信息
* @param request
* @return
*/
@PutMapping("/edit")
Result edit(@Validated @RequestBody ApiPremiumRemittanceDto request);
/**
* 详情-保费对账汇款记录信息
* @param premiumRemittanceBizId 保费对账-汇款记录表唯一业务ID
* @return
*/
@GetMapping("/detail")
Result<ApiPremiumRemittanceDto> detail(@NotBlank(message = "保费对账-汇款记录表唯一业务ID能为空") @RequestParam(value = "premiumRemittanceBizId") String premiumRemittanceBizId);
/**
* 删除-单个保费对账汇款记录信息
* @param premiumRemittanceBizId
* @return
*/
@DeleteMapping("/del")
Result del(@NotBlank(message = "保费对账-汇款记录表唯一业务ID能为空") @RequestParam(value = "premiumRemittanceBizId") String premiumRemittanceBizId);
}
yd-csf-feign/src/main/java/com/yd/csf/feign/client/premiumremittancefile/ApiPremiumRemittanceFileFeignClient.java 0 → 100644
package com.yd.csf.feign.client.premiumremittancefile;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import com.yd.csf.feign.fallback.premiumremittancefile.ApiPremiumRemittanceFileFeignFallbackFactory;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-保费汇款记录附件信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiPremiumRemittanceFileFeignFallbackFactory.class)
public interface ApiPremiumRemittanceFileFeignClient {
/**
* 分页列表查询-保费汇款记录附件信息
* @param request
* @return
*/
@PostMapping("/page")
Result page(@RequestBody ApiPremiumRemittanceFilePageRequest request);
/**
* 添加-保费汇款记录附件信息
* @param request
* @return
*/
@PostMapping("/add")
Result add(@Validated @RequestBody ApiPremiumRemittanceFileDto request);
/**
* 编辑-保费汇款记录附件信息
* @param request
* @return
*/
@PutMapping("/edit")
Result edit(@Validated @RequestBody ApiPremiumRemittanceFileDto request);
/**
* 删除-保费汇款记录附件信息
* @param premiumRemittanceFileBizId
* @return
*/
@DeleteMapping("/del")
Result del(@NotBlank(message = "保费汇款记录附件表唯一业务ID能为空") @RequestParam(value = "premiumRemittanceFileBizId") String premiumRemittanceFileBizId);
}
yd-csf-feign/src/main/java/com/yd/csf/feign/dto/premiumreconciliation/ApiPremiumReconciliationDto.java 0 → 100644
package com.yd.csf.feign.dto.premiumreconciliation;
import lombok.Data;
import javax.validation.constraints.NotBlank;
@Data
public class ApiPremiumReconciliationDto {
/**
* 保费对账记录表唯一业务ID
*/
private String premiumReconciliationBizId;
/**
* 对账类型
*/
@NotBlank(message = "对账类型不能为空")
private String reconciliationType;
/**
* 申请人
*/
@NotBlank(message = "申请人不能为空")
private String applicant;
/**
* 保单号
*/
@NotBlank(message = "保单号不能为空")
private String policyNo;
/**
* 保单受保人（被保人）
*/
@NotBlank(message = "被保人不能为空")
private String insured;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/dto/premiumremittance/ApiPremiumRemittanceDto.java 0 → 100644
package com.yd.csf.feign.dto.premiumremittance;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import java.math.BigDecimal;
import java.util.List;
@Data
public class ApiPremiumRemittanceDto {
/**
* 保费对账-汇款记录表唯一业务ID（传值编辑，不传值新增）
*/
private String premiumRemittanceBizId;
/**
* 保费对账记录表唯一业务ID
*/
private String premiumReconciliationBizId;
/**
* 缴费方式
*/
@NotBlank(message = "缴费方式不能为空")
private String paymentMethod;
/**
* 付款金额
*/
@NotBlank(message = "付款金额不能为空")
private BigDecimal paymentAmount;
/**
* 付款币种
*/
@NotBlank(message = "付款币种不能为空")
private String paymentCurrency;
/**
* 付款人与保单关系（字典）
*/
@NotBlank(message = "付款人与保单关系不能为空")
private String paymentRel;
/**
* 付款人
*/
@NotBlank(message = "付款人不能为空")
private String payer;
/**
* 付款银行
*/
private String payingBank;
/**
* 付款账号
*/
private String paymentAccount;
/**
* 支付凭证列表
*/
@NotEmpty(message = "支付凭证列表不能为空")
private List<String> paymentVoucherList;
/**
* 账户证明列表
*/
@NotEmpty(message = "账户证明列表不能为空")
private List<String> accountVerificationList;
/**
* 其他资料列表
*/
private List<ApiPremiumRemittanceFileDto> apiPremiumRemittanceFileDtoList;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/dto/premiumremittancefile/ApiPremiumRemittanceFileDto.java 0 → 100644
package com.yd.csf.feign.dto.premiumremittancefile;
import lombok.Data;
@Data
public class ApiPremiumRemittanceFileDto {
/**
* 保费对账-汇款记录表唯一业务ID
*/
private String premiumRemittanceBizId;
/**
* 保费汇款记录附件表唯一业务ID
*/
private String premiumRemittanceFileBizId;
/**
* 文件名
*/
private String fileName;
/**
* 文件类型
*/
private String fileType;
/**
* 文件URL
*/
private String fileUrl;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/enums/ReconciliationStatusEnum.java 0 → 100644
package com.yd.csf.feign.enums;
/**
* 对账状态
*/
public enum ReconciliationStatusEnum {
YY_SHZ("运营审核中","YY_SHZ","客户提交后的状态"),
BS_DZZ("保司对账中","BS_DZZ","运营审核通过，提交给保司后"),
BS_DZ_CG("保司对账成功","BS_DZ_CG","保司反馈，已经收到打款"),
BS_DZ_SB("保司对账失败","BS_DZ_SB","保司反馈，没有收到打款"),
;
//字典项标签（名称）
private String itemLabel;
//字典项值
private String itemValue;
//描述
private String description;
//构造函数
ReconciliationStatusEnum(String itemLabel, String itemValue,String description) {
this.itemLabel = itemLabel;
this.itemValue = itemValue;
this.description = description;
}
public String getItemLabel() {
return itemLabel;
}
public String getItemValue() {
return itemValue;
}
public String getDescription() {
return description;
}
}
yd-csf-feign/src/main/java/com/yd/csf/feign/fallback/premiumreconciliation/ApiPremiumReconciliationFeignFallbackFactory.java 0 → 100644
package com.yd.csf.feign.fallback.premiumreconciliation;
import com.yd.common.result.Result;
import com.yd.csf.feign.client.premiumreconciliation.ApiPremiumReconciliationFeignClient;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationAddRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationPageRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiPremiumReconciliationResultEditRequest;
import com.yd.csf.feign.request.premiumreconciliation.ApiCalculateRemainingUnpaidAmountRequest;
import com.yd.csf.feign.response.premiumreconciliation.ApiPremiumReconciliationDetailResponse;
import com.yd.csf.feign.response.premiumreconciliation.ApiCalculateRemainingUnpaidAmountResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* 香港保险服务-保费对账记录信息Feign降级处理
*/
@Slf4j
@Component
public class ApiPremiumReconciliationFeignFallbackFactory implements FallbackFactory<ApiPremiumReconciliationFeignClient> {
@Override
public ApiPremiumReconciliationFeignClient create(Throwable cause) {
return new ApiPremiumReconciliationFeignClient() {
@Override
public Result page(ApiPremiumReconciliationPageRequest request) {
return null;
}
@Override
public Result add(ApiPremiumReconciliationAddRequest request) {
return null;
}
@Override
public Result edit(ApiPremiumReconciliationDto request) {
return null;
}
@Override
public Result<ApiPremiumReconciliationDetailResponse> detail(String premiumReconciliationBizId) {
return null;
}
@Override
public Result<ApiCalculateRemainingUnpaidAmountResponse> calculateRemainingUnpaidAmount(ApiCalculateRemainingUnpaidAmountRequest request) {
return null;
}
@Override
public Result editResult(ApiPremiumReconciliationResultEditRequest request) {
return null;
}
};
}
}
yd-csf-feign/src/main/java/com/yd/csf/feign/fallback/premiumremittance/ApiPremiumRemittanceFeignFallbackFactory.java 0 → 100644
package com.yd.csf.feign.fallback.premiumremittance;
import com.yd.common.result.Result;
import com.yd.csf.feign.client.premiumremittance.ApiPremiumRemittanceFeignClient;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-保费汇款记录信息Feign降级处理
*/
@Slf4j
@Component
public class ApiPremiumRemittanceFeignFallbackFactory implements FallbackFactory<ApiPremiumRemittanceFeignClient> {
@Override
public ApiPremiumRemittanceFeignClient create(Throwable cause) {
return new ApiPremiumRemittanceFeignClient() {
@Override
public Result add(ApiPremiumRemittanceDto request) {
return null;
}
@Override
public Result edit(ApiPremiumRemittanceDto request) {
return null;
}
@Override
public Result<ApiPremiumRemittanceDto> detail(String premiumRemittanceBizId) {
return null;
}
@Override
public Result del(String premiumRemittanceBizId) {
return null;
}
};
}
}
yd-csf-feign/src/main/java/com/yd/csf/feign/fallback/premiumremittancefile/ApiPremiumRemittanceFileFeignFallbackFactory.java 0 → 100644
package com.yd.csf.feign.fallback.premiumremittancefile;
import com.yd.common.result.Result;
import com.yd.csf.feign.client.premiumremittancefile.ApiPremiumRemittanceFileFeignClient;
import com.yd.csf.feign.dto.premiumremittancefile.ApiPremiumRemittanceFileDto;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* 香港保险服务-保费汇款记录附件信息Feign降级处理
*/
@Slf4j
@Component
public class ApiPremiumRemittanceFileFeignFallbackFactory implements FallbackFactory<ApiPremiumRemittanceFileFeignClient> {
@Override
public ApiPremiumRemittanceFileFeignClient create(Throwable cause) {
return new ApiPremiumRemittanceFileFeignClient() {
@Override
public Result page(ApiPremiumRemittanceFilePageRequest request) {
return null;
}
@Override
public Result add(ApiPremiumRemittanceFileDto request) {
return null;
}
@Override
public Result edit(ApiPremiumRemittanceFileDto request) {
return null;
}
@Override
public Result del(String premiumRemittanceFileBizId) {
return null;
}
};
}
}
yd-csf-feign/src/main/java/com/yd/csf/feign/request/premiumreconciliation/ApiCalculateRemainingUnpaidAmountRequest.java 0 → 100644
package com.yd.csf.feign.request.premiumreconciliation;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
@Data
public class ApiCalculateRemainingUnpaidAmountRequest {
/**
* 保费对账记录表唯一业务ID
*/
@NotBlank(message = "保费对账记录表唯一业务ID不能为空")
private String premiumReconciliationBizId;
/**
* 当次保司认定金额（客户当次缴纳的金额）
*/
@NotNull(message = "当次保司认定金额不能为空")
private BigDecimal recognizedAmount;
/**
* 当次保司认定币种
*/
@NotNull(message = "当次保司认定币种不能为空")
private String recognizedCurrency;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/request/premiumreconciliation/ApiPremiumReconciliationAddRequest.java 0 → 100644
package com.yd.csf.feign.request.premiumreconciliation;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import lombok.Data;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.util.List;
@Data
public class ApiPremiumReconciliationAddRequest {
/**
* 保费对账信息
*/
@Valid
@NotNull(message = "保费对账信息不能为空")
private ApiPremiumReconciliationDto apiPremiumReconciliationDto;
/**
* 保费对账-汇款记录列表
*/
@Valid
private List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/request/premiumreconciliation/ApiPremiumReconciliationPageRequest.java 0 → 100644
package com.yd.csf.feign.request.premiumreconciliation;
import com.yd.common.dto.PageDto;
import lombok.Data;
@Data
public class ApiPremiumReconciliationPageRequest extends PageDto {
}
yd-csf-feign/src/main/java/com/yd/csf/feign/request/premiumreconciliation/ApiPremiumReconciliationResultEditRequest.java 0 → 100644
package com.yd.csf.feign.request.premiumreconciliation;
import lombok.Data;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.Date;
@Data
public class ApiPremiumReconciliationResultEditRequest {
/**
* 当次保司认定金额（客户当次缴纳的金额）
*/
@NotNull(message = "当次保司认定金额不能为空")
private BigDecimal recognizedAmount;
/**
* 当次保司认定币种
*/
@NotNull(message = "当次保司认定币种不能为空")
private String recognizedCurrency;
/**
* 当期剩余待付金额
*/
@NotNull(message = "当期剩余待付金额不能为空")
private BigDecimal remainingUnpaidAmount;
/**
* 当期剩余待付币种
*/
@NotNull(message = "当期剩余待付币种不能为空")
private String remainingUnpaidCurrency;
//以下信息只有当前保单首期剩余待付金额为小于等于0时，才传入下面字段进行保单生效日和状态更新
/**
* 生效日期（保单生效日）
*/
private Date effectiveDate;
/**
* 保单核保日
*/
private Date underwritingDate;
/**
* 保单状态
*/
private String status;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/request/premiumremittance/ApiPremiumRemittanceAddRequest.java 0 → 100644
package com.yd.csf.feign.request.premiumremittance;
import lombok.Data;
@Data
public class ApiPremiumRemittanceAddRequest {
}
yd-csf-feign/src/main/java/com/yd/csf/feign/request/premiumremittancefile/ApiPremiumRemittanceFilePageRequest.java 0 → 100644
package com.yd.csf.feign.request.premiumremittancefile;
import com.yd.common.dto.PageDto;
import lombok.Data;
@Data
public class ApiPremiumRemittanceFilePageRequest extends PageDto {
/**
* 文件名
*/
private String fileName;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/response/premiumreconciliation/ApiCalculateRemainingUnpaidAmountResponse.java 0 → 100644
package com.yd.csf.feign.response.premiumreconciliation;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class ApiCalculateRemainingUnpaidAmountResponse {
/**
* 当期剩余待付金额
*/
private BigDecimal remainingUnpaidAmount;
/**
* 当期剩余待付币种
*/
private String remainingUnpaidCurrency;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/response/premiumreconciliation/ApiPremiumReconciliationDetailResponse.java 0 → 100644
package com.yd.csf.feign.response.premiumreconciliation;
import com.yd.csf.feign.dto.premiumreconciliation.ApiPremiumReconciliationDto;
import com.yd.csf.feign.dto.premiumremittance.ApiPremiumRemittanceDto;
import lombok.Data;
import java.util.List;
@Data
public class ApiPremiumReconciliationDetailResponse {
/**
* 保费对账信息
*/
private ApiPremiumReconciliationDto apiPremiumReconciliationDto;
/**
* 保费对账-汇款记录列表
*/
private List<ApiPremiumRemittanceDto> apiPremiumRemittanceDtoList;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/response/premiumreconciliation/ApiPremiumReconciliationPageResponse.java 0 → 100644
package com.yd.csf.feign.response.premiumreconciliation;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Data
public class ApiPremiumReconciliationPageResponse {
/**
* 保险公司名称（保单表）
*/
private String insurer;
/**
* 保单号（保单表）
*/
private String policyNo;
/**
* 新单状态（新单跟进表）
*/
private String policyFollowStatus;
/**
* 对账状态（保费对账记录表）
*/
private String reconciliationStatus;
/**
* 保单状态（保单表）
*/
private String policyStatus;
/**
* 当期剩余待付金额（保费对账记录表）
*/
private BigDecimal remainingUnpaidAmount;
/**
* 当期剩余待付币种（保费对账记录表）
*/
private String remainingUnpaidCurrency;
/**
* 付款金额（保费对账-汇款记录表统计合）
*/
private BigDecimal paymentAmount;
/**
* 付款币种（保费对账-汇款记录表）
*/
private String paymentCurrency;
/**
* 缴费方式（保费对账-汇款记录表，多个分号分隔）
*/
private String paymentMethod;
/**
* 当次保司认定金额（客户当次缴纳的金额，保费对账记录表）
*/
private BigDecimal recognizedAmount;
/**
* 当次保司认定币种（保费对账记录表）
*/
private String recognizedCurrency;
/**
* 付款人（保费对账-汇款记录表）
*/
private String payer;
/**
* 付款银行（保费对账-汇款记录表）
*/
private String payingBank;
/**
* 保單持有人（投保人，保单表）
*/
private String policyHolder;
/**
* 受保人（保单表）
*/
private String insured;
/**
* 转介人名称（保单转介人表，多个分号分隔）
*/
private String brokerName;
/**
* 创建时间（保费对账记录表）
*/
private LocalDateTime createTime;
/**
* 更新时间（保费对账记录表）
*/
private LocalDateTime updateTime;
/**
* 对账公司（保单表）
*/
private String reconciliationCompany;
}
yd-csf-feign/src/main/java/com/yd/csf/feign/response/premiumremittancefile/ApiPremiumRemittanceFilePageResponse.java 0 → 100644
package com.yd.csf.feign.response.premiumremittancefile;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class ApiPremiumRemittanceFilePageResponse {
/**
* 主键ID
*/
private Long id;
/**
* 保费汇款记录附件表唯一业务ID
*/
private String premiumRemittanceFileBizId;
/**
* 保费对账-汇款记录表唯一业务ID
*/
private String premiumRemittanceBizId;
/**
* 文件名
*/
private String fileName;
/**
* 文件类型
*/
private String fileType;
/**
* 文件URL
*/
private String fileUrl;
/**
* 创建人名
*/
private String creatorName;
/**
* 创建时间
*/
private LocalDateTime createTime;
}
yd-csf-service/src/main/java/com/yd/csf/service/dao/PremiumReconciliationMapper.java 0 → 100644
package com.yd.csf.service.dao;
import com.yd.csf.service.model.PremiumReconciliation;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 保费对账记录表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-12-26
*/
public interface PremiumReconciliationMapper extends BaseMapper<PremiumReconciliation> {
}
yd-csf-service/src/main/java/com/yd/csf/service/dao/PremiumRemittanceFileMapper.java 0 → 100644
package com.yd.csf.service.dao;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse;
import com.yd.csf.service.model.PremiumRemittanceFile;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 保费汇款记录附件表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-12-26
*/
public interface PremiumRemittanceFileMapper extends BaseMapper<PremiumRemittanceFile> {
IPage<ApiPremiumRemittanceFilePageResponse> page(@Param("page") Page<ApiPremiumRemittanceFilePageResponse> page,
@Param("request") ApiPremiumRemittanceFilePageRequest request);
}
yd-csf-service/src/main/java/com/yd/csf/service/dao/PremiumRemittanceMapper.java 0 → 100644
package com.yd.csf.service.dao;
import com.yd.csf.service.model.PremiumRemittance;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 保费汇款记录表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-12-26
*/
public interface PremiumRemittanceMapper extends BaseMapper<PremiumRemittance> {
}
yd-csf-service/src/main/java/com/yd/csf/service/dto/PremiumReconciliationDto.java 0 → 100644
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PremiumReconciliationDto {
/**
* 保费对账记录表唯一业务ID
*/
private String premiumReconciliationBizId;
/**
* 当前期数
*/
private String currentIssueNumber;
/**
* 查询是否排除当前记录
*/
@Builder.Default
private Boolean isExcludeMy = false;
}
yd-csf-service/src/main/java/com/yd/csf/service/dto/PremiumRemittanceDto.java 0 → 100644
package com.yd.csf.service.dto;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PremiumRemittanceDto {
/**
* 保费对账记录表唯一业务ID
*/
private String premiumReconciliationBizId;
}
yd-csf-service/src/main/java/com/yd/csf/service/model/PremiumReconciliation.java 0 → 100644
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保费对账记录表
* </p>
*
* @author zxm
* @since 2025-12-26
*/
@Getter
@Setter
@TableName("premium_reconciliation")
public class PremiumReconciliation implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 保费对账记录表唯一业务ID
*/
@TableField("premium_reconciliation_biz_id")
private String premiumReconciliationBizId;
/**
* 对账类型
*/
@TableField("reconciliation_type")
private String reconciliationType;
/**
* 当前期数
*/
@TableField("current_issue_number")
private String currentIssueNumber;
/**
* 申请人
*/
@TableField("applicant")
private String applicant;
/**
* 保单号
*/
@TableField("policy_no")
private String policyNo;
/**
* 保单受保人（被保人）
*/
@TableField("insured")
private String insured;
/**
* 保险公司名称
*/
@TableField("insurer")
private String insurer;
/**
* 当次保司认定金额（客户当次缴纳的金额）
*/
@TableField("recognized_amount")
private BigDecimal recognizedAmount;
/**
* 当次保司认定币种
*/
@TableField("recognized_currency")
private String recognizedCurrency;
/**
* 当期剩余待付金额
*/
@TableField("remaining_unpaid_amount")
private BigDecimal remainingUnpaidAmount;
/**
* 当期剩余待付币种
*/
@TableField("remaining_unpaid_currency")
private String remainingUnpaidCurrency;
/**
* 对账状态
*/
@TableField("reconciliation_status")
private String reconciliationStatus;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
yd-csf-service/src/main/java/com/yd/csf/service/model/PremiumRemittance.java 0 → 100644
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保费对账-汇款记录表
* </p>
*
* @author zxm
* @since 2025-12-26
*/
@Getter
@Setter
@TableName("premium_remittance")
public class PremiumRemittance implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 保费对账-汇款记录表唯一业务ID
*/
@TableField("premium_remittance_biz_id")
private String premiumRemittanceBizId;
/**
* 保费对账记录表唯一业务ID
*/
@TableField("premium_reconciliation_biz_id")
private String premiumReconciliationBizId;
/**
* 缴费方式
*/
@TableField("payment_method")
private String paymentMethod;
/**
* 付款金额
*/
@TableField("payment_amount")
private BigDecimal paymentAmount;
/**
* 付款币种
*/
@TableField("payment_currency")
private String paymentCurrency;
/**
* 付款人与保单关系（字典）
*/
@TableField("payment_rel")
private String paymentRel;
/**
* 付款人
*/
@TableField("payer")
private String payer;
/**
* 付款银行
*/
@TableField("paying_bank")
private String payingBank;
/**
* 付款账号
*/
@TableField("payment_account")
private String paymentAccount;
/**
* 支付凭证（多个文件URL用分号分隔）
*/
@TableField("payment_voucher")
private String paymentVoucher;
/**
* 账户证明（多个文件URL用分号分隔）
*/
@TableField("account_verification")
private String accountVerification;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
yd-csf-service/src/main/java/com/yd/csf/service/model/PremiumRemittanceFile.java 0 → 100644
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保费对账-汇款记录附件表
* </p>
*
* @author zxm
* @since 2025-12-26
*/
@Getter
@Setter
@TableName("premium_remittance_file")
public class PremiumRemittanceFile implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 保费汇款记录附件表唯一业务ID
*/
@TableField("premium_remittance_file_biz_id")
private String premiumRemittanceFileBizId;
/**
* 保费对账-汇款记录表唯一业务ID
*/
@TableField("premium_remittance_biz_id")
private String premiumRemittanceBizId;
/**
* 文件名
*/
@TableField("file_name")
private String fileName;
/**
* 文件类型
*/
@TableField("file_type")
private String fileType;
/**
* 文件URL
*/
@TableField("file_url")
private String fileUrl;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 创建人名
*/
@TableField("creator_name")
private String creatorName;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
yd-csf-service/src/main/java/com/yd/csf/service/service/IPremiumReconciliationService.java 0 → 100644
package com.yd.csf.service.service;
import com.yd.csf.service.dto.PremiumReconciliationDto;
import com.yd.csf.service.model.PremiumReconciliation;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 保费对账记录表 服务类
* </p>
*
* @author zxm
* @since 2025-12-26
*/
public interface IPremiumReconciliationService extends IService<PremiumReconciliation> {
PremiumReconciliation queryOne(String premiumReconciliationBizId);
List<PremiumReconciliation> queryList(PremiumReconciliationDto dto);
}
yd-csf-service/src/main/java/com/yd/csf/service/service/IPremiumRemittanceFileService.java 0 → 100644
package com.yd.csf.service.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse;
import com.yd.csf.service.model.PremiumRemittanceFile;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 保费汇款记录附件表 服务类
* </p>
*
* @author zxm
* @since 2025-12-26
*/
public interface IPremiumRemittanceFileService extends IService<PremiumRemittanceFile> {
IPage<ApiPremiumRemittanceFilePageResponse> page(Page<ApiPremiumRemittanceFilePageResponse> page,
ApiPremiumRemittanceFilePageRequest request);
List<PremiumRemittanceFile> queryList(String premiumRemittanceBizId);
Boolean delByPremiumRemittanceBizId(String premiumRemittanceBizId);
PremiumRemittanceFile queryOne(String premiumRemittanceFileBizId);
}
yd-csf-service/src/main/java/com/yd/csf/service/service/IPremiumRemittanceService.java 0 → 100644
package com.yd.csf.service.service;
import com.yd.csf.service.dto.PremiumRemittanceDto;
import com.yd.csf.service.model.PremiumRemittance;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 保费汇款记录表 服务类
* </p>
*
* @author zxm
* @since 2025-12-26
*/
public interface IPremiumRemittanceService extends IService<PremiumRemittance> {
List<PremiumRemittance> queryList(PremiumRemittanceDto dto);
PremiumRemittance queryOne(String premiumRemittanceBizId);
Boolean delByPremiumRemittanceBizId(String premiumRemittanceBizId);
}
yd-csf-service/src/main/java/com/yd/csf/service/service/impl/PremiumReconciliationServiceImpl.java 0 → 100644
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.PremiumReconciliationDto;
import com.yd.csf.service.model.PremiumReconciliation;
import com.yd.csf.service.dao.PremiumReconciliationMapper;
import com.yd.csf.service.model.Variable;
import com.yd.csf.service.service.IPremiumReconciliationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 保费对账记录表 服务实现类
* </p>
*
* @author zxm
* @since 2025-12-26
*/
@Service
public class PremiumReconciliationServiceImpl extends ServiceImpl<PremiumReconciliationMapper, PremiumReconciliation> implements IPremiumReconciliationService {
@Override
public PremiumReconciliation queryOne(String premiumReconciliationBizId) {
return this.getOne(new LambdaQueryWrapper<PremiumReconciliation>()
.eq(PremiumReconciliation::getPremiumReconciliationBizId,premiumReconciliationBizId).last(" limit 1 "));
}
@Override
public List<PremiumReconciliation> queryList(PremiumReconciliationDto dto) {
List<PremiumReconciliation> list = baseMapper.selectList(new LambdaQueryWrapper<PremiumReconciliation>()
.eq(StringUtils.isNotBlank(dto.getPremiumReconciliationBizId()) && !dto.getIsExcludeMy(),PremiumReconciliation::getPremiumReconciliationBizId,dto.getPremiumReconciliationBizId())
.eq(StringUtils.isNotBlank(dto.getCurrentIssueNumber()),PremiumReconciliation::getCurrentIssueNumber,dto.getCurrentIssueNumber())
.ne(dto.getIsExcludeMy(),PremiumReconciliation::getPremiumReconciliationBizId,dto.getPremiumReconciliationBizId())
);
return list;
}
}
yd-csf-service/src/main/java/com/yd/csf/service/service/impl/PremiumRemittanceFileServiceImpl.java 0 → 100644
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.premiumremittancefile.ApiPremiumRemittanceFilePageRequest;
import com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse;
import com.yd.csf.service.model.PremiumRemittance;
import com.yd.csf.service.model.PremiumRemittanceFile;
import com.yd.csf.service.dao.PremiumRemittanceFileMapper;
import com.yd.csf.service.service.IPremiumRemittanceFileService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 保费汇款记录附件表 服务实现类
* </p>
*
* @author zxm
* @since 2025-12-26
*/
@Service
public class PremiumRemittanceFileServiceImpl extends ServiceImpl<PremiumRemittanceFileMapper, PremiumRemittanceFile> implements IPremiumRemittanceFileService {
@Override
public IPage<ApiPremiumRemittanceFilePageResponse> page(Page<ApiPremiumRemittanceFilePageResponse> page,
ApiPremiumRemittanceFilePageRequest request) {
return baseMapper.page(page,request);
}
@Override
public List<PremiumRemittanceFile> queryList(String premiumRemittanceBizId) {
List<PremiumRemittanceFile> list = baseMapper.selectList(new LambdaQueryWrapper<PremiumRemittanceFile>()
.eq(StringUtils.isNotBlank(premiumRemittanceBizId),PremiumRemittanceFile::getPremiumRemittanceBizId,premiumRemittanceBizId)
);
return list;
}
/**
* 根据保费对账-汇款记录表唯一业务ID删除
* @param premiumRemittanceBizId
* @return
*/
@Override
public Boolean delByPremiumRemittanceBizId(String premiumRemittanceBizId) {
return this.remove(new LambdaQueryWrapper<PremiumRemittanceFile>().eq(PremiumRemittanceFile::getPremiumRemittanceBizId,premiumRemittanceBizId));
}
/**
* 查询单个对象
* @param premiumRemittanceFileBizId
* @return
*/
@Override
public PremiumRemittanceFile queryOne(String premiumRemittanceFileBizId) {
return this.getOne(new LambdaQueryWrapper<PremiumRemittanceFile>()
.eq(PremiumRemittanceFile::getPremiumRemittanceBizId,premiumRemittanceFileBizId).last(" limit 1 "));
}
}
yd-csf-service/src/main/java/com/yd/csf/service/service/impl/PremiumRemittanceServiceImpl.java 0 → 100644
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.PremiumRemittanceDto;
import com.yd.csf.service.model.PremiumRemittance;
import com.yd.csf.service.dao.PremiumRemittanceMapper;
import com.yd.csf.service.service.IPremiumRemittanceService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
* <p>
* 保费汇款记录表 服务实现类
* </p>
*
* @author zxm
* @since 2025-12-26
*/
@Service
public class PremiumRemittanceServiceImpl extends ServiceImpl<PremiumRemittanceMapper, PremiumRemittance> implements IPremiumRemittanceService {
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<PremiumRemittance> queryList(PremiumRemittanceDto dto) {
List<PremiumRemittance> list = baseMapper.selectList(new LambdaQueryWrapper<PremiumRemittance>()
.eq(StringUtils.isNotBlank(dto.getPremiumReconciliationBizId()),PremiumRemittance::getPremiumReconciliationBizId,dto.getPremiumReconciliationBizId())
);
return list;
}
/**
* 查询单个对象
* @param premiumRemittanceBizId
* @return
*/
@Override
public PremiumRemittance queryOne(String premiumRemittanceBizId) {
return this.getOne(new LambdaQueryWrapper<PremiumRemittance>()
.eq(PremiumRemittance::getPremiumRemittanceBizId,premiumRemittanceBizId).last(" limit 1 "));
}
/**
* 根据保费对账-汇款记录表唯一业务ID删除
* @param premiumRemittanceBizId
* @return
*/
@Override
public Boolean delByPremiumRemittanceBizId(String premiumRemittanceBizId) {
return this.remove(new LambdaQueryWrapper<PremiumRemittance>().eq(PremiumRemittance::getPremiumRemittanceBizId,premiumRemittanceBizId));
}
}
yd-csf-service/src/main/java/com/yd/csf/service/utils/MyBatisPlusCodeGenerator.java
......@@ -21,7 +21,7 @@ public class MyBatisPlusCodeGenerator {
})
.strategyConfig(builder -> {
builder.addInclude(
"policy_receipt"
"premium_reconciliation","premium_remittance","premium_remittance_file"
)
.entityBuilder()
......
yd-csf-service/src/main/resources/mappers/PremiumReconciliationMapper.xml 0 → 100644
<?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.yd.csf.service.dao.PremiumReconciliationMapper">
</mapper>
yd-csf-service/src/main/resources/mappers/PremiumRemittanceFileMapper.xml 0 → 100644
<?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.yd.csf.service.dao.PremiumRemittanceFileMapper">
<select id="page"
resultType="com.yd.csf.feign.response.premiumremittancefile.ApiPremiumRemittanceFilePageResponse">
select prf.* from premium_remittance_file prf
<where>
<if test="request.fileName != null and request.fileName != ''">
and prf.file_name like concat('%', #{request.fileName}, '%')
</if>
and prf.is_deleted = 0
</where>
</select>
</mapper>
yd-csf-service/src/main/resources/mappers/PremiumRemittanceMapper.xml 0 → 100644
<?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.yd.csf.service.dao.PremiumRemittanceMapper">
</mapper>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment