package com.doumee.core.utils;
|
|
import cn.hutool.core.io.IoUtil;
|
import cn.hutool.core.util.IdcardUtil;
|
import com.doumee.core.constants.ResponseStatus;
|
import com.doumee.core.exception.BusinessException;
|
import com.doumee.dao.business.dto.ApplyPowerDTO;
|
import com.doumee.dao.business.dto.CountCyclePriceDTO;
|
import com.doumee.dao.business.model.*;
|
import com.doumee.dao.business.vo.ApplyPowerVO;
|
import com.doumee.dao.business.vo.ChangeDealTypeVO;
|
import com.doumee.dao.business.vo.CountCyclePriceVO;
|
import io.swagger.models.auth.In;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.apache.commons.compress.archivers.zip.Zip64Mode;
|
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
|
import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
|
import org.apache.commons.lang3.StringUtils;
|
|
import javax.servlet.ServletOutputStream;
|
import java.io.*;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.net.URL;
|
import java.net.URLDecoder;
|
import java.time.Instant;
|
import java.time.LocalDate;
|
import java.time.Period;
|
import java.time.ZoneId;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
import java.util.Date;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
public class Constants {
|
|
public static final int ZERO = 0 ;
|
public static final int ONE = 1 ;
|
public static final int TWO = 2 ;
|
public static final int
|
THREE = 3 ;
|
public static final int FIVE = 5 ;
|
public static final int SIX = 6 ;
|
public static final int SEVEN = 7 ;
|
public static final String ACCESS_ID="ACCESS_ID";
|
public static final String BUCKETNAME = "BUCKETNAME";
|
public static final String OSS = "OSS";
|
public static final String ACCESS_KEY = "ACCESS_KEY";
|
public static final String ENDPOINT = "ENDPOINT";
|
public static final String RESOURCE_PATH = "RESOURCE_PATH";
|
public static final String WEB_PARAM = "WEB_PARAM";
|
public static final String MAIN_COLOR = "MAIN_COLOR";
|
public static final String BG_IMG = "BG_IMG";
|
public static final String TOP_IMG = "TOP_IMG";
|
public static final String PK_IMG = "PK_IMG";
|
public static final String RANGE_SIZE = "RANGE_SIZE";
|
public static final String CATE_PARAM_OPEN = "_CATE_PARAM_OPEN";
|
public static final String OPEN_SYNC_SWITCH = "OPEN_SYNC_SWITCH";
|
public static final String WX_MIN_PROGRAM = "WX_MIN_PROGRAM";
|
public static final String WX_MIN_APPID = "WX_MIN_APPID";
|
public static final String WX_MIN_SECRET = "WX_MIN_SECRET";
|
|
public static final String PLAT_COMPANY_NAME ="PLAT_COMPANY_NAME";
|
public static final String PLAT_CREDIT_CODE ="PLAT_CREDIT_CODE";
|
public static final String PLAT_EMAIL ="PLAT_EMAIL";
|
public static final String SYSTEM ="SYSTEM";
|
public static final String PROTOCOL ="PROTOCOL";
|
public static final String PRIVACY ="PRIVACY";
|
public static final String USE ="USE";
|
|
public static final String GOODS_IMG_DIR ="GOODS_IMG_DIR";
|
public static final String CREDIT_CODE_REGEX = "[0-9A-HJ-NPQRTUWXY]{2}\\d{6}[0-9A-HJ-NPQRTUWXY]{10}";
|
|
public static final String ROOT_PATH="ROOT_PATH";//本地文件上传地址配置
|
public static final String FILE_DIR="FILE_DIR";//本地文件访问地址配置
|
public static final String HOME_IMAGE="HOME_IMAGE";//H5 首页图
|
|
public static final String PROJECTS = "PROJECTS";
|
public static final String CATEGORY_IMG = "CATEGORY_IMG";
|
public static final String GOODS_IMG ="GOODS_IMG" ;
|
public static final String GOODS_PRICE_RATE = "GOODS_PRICE_RATE";
|
public static final String COMPANY_MANAGE_ROLE = "COMPANY_MANAGE_ROLE";
|
|
|
public static final String DEFAULT_MANAGE_ROLE = "DEFAULT_MANAGE_ROLE";
|
public static final String DEFAULT_PASSWORD = "DEFAULT_PASSWORD";
|
public static final String BRAND_IMG = "BRAND_IMG";
|
public static final String PLATFORM = "PLATFORM";
|
public static final String ZHUBO_ROOM_URL = "ZHUBO_ROOM_URL";
|
public static final String SMS_IP ="SMS_IP" ;
|
public static final String SMS_PORT ="SMS_PORT" ;
|
public static final String SMS_APPKEY="SMS_APPKEY";
|
public static final String SMS_APPSECRET ="SMS_APPSERECT" ;
|
public static final String SMS ="SMS" ;
|
public static final String SIGN = "SIGN";
|
public static final String SIGN_URL = "SIGN_URL";
|
public static final String SIGN_APPKEY = "SIGN_APPKEY";
|
public static final String SIGN_APPSECRET = "SIGN_APPSECRET";
|
public static final String COMPANY_FILE ="COMPANY_FILE" ;
|
public static final String SMS_COMNAME = "SMS_COMNAME";
|
public static final String TAXES_FILE = "TAXES_FILE";
|
public static final String APPLY_FILE ="APPLY_FILE" ;
|
public static final String COMPANY_USER_APPLY ="COMPANY_USER_APPLY" ;
|
public static final String INSURANCE ="INSURANCE" ;
|
public static final String CONTRACT ="CONTRACT" ;
|
public static final String DISCUSS_PROBLEM_TYPE ="DISCUSS_PROBLEM_TYPE" ;
|
|
public static final String SETTLE_FILE ="SETTLE_FILE" ;
|
public static final String DU_FILE ="DU_FILE" ;
|
public static final String SIGN_DONE_NOTIFY_URL = "SIGN_DONE_NOTIFY_URL";
|
public static final int FOUR = 4;
|
public static final String COMPANY_PHONE_AUTH ="COMPANY_PHONE_AUTH" ;
|
|
/*RISK_TIMES_OPEN 风险提醒设置-多次出现提醒是否开启：0=否；1=是；
|
RISK_TIMES_REPORT_TIMES 风险提醒设置-多次出现报案次数提醒
|
RISK_REPEAT_REPORT_OPEN 风险提醒设置-重复报案是否开启：0=否；1=是;
|
RISK_REPEAT_REPORT_TIME_UNIT 风险提醒设置-重复报案时间单位：0分钟 1小时 2天
|
RISK_REPEAT_REPORT_TIME 风险提醒设置-重复报案时间
|
RISK_CLAIM_TIMES_OPEN 风险提醒设置-索赔次数过多是否开启：0=否；1=是；
|
RISK_CLAIM_TIMES 风险提醒设置-索赔次数
|
RISK_NEW_MEMBER_OPEN 风险提醒设置-新员工出险提醒是否开启：0=否；1=是;
|
RISK_NEW_MEMBER_TIME_UNIT 风险提醒设置-新员工出险提醒时间单位：0分钟 1小时 2天
|
RISK_NEW_MEMBER_TIME 风险提醒设置-新员工出险提醒时间
|
RISK_SENSITIVE_WORDS_OPEN 风险提醒设置-敏感词提醒是否开启：0=否；1=是；
|
RISK_SENSITIVE_WORDS 风险提醒设置-多次出现报案次数提醒*/
|
|
public static final String RISK_TIMES_OPEN ="RISK_TIMES_OPEN" ;
|
public static final String RISK_TIMES_REPORT_TIMES ="RISK_TIMES_REPORT_TIMES" ;
|
public static final String RISK_REPEAT_REPORT_OPEN ="RISK_REPEAT_REPORT_OPEN" ;
|
public static final String RISK_REPEAT_REPORT_TIME_UNIT ="RISK_REPEAT_REPORT_TIME_UNIT" ;
|
public static final String RISK_REPEAT_REPORT_TIME ="RISK_REPEAT_REPORT_TIME" ;
|
public static final String RISK_CLAIM_TIMES_OPEN ="RISK_CLAIM_TIMES_OPEN" ;
|
public static final String RISK_CLAIM_TIMES ="RISK_CLAIM_TIMES" ;
|
public static final String RISK_NEW_MEMBER_OPEN ="RISK_NEW_MEMBER_OPEN" ;
|
public static final String RISK_NEW_MEMBER_TIME_UNIT ="RISK_NEW_MEMBER_TIME_UNIT" ;
|
public static final String RISK_NEW_MEMBER_TIME ="RISK_NEW_MEMBER_TIME" ;
|
public static final String RISK_SENSITIVE_WORDS_OPEN ="RISK_SENSITIVE_WORDS_OPEN" ;
|
public static final String RISK_SENSITIVE_WORDS ="RISK_SENSITIVE_WORDS" ;
|
|
|
|
|
|
|
|
|
/**
|
* 获取申请单时间列标题
|
* @param type 0开始时间 1截止时间
|
* @param model
|
* @return
|
*/
|
public static String getApplyTimeTitle(int type, InsuranceApply model){
|
if(type ==1){
|
if(Constants.equalsInteger(model.getSolutionType(),Constants.ONE)){
|
return Constants.equalsInteger(model.getUnionApplyTbdStatus(),Constants.THREE)?"保险生效起期":"期望保险生效起期";
|
}else{
|
return Constants.equalsInteger(model.getStatus(), InsuranceApplyStatus.UPLOAD_INSURANCE.getKey())?"保险生效起期":"期望保险生效起期";
|
}
|
}else{
|
if(Constants.equalsInteger(model.getSolutionType(),Constants.ONE)){
|
return Constants.equalsInteger(model.getUnionApplyTbdStatus(),Constants.THREE)?"保险生效止期":"预计生效止期";
|
}else{
|
return Constants.equalsInteger(model.getStatus(), InsuranceApplyStatus.UPLOAD_INSURANCE.getKey())?"保险生效止期":"预计生效止期";
|
}
|
}
|
|
}
|
public interface DATAPERMISSION_TYPE{
|
public static final int all = 0;
|
public static final int departAndChild = 1;
|
public static final int departAndLeaf = 2;
|
public static final int depart = 3;
|
public static final int custom = 4;
|
public static final int self = -1;
|
}
|
|
/**
|
* 获取批改单时间标题列
|
* @param type 0更换派遣单位 1加保 0减保
|
* @param model
|
* @return
|
*/
|
public static String getChangeApplyTimeTitle(int type, ApplyChange model){
|
if(type ==2){
|
return Constants.equalsInteger(model.getStatus(), ApplyChangeStatus.APPROVE.getKey())?"批单生效期":"期望批单生效期";
|
}else if(type ==1){
|
return Constants.equalsInteger(model.getStatus(), ApplyChangeStatus.APPROVE.getKey())?"批增生效起期":"期望批增生效起期";
|
}else{
|
return Constants.equalsInteger(model.getStatus(), ApplyChangeStatus.APPROVE.getKey())?"批减生效起期":"期望批减生效起期";
|
}
|
}
|
|
|
public static String getApplyTimeTitle(int type, UnionApply model){
|
if(type ==1){
|
return Constants.equalsInteger(model.getStatus(), UnionApplyStatus.FINISH.getKey())?"保险生效起期":"期望保险生效起期";
|
}else{
|
return Constants.equalsInteger(model.getStatus(), UnionApplyStatus.FINISH.getKey())?"保险生效止期":"预计生效止期";
|
}
|
|
}
|
|
public static BigDecimal getBigDecimalNoNull(BigDecimal bigDecimal){
|
if(Objects.isNull(bigDecimal)){
|
return BigDecimal.ZERO;
|
}
|
return bigDecimal;
|
}
|
|
/**
|
* 获取批改单时间标题列
|
* @param type 0更换派遣单位 1加保 0减保
|
* @param model
|
* @return
|
*/
|
public static String getChangeApplyTimeTitle(int type, UnionChange model){
|
if(type ==2){
|
return Constants.equalsInteger(model.getStatus(), UnionChangeStatus.FINISH.getKey())?"批单生效期":"期望批单生效期";
|
}else if(type ==1){
|
return Constants.equalsInteger(model.getStatus(), UnionChangeStatus.FINISH.getKey())?"批增生效起期":"期望批增生效起期";
|
}else{
|
return Constants.equalsInteger(model.getStatus(), UnionChangeStatus.FINISH.getKey())?"批减生效起期":"期望批减生效起期";
|
}
|
}
|
/**
|
* 企业数据来源 0平台注册 1后台导入
|
*/
|
public interface ORIGIN{
|
public static final int platformRegister = 0;
|
public static final int backstageImport = 1;
|
}
|
public static String getRandom6Num( ) {
|
Random random = new Random();
|
StringBuilder sb = new StringBuilder();
|
|
for (int i = 0; i < 6; i++) {
|
int digit = random.nextInt(10);
|
sb.append(digit);
|
}
|
|
return sb.toString();
|
}
|
public static BigDecimal formatBigdecimal(BigDecimal d) {
|
if (d == null) {
|
d = new BigDecimal(0.0);
|
}
|
//保留两位小数且四舍五入
|
// d = d.setScale(2, BigDecimal.ROUND_HALF_UP);
|
return d;
|
}
|
public static BigDecimal formatBigdecimal2Float(BigDecimal d) {
|
if (d == null) {
|
d = new BigDecimal(0.0);
|
}
|
//保留两位小数且四舍五入
|
d = d.setScale(2, BigDecimal.ROUND_HALF_UP);
|
return d;
|
}
|
|
public static BigDecimal formatBigdecimal4Float(BigDecimal d) {
|
if (d == null) {
|
d = new BigDecimal(0.0);
|
}
|
//保留两位小数且四舍五入
|
d = d.setScale(4, BigDecimal.ROUND_HALF_UP);
|
return d;
|
}
|
|
public static boolean equalsObject(Object a, Object b) {
|
if (a == null && b == null) {
|
return true;
|
}
|
if (a != null){
|
return a.equals(b);
|
}
|
return false;
|
}
|
|
public static boolean equalsInteger(Integer a, Integer b) {
|
if (formatIntegerNum(a) == formatIntegerNum(b)) {
|
return true;
|
}
|
return false;
|
}
|
|
public static int formatIntegerNum(Integer d) {
|
if (d == null) {
|
d = 0;
|
}
|
return d.intValue();
|
}
|
|
public static long getAgeByIdCard(String idCard){
|
try {
|
int birthYear = Integer.parseInt(idCard.substring(6, 10));
|
int birthMonth = Integer.parseInt(idCard.substring(10, 12));
|
int birthDay = Integer.parseInt(idCard.substring(12, 14));
|
try{
|
LocalDate birthDate = LocalDate.of(birthYear, birthMonth, birthDay);
|
LocalDate currentDate = LocalDate.now();
|
long age = ChronoUnit.YEARS.between(birthDate, currentDate);
|
return age;
|
}catch (Exception e){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"身份证号码错误："+idCard);
|
}
|
}catch (Exception e){
|
|
}
|
return 0;
|
|
}
|
|
public static CountCyclePriceVO getCountCyclePriceVO(CountCyclePriceDTO countCyclePriceDTO){
|
if(Objects.isNull(countCyclePriceDTO)
|
|| Objects.isNull(countCyclePriceDTO.getSolutions())
|
|| Objects.isNull(countCyclePriceDTO.getStartDate())
|
){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST);
|
}
|
return Constants.countPriceVO(countCyclePriceDTO.getStartDate(),countCyclePriceDTO.getSolutions());
|
}
|
|
public static int calculateAge(String idCard,Date dateDate) {
|
try{
|
Integer happenYear = Integer.valueOf(DateUtil.dateToString(dateDate,"yyyy"));
|
Integer birthYear = Integer.valueOf(idCard.substring(6,10));
|
return happenYear - birthYear;
|
}catch (Exception e){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"年龄信息错误");
|
}
|
|
|
|
|
|
// if (idCard == null || idCard.length() != 18) {
|
// throw new IllegalArgumentException("身份证号码必须是18位");
|
// }
|
//
|
// // 提取出生日期
|
// String birthDateStr = idCard.substring(6, 14); // 例如：19900101
|
// LocalDate birthDate = LocalDate.parse(birthDateStr);
|
// Instant instant = dateDate.toInstant();
|
// // 获取当前日期
|
// LocalDate currentDate = instant.atZone(ZoneId.systemDefault()).toLocalDate(); // 转换为 LocalDate
|
//
|
// // 计算年龄
|
// Period period = Period.between(birthDate, currentDate);
|
// int age = period.getYears(); // 直接获取年份差即为年龄
|
|
// return age;
|
}
|
|
|
public static CountCyclePriceVO countPriceVO(Date startDate, Solutions solutions){
|
CountCyclePriceVO countCyclePriceVO = new CountCyclePriceVO();
|
//天
|
if(solutions.getTimeUnit().equals(TimeUnit.DAY.getValue())){
|
countCyclePriceVO.setEndDate(
|
DateUtil.getMontageDate(
|
DateUtil.afterDateByType(startDate,0,0)
|
,2)
|
);
|
}else if(solutions.getTimeUnit().equals(TimeUnit.MONTH.getValue())){
|
//获取当月天数
|
Integer monthDays = DateUtil.monthDays(startDate);
|
//获取天数后的日期
|
Date afterDate = DateUtil.afterDateByType(startDate,0,monthDays);
|
//赋值 每日结束时分秒
|
countCyclePriceVO.setEndDate(DateUtil.getMontageDate(afterDate,3));
|
}else if(solutions.getTimeUnit().equals(TimeUnit.QUARTER.getValue())){
|
//获取X年后日期 多了一天
|
Date afterDate = DateUtil.afterDateByType(startDate,1,3);
|
//赋值 每日结束时分秒 然后减少一天
|
countCyclePriceVO.setEndDate(DateUtil.getMontageDate(afterDate,3));
|
}else if(solutions.getTimeUnit().equals(TimeUnit.HALF_YEAR.getValue())){
|
//获取X年后日期 多了一天
|
Date afterDate = DateUtil.afterDateByType(startDate,1,6);
|
//赋值 每日结束时分秒 然后减少一天
|
countCyclePriceVO.setEndDate(DateUtil.getMontageDate(afterDate,3));
|
}else if(solutions.getTimeUnit().equals(TimeUnit.YEAR.getValue())){
|
//获取X年后日期 多了一天
|
Date afterDate = DateUtil.afterDateByType(startDate,2,1);
|
//赋值 每日结束时分秒 然后减少一天
|
countCyclePriceVO.setEndDate(DateUtil.getMontageDate(afterDate,3));
|
}
|
countCyclePriceVO.setCyclePrice(solutions.getPrice());
|
return countCyclePriceVO;
|
}
|
|
//查询每个批改周期费用
|
public static BigDecimal calculateSingleCycleFee(Solutions solutions,Date startTime){
|
if(Constants.equalsInteger(solutions.getTimeUnit(),solutions.getInsureCycleUnit())){
|
return solutions.getPrice();
|
}
|
CountCyclePriceVO countCyclePriceVO = Constants.countPriceVO(startTime,solutions);
|
//单计费周期的费用
|
BigDecimal singleFee = Constants.singleCycleFee(solutions,startTime,countCyclePriceVO.getEndDate());
|
return singleFee;
|
}
|
|
|
/**
|
* 加减保业务使用
|
* 判断是否处于 周期节点
|
* 结束日期 入的日期为批单日期 前一天 23:59:59
|
* @param solutions
|
* @param startTime
|
* @param endTime
|
* @return 0=无周期费用；1=有周期费用；2无周期费用 且 数据标记无效
|
*/
|
public static ChangeDealTypeVO calculateRetreatCost(Solutions solutions , Date startTime , Date endTime){
|
ChangeDealTypeVO changeDealTypeVO = new ChangeDealTypeVO();
|
//查询每个周期的费用
|
changeDealTypeVO.setSinglePrice(Constants.calculateSingleCycleFee(solutions,startTime));
|
|
//批单日期为开始日期的第一天 则标记明细记录为 无效数据 或者 开始时间大于当前时间 直接返回 数据标记无效
|
if(startTime.getTime()>endTime.getTime()
|
|| startTime.getTime() > System.currentTimeMillis()){
|
changeDealTypeVO.setChangeStatus(Constants.TWO);
|
return changeDealTypeVO;
|
}
|
//获取昨日日期结束 为实际减保结束日期·
|
Boolean isOver = true;
|
if(solutions.getInsureCycleUnit().equals(InsureCycleUnit.DAY.getValue())){
|
//方案 计费周期和批改周期 相同 直接返回 有周期费用
|
changeDealTypeVO.setChangeStatus(Constants.ONE);
|
return changeDealTypeVO;
|
}else if(solutions.getInsureCycleUnit().equals(InsureCycleUnit.HALF_MONTH.getValue())){
|
//半月周期 以15.5计算 由于15.5 无法整除 所以需要特殊处理
|
//奇数/偶数 用于添加天数 如果是奇数
|
BigDecimal cycleHalfMonth = new BigDecimal(15.5);
|
Integer cycle = 1;
|
while(isOver){
|
//获取周期后的结束时间 带时分秒 23:59:59
|
Date cycleEndTime = DateUtil.getMontageDate(DateUtil.afterDateByType(startTime,0, cycleHalfMonth.multiply(new BigDecimal(cycle)).setScale(2,RoundingMode.HALF_UP).intValue()
|
),2);
|
if(cycleEndTime.getTime()>=endTime.getTime()){
|
isOver = false;
|
//当计费周期的结束日期 刚好 与批单日期的结束日期相等 则 不需要扣除批单周期费用
|
if(cycleEndTime.getTime()==endTime.getTime()){
|
changeDealTypeVO.setChangeStatus(Constants.ZERO);
|
}else{
|
changeDealTypeVO.setChangeStatus(Constants.ONE);
|
}
|
return changeDealTypeVO;
|
}
|
cycle = cycle + 1;
|
}
|
}else if(solutions.getInsureCycleUnit().equals(InsureCycleUnit.MONTH.getValue())){
|
//扣费周期为月
|
Integer cycle = 1;
|
while(isOver){
|
//获取周期后的结束时间 带时分秒 23:59:59
|
Date cycleEndTime = DateUtil.getMontageDate(DateUtil.afterDateByType(startTime,1,cycle),2);
|
//当前周期 大于等于 批单结束日期时 ， 则结束流程
|
if(cycleEndTime.getTime()>=endTime.getTime()){
|
isOver = false;
|
//当计费周期的结束日期 刚好 与批单日期的结束日期相等 则 不需要扣除批单周期费用
|
if(cycleEndTime.getTime()==endTime.getTime()){
|
changeDealTypeVO.setChangeStatus(Constants.ZERO);
|
}else{
|
changeDealTypeVO.setChangeStatus(Constants.ONE);
|
}
|
return changeDealTypeVO;
|
}
|
cycle = cycle + 1;
|
}
|
}else if(solutions.getTimeUnit().equals(TimeUnit.QUARTER.getValue())){
|
//扣费周期为季度
|
Integer cycle = 3;
|
while(isOver){
|
//获取周期后的结束时间 带时分秒 23:59:59
|
Date cycleEndTime = DateUtil.getMontageDate(DateUtil.afterDateByType(startTime,1,cycle),2);
|
//当前周期 大于等于 批单结束日期时 ， 则结束流程
|
if(cycleEndTime.getTime()>=endTime.getTime()){
|
isOver = false;
|
//当计费周期的结束日期 刚好 与批单日期的结束日期相等 则 不需要扣除批单周期费用
|
if(cycleEndTime.getTime()==endTime.getTime()){
|
changeDealTypeVO.setChangeStatus(Constants.ZERO);
|
}else{
|
changeDealTypeVO.setChangeStatus(Constants.ONE);
|
}
|
return changeDealTypeVO;
|
}
|
cycle = cycle + 3;
|
}
|
}else if(solutions.getTimeUnit().equals(TimeUnit.HALF_YEAR.getValue())){
|
//扣费周期为半年
|
Integer cycle = 3;
|
while(isOver){
|
//获取周期后的结束时间 带时分秒 23:59:59
|
Date cycleEndTime = DateUtil.getMontageDate(DateUtil.afterDateByType(startTime,1,cycle),2);
|
//当前周期 大于等于 批单结束日期时 ， 则结束流程
|
if(cycleEndTime.getTime()>=endTime.getTime()){
|
isOver = false;
|
//当计费周期的结束日期 刚好 与批单日期的结束日期相等 则 不需要扣除批单周期费用
|
if(cycleEndTime.getTime()==endTime.getTime()){
|
changeDealTypeVO.setChangeStatus(Constants.ZERO);
|
}else{
|
changeDealTypeVO.setChangeStatus(Constants.ONE);
|
}
|
return changeDealTypeVO;
|
}
|
cycle = cycle + 3;
|
}
|
}
|
throw new BusinessException(ResponseStatus.DATA_ERRO.getCode(),"计算批单周期信息异常");
|
|
}
|
|
|
|
|
|
|
// public static CountCyclePriceVO countPriceVO(Date startDate, Solutions solutions){
|
// CountCyclePriceVO countCyclePriceVO = new CountCyclePriceVO();
|
// if(solutions.getInsureCycleUnit().equals(Constants.ZERO)){
|
// countCyclePriceVO.setEndDate(
|
// DateUtil.getMontageDate(
|
// DateUtil.afterDateByType(startDate,0,solutions.getInsureCycle()-1)
|
// ,2)
|
// );
|
// }else if(solutions.getInsureCycleUnit().equals(Constants.TWO)){
|
// //获取当月天数
|
// Integer monthDays = DateUtil.monthDays(startDate);
|
// //获取天数后的日期
|
// Date afterDate = DateUtil.afterDateByType(startDate,0,monthDays);
|
// //赋值 每日结束时分秒
|
// countCyclePriceVO.setEndDate(DateUtil.getMontageDate(afterDate,3));
|
// }else if(solutions.getInsureCycleUnit().equals(Constants.THREE)){
|
// //获取X年后日期 多了一天
|
// Date afterDate = DateUtil.afterDateByType(startDate,2,solutions.getInsureCycle());
|
// //赋值 每日结束时分秒 然后减少一天
|
// countCyclePriceVO.setEndDate(DateUtil.getMontageDate(afterDate,3));
|
// }
|
// countCyclePriceVO.setCyclePrice(Constants.countDetailFee(solutions,countCyclePriceVO.getEndDate(),startDate));
|
// return countCyclePriceVO;
|
// }
|
|
public static Integer getSexByIdCard(String idCard){
|
if(StringUtils.isBlank(idCard)){
|
return 2;
|
}
|
Pattern pattern = Pattern.compile("\\d{17}[\\d|x|X]"); // 定义身份证号码格式的正则表达式
|
Matcher matcher = pattern.matcher(idCard);
|
Integer sex = 0;
|
if (matcher.matches()) {
|
int genderCode = Integer.parseInt(idCard.substring(16, 17)); // 从第17位开始提取性别编码（奇数为男性，偶数为女性）
|
if ((genderCode % 2 == 1) ) {
|
sex = 0;
|
} else {
|
sex = 1;
|
}
|
} else {
|
sex = 2;
|
}
|
return sex;
|
}
|
|
|
/**
|
* 状态 0已保存、1待审核、2审核通过、3退回修改、4审核驳回、5待服务机构确认、6服务机构拒绝、7已分配服务机构、8诊断中
|
* （成功上传第一份服务资料）、9服务完成、10已分配评分专家、11已完成（专家上传评分） 12退回修改中 13 已完成退回修改
|
*/
|
public enum DeclareStatus {
|
|
EDITING(0, "已保存", "已保存"),
|
CHECK_WAIT(1, "待审核", "待审核"),
|
CHECK_PASS(2, "审核通过", "审核通过"),
|
CHECK_EDIT(3, "退回修改", "退回修改"),
|
CHECK_BACK(4, "审核驳回", "审核驳回"),
|
WAIT_SO_COMFIRM(5, "待服务机构确认", "待服务机构确认"),
|
SO_BACK(6, "服务机构拒绝", "服务机构拒绝"),
|
SELECTED_SO(7, "已分配服务机构", "已分配服务机构"),
|
SERVING(8, "诊断中", "诊断中"),
|
SERVICE_DONE(9, "服务完成", "服务完成"),
|
SELECT_EXPERT(10, "已分配评分专家", "已分配评分专家"),
|
DONE(11, "已完成", "已完成"),
|
BACK_SERVER_ING(12, "退回修改", "诊断服务退回修改"),
|
BACK_SERVER_DONE(13, "退回修改完成", "诊断服务退回已修改"),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
private String noteinfo;// 描述
|
|
// 构造方法
|
DeclareStatus(int key, String name, String noteinfo) {
|
this.name = name;
|
this.key = key;
|
this.noteinfo = noteinfo;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (DeclareStatus c : DeclareStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// 普通方法
|
public static String getNoteinfo(int index) {
|
for (DeclareStatus c : DeclareStatus.values()) {
|
if (c.getKey() == index) {
|
return c.noteinfo;
|
}
|
}
|
return "-";
|
}
|
|
// 普通方法
|
public static String getInfo(int index) {
|
for (DeclareStatus c : DeclareStatus.values()) {
|
if (c.getKey() == index) {
|
return c.noteinfo;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getNoteinfo() {
|
return noteinfo;
|
}
|
|
}
|
|
public enum DeclareCheckType{
|
EDITING(0, "已保存", "已保存"),
|
CHECK_WAIT(1, "待审核", "待审核"),
|
CHECK_PASS(2, "审核通过", "审核通过"),
|
CHECK_EDIT(3, "退回修改", "退回修改"),
|
CHECK_BACK(4, "审核驳回", "审核驳回"),
|
WAIT_SO_COMFIRM(5, "待服务机构确认", "待服务机构确认"),
|
SO_BACK(6, "服务机构拒绝", "服务机构拒绝"),
|
SELECTED_SO(7, "已分配服务机构", "已分配服务机构"),
|
SERVING(8, "诊断中", "诊断中"),
|
SERVICE_DONE(9, "服务完成", "服务完成"),
|
SELECT_EXPERT(10, "已分配评分专家", "已分配评分专家"),
|
DONE(11, "已完成", "已完成"),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
private String noteinfo;// 描述
|
|
// 构造方法
|
DeclareCheckType(int key, String name, String noteinfo) {
|
this.name = name;
|
this.key = key;
|
this.noteinfo = noteinfo;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (ProjectRecord c : ProjectRecord.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// 普通方法
|
public static String getInfo(int index) {
|
for (ProjectRecord c : ProjectRecord.values()) {
|
if (c.getKey() == index) {
|
return c.noteinfo;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getNoteinfo() {
|
return noteinfo;
|
}
|
}
|
|
public enum DeclareHistoryType{
|
|
EDITING(0,"保存","保存"),
|
CHECK_WAIT_COUNTY(1,"待县区审核",""),
|
CHECK_PASS_COUNTY(2,"县区审核通过",""),
|
CHECK_EDIT_COUNTY(3,"县区退回修改",""),
|
CHECK_BACK_COUNTY(4,"县区审核驳回",""),
|
TWO_WAY_WAIT_SO_COMFIRM(5,"双选待服务机构确认",""),
|
WO_WAY_WAIT_SO_BACK(6,"双选服务机构拒绝",""),
|
SELECTED_SO(7,"已分配服务机构",""),
|
SO_SERVICE(8,"服务机构诊断",""),
|
SO_SERVICE_DONE(9,"服务机构服务完成",""),
|
SELECT_EXPERT(10,"分配评分专家",""),
|
EXPERT_SCORE(11,"专家完成评分","")
|
;
|
|
private int key;
|
private String name;
|
|
private String noteInfo;
|
|
DeclareHistoryType(int key, String name, String noteInfo) {
|
this.key = key;
|
this.name = name;
|
this.noteInfo = noteInfo;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public String getNoteInfo() {
|
return noteInfo;
|
}
|
|
public void setNoteInfo(String noteInfo) {
|
this.noteInfo = noteInfo;
|
}
|
}
|
|
public interface BasegoodsOrigin{
|
int userAdd = 0;
|
int imported = 1;
|
int basedata = 2;
|
}
|
/**
|
* 关联对象类型
|
关联对象类型 0企业营业执照 1理赔报案事故视频或图片 2理赔员工关系证明材料 3理赔门诊资料 4理赔住院资料 5理赔伤残资料 6理赔赔付结案材料 7企业身份证号 8保单申请表PDF 9签署后保单申请表PDF 10企业签章 11最终报单
|
*/
|
public enum MultiFile{
|
COM_BUSINESS_LICENSE(0, "企业营业执照", "企业营业执照"),
|
LP_SGXC_FILE(1, "理赔报案事故视频或图片", "理赔报案事故视频或图片"),
|
LP_YGGX_FILE(2, "理赔员工关系证明材料 ", "理赔员工关系证明材料 "),
|
LP_MZCL_FILE(3, "理赔门诊资料 ", "理赔门诊资料"),
|
LP_ZYCL_FILE(4, "理赔住院资料", "理赔住院资料"),
|
LP_SCZL_FILE(5, "理赔伤残资料", "理赔伤残资料"),
|
LP_JACL_FILE(6, "理赔赔付结案材料", "理赔赔付结案材料"),
|
COM_IDCARD_IMG(7, "企业身份证号", "企业身份证号"),
|
BD_APPLY_PDF(8, "保单申请表PDF ", "保单申请表PDF "),
|
BD_SIGNED_PDF(9, "签署后保单申请表PDF", "签署后保单申请表PDF"),
|
COM_SING_IMG(10, "企业印章", "企业印章"),
|
BD_DONE_PDF(11, "最终报单", "最终报单"),
|
CA_PD_PDF(12, "最终报单", "最终报单"),
|
CA_APPLY_JIAJIAN_SIGN(13, "加减保申请签章文件", "加减保申请签章文件"),
|
CA_APPLY_CHANGEUNIT_SIGN(14, "换厂申请签章文件", "换厂申请签章文件"),
|
|
HBD_BD_APPLY_PDF(15, "合并单-保单申请表PDF ", "合并单-保单申请表PDF "),
|
HBD_BD_SIGNED_PDF(16, "合并单-签署后保单申请表PDF", "合并单-签署后保单申请表PDF"),
|
SOLUTIONS_CONFIRMATION_LATTER(18, "投保方案确认书", "投保方案确认书"),
|
MEMBER_LIST_LATTER(19, "委托保 - 投保人员名单", "委托保 - 投保人员名单"),
|
// CHANGE_MEMBER_LIST_LATTER(20, "委托保 - 加减保人员名单", "委托保 - 加减保人员名单"),
|
WTB_BD_DONE_PDF(21, "委托投保单 - 合并单最终保单", "委托投保单 - 合并单最终保单"),
|
WTB_CA_DONE_PDF(23, "委托加减保/换厂业务 - 合并单最终保单", "委托加减保/换厂业务 - 合并单最终保单"),
|
WTB_CONFIRMATION_LATTER(24, "委托保 - 投保方案确认书", "委托保 - 投保方案确认书"),
|
WTB_CA_TBD_PDF(25, "委托加减保/换厂业务 -申请单（商户签署后PDF）", "委托加减保/换厂业务 -申请单（商户签署后PDF）"),
|
|
CONTRACT_PDF(26, "合同附件", "合同附件"),
|
CONTRACT_FIRST_PDF(27, "合同签署附件", "合同签署附件"),
|
CONTRACT_DONE_PDF(28, "合同签署附件", "合同签署附件"),
|
COMPANY_SOLUTION_SIGN_PDF(29, "企业签署后方案确认书", "企业签署后方案确认书"),
|
COMPANY_USER_APPLY(30, "企业申请集团用户附件", "企业申请集团用户附件"),
|
|
LP_STAMP_FILE(31, "保险公司理赔盖章文件", "保险公司理赔盖章文件"),
|
LP_FILE(32, "保险公司上传理赔材料一览表", "保险公司上传理赔材料一览表"),
|
LP_OTHER_FILE(33, "理赔其他材料", "理赔其他材料"),
|
LP_PAY_FILE(34, "打款凭证", "打款凭证"),
|
LP_DZBD_FILE(35, "电子保单", "电子保单"),
|
LP_SUPPLEMENT_FILE(36, "补充材料", "补充材料"),
|
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
private String noteinfo;// 描述
|
|
// 构造方法
|
MultiFile(int key, String name, String noteinfo) {
|
this.name = name;
|
this.key = key;
|
this.noteinfo = noteinfo;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (MultiFile c : MultiFile.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// 普通方法
|
public static String getInfo(int index) {
|
for (MultiFile c : MultiFile.values()) {
|
if (c.getKey() == index) {
|
return c.noteinfo;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getNoteinfo() {
|
return noteinfo;
|
}
|
|
private volatile static Set<Integer> multifileCompanyType;
|
|
private volatile static Set<Integer> multifileProjectType;
|
|
public static Set<Integer> multifileCompanyType(){
|
// 0企业营业执照 1工商变更登记 7企业资质 8企业中标通知书 11 变更企业营业执照 12 变更工商变更登记
|
|
if (CollectionUtils.isEmpty(multifileCompanyType)){
|
synchronized (MultiFile.class){
|
if (CollectionUtils.isEmpty(multifileCompanyType)){
|
multifileCompanyType = new HashSet<>();
|
multifileCompanyType.add(0);
|
multifileCompanyType.add(1);
|
multifileCompanyType.add(8);
|
multifileCompanyType.add(9);
|
multifileCompanyType.add(11);
|
multifileCompanyType.add(12);
|
}
|
}
|
}
|
return multifileCompanyType;
|
}
|
|
public static Set<Integer> multifileProjectType(){
|
|
//2项目申报企业资料 3企业评分表 4诊断报告 5诊断服务资料 6专家评分报告 7服务机构上传服务资料
|
if (CollectionUtils.isEmpty(multifileProjectType)){
|
synchronized (MultiFile.class){
|
if(CollectionUtils.isEmpty(multifileProjectType)){
|
multifileProjectType = new HashSet<>();
|
multifileProjectType.add(2);
|
multifileProjectType.add(3);
|
multifileProjectType.add(4);
|
multifileProjectType.add(5);
|
multifileProjectType.add(6);
|
multifileProjectType.add(7);
|
multifileProjectType.add(10);
|
multifileProjectType.add(13);
|
}
|
}
|
}
|
return multifileProjectType;
|
}
|
|
public static Integer multifileType(String name){
|
|
boolean pic = Arrays.asList(".jpg", "png", "jpeg").stream().anyMatch(s -> name.contains(s));
|
if (pic){
|
return Constants.ZERO;
|
}
|
boolean ivc = Arrays.asList(".avi", "mp4").stream().anyMatch(s -> name.contains(s));
|
if (ivc){
|
return Constants.ONE;
|
}
|
return Constants.TWO;
|
|
}
|
|
|
}
|
|
public static void main(String[] args) {
|
System.out.println(BigDecimal.valueOf(3.45678).setScale(2,BigDecimal.ROUND_HALF_UP));
|
System.out.println(BigDecimal.valueOf(3.45678).setScale(2,BigDecimal.ROUND_DOWN));
|
// System.out.println(IdcardUtil.isValidCard("340621199310134818"));
|
// System.out.println(IdcardUtil.isValidCard("341621199310134818"));
|
|
// System.out.println("{\"companyName\":\"应宝科技\",\"endtime\":\"2024-03-01 17:19:00\",\"erpId\":\"4D40185D5BC74A13821BE46EAF8B4179\",\"erpWithVisitDTOList\":[],\"faceImg\":\"20240304/1709518170325_742.jpg\",\"idcardNo\":\"342501199609300535\",\"idcardType\":0,\"name\":\"黄晋\",\"phone\":\"17756328697\",\"reason\":\"探险\",\"receptMemberId\":\"E7E514BD7DE3F27CE0530B630A0AEAE0\",\"starttime\":\"2024-03-01 13:18:00\"}");
|
}
|
/**
|
* 用户类型 0系统用户 1企业用户 2服务机构管理员 3服务机构子账号 4综合服务单位管理员 5综合服务单位子账号 6专家 7县区用户 8市局用户
|
*/
|
public enum UserType {
|
|
SYSTEM(0, "系统用户", "管理员",Arrays.asList(0,1,2,3,4,5,6,7,8,9,10,11)),
|
COMPANY(1, "企业用户", "企业",Arrays.asList(-1)),
|
ZHUBO(2, "商户", "商户",Arrays.asList(-1)),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
private List<Integer> historyStatus;
|
private String noteinfo;// 描述
|
|
// 构造方法
|
UserType(int key, String name, String noteinfo,List<Integer> historyStatus) {
|
this.name = name;
|
this.key = key;
|
this.noteinfo = noteinfo;
|
this.historyStatus=historyStatus;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (UserType c : UserType.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// 普通方法
|
public static String getInfo(int index) {
|
for (UserType c : UserType.values()) {
|
if (c.getKey() == index) {
|
return c.noteinfo;
|
}
|
}
|
return null;
|
}
|
// 普通方法
|
public static List<Integer> getHistoryStatus(int index) {
|
for (UserType c : UserType.values()) {
|
if (c.getKey() == index) {
|
return c.historyStatus;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
public List<Integer> getHistoryStatus() {
|
return historyStatus;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getNoteinfo() {
|
return noteinfo;
|
}
|
|
|
|
}
|
|
|
public enum DispatchUnitLogType {
|
UPLOAD(0, "提交申请"),
|
AUDIT_PASS(1, "派遣单位通过"),
|
AUDIT_UN_PASS(2, "派遣单位不通过"),
|
EDIT_UNIT(3, "修改派遣单位信息"),
|
ADD_WORK_TYPE(4, "提交添加工种"),
|
WORK_TYPE_AUDIT_PASS(5, "添加工种审批通过"),
|
WORK_TYPE_AUDIT_UN_PASS(6, "添加工种审批不通过"),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
|
// 构造方法
|
DispatchUnitLogType(int key, String name) {
|
this.name = name;
|
this.key = key;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (DispatchUnitLogType c : DispatchUnitLogType.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
}
|
|
public enum ApplyCollectStatus {
|
DSP(0, "待审核"),
|
DCD(1, "待出单"),
|
BZZ(2, "保障中"),
|
YGQ(3, "已过期"),
|
YTH(4, "已退回"),
|
THSQZ(5, "申请退回"),
|
YGB(6, "已关闭"),
|
DQYQZ(7, "待签署"),
|
|
WTBDQS(28, "待签署"),
|
WTBDSH(22, "待审核"),
|
WTBDCD(23, "待出单"),
|
WTBYTH(24, "已退回"),
|
WTBYGB(25, "已关闭"),
|
//2024年4月25日15:17:13 修改 投保中 = 》 批改申请中
|
//2024-5-21 14:04:10 修改 批改申请中= 》投保中
|
WTBTBZ(26, "投保中"),
|
WTBBZZ(27, "保障中"),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
|
// 构造方法
|
ApplyCollectStatus(int key, String name) {
|
this.name = name;
|
this.key = key;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (ApplyCollectStatus c : ApplyCollectStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
}
|
|
|
public enum ApplyLogType {
|
UPLOAD(0, "提交投保","提交意见：${param}",0),
|
PLATFORM_RETURN(1, "退回申请","提交意见：${param}",0),
|
WAIT_SIGNATURE(2, "上传投保单","提交意见：${param}",0),
|
SIGNATURE(3, "企业签章","",0),
|
FAIL_RETURN(4, "保单出具失败退回","提交意见：${param}",0),
|
UPLOAD_INSURANCE(5, "保单完成","保险生效起期：${param1}变更为${param2}",0),
|
COMPANY_APPLY_RETURN(6, "申请退回","提交意见：${param}",0),
|
COMPANY_APPLY_CLOSE(7, "关闭申请","",0),
|
PLATFORM_AGREE_BACK(8, "同意退回申请","",0),
|
PLATFORM_UN_AGREE_BACK(9, "驳回退回申请","提交意见：${param}",0),
|
COMPANY_EDIT(10, "保单修改","提交意见：${param1}\n${param2}",0),
|
PLATFORM_CHECK_PASS(11, "投保审核通过","提交意见：${param}",0),
|
|
CA_PLATFORM_CHECK_PASS_NO(12, "退回申请","提交意见：${param}",1),
|
CA_PLATFORM_AGREE_BACK_APPLY(13, "同意退回申请","提交意见：${param}",1),
|
CA_PLATFORM_APPROVE(14, "批单完成","保险生效起期：${param1}变更为${param2}",1),
|
CA_PLATFORM_CHECK_SIGNATURE(15, "企业签章","",1),
|
CA_COMPANY_EDIT(16, "批单修改","提交意见：${param1}\n${param2}",1),
|
CA_COMPANY_COMMIT(17, "提交投保","",1),
|
CA_COMPANY_BACK_APPLY(18, "申请退回","提交意见：${param}",1),
|
CA_COMPANY_CLOSE(19, "关闭申请","",1),
|
CA_PALTFORM_REFUSE_APPLY(20, "驳回退回申请","",1),
|
CA_PALTFORM_EDIT_PIDAN(21, "修改批单","修改原因：${param}",1),
|
CA_JIAJIAN_APPLY_SIGN(23, "加减保申请企业签章","",1),
|
CA_CHANGUNIT_APPLY_SIGN(24, "换厂申请企业签章","",1),
|
CA_UPLOAD_AGAIN(25, "再次投保","",1),
|
CA_HBD_AUDIT(42, "审批通过","原因：${param}",1),
|
|
WTB_FINISH_FAQRS(26, "委托保 - 企业完成签署方案确认书","",0),
|
WTB_FINISH_MEMBER_LIST(27, "委托保 - 企业完成签署人员名单","",0),
|
CA_WTB_FINISH_MEMBER_LIST(28, "委托保 - 加减保签署人员名单","",1),
|
UPLOAD_AGAIN(29, "再次投保","",0),
|
PALTFORM_EDIT_BD(30, "修改保单","修改原因：${param}",0),
|
SHOP_CLOSE_WTB_APPLY(31, "关闭申请","原因：${param}",0),
|
|
|
/**
|
* 委托保 投保单合并单日志
|
*/
|
IA_HBD_UPLOAD(32, "提交申请","",3),
|
IA_HBD_UPLOAD_TBD(33, "上传投保单","",3),
|
IA_HBD_SIGNATURE_TBD(34, "商户签章","",3),
|
IA_HBD_UPLOAD_INSURANCE(35, "投保完成","保险生效起期：${param1}变更为${param2}",3),
|
IA_HBD_CLOSE(36, "退回申请","原因：${param}",3),
|
IA_HBD_UPLOAD_BXD(41, "上传保险单","",3),
|
IA_HBD_REEXAMINE_PASS(42, "复审通过","",3),
|
|
|
|
/**
|
* 委托保 加减保/换厂 合并单
|
*/
|
CA_HBD_UPLOAD(37, "提交申请","",4),
|
CA_HBD_SIGNATURE_TBD(38, "商户签章","",4),
|
CA_HBD_UPLOAD_INSURANCE(39, "投保完成","",4),
|
CA_HBD_CLOSE(40, "退回申请","原因：${param}",4),
|
|
|
|
|
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private int key;
|
private int type;
|
|
// 构造方法
|
ApplyLogType(int key, String name,String info,int type) {
|
this.name = name;
|
this.info = info;
|
this.key = key;
|
this.type = type;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (ApplyLogType c : ApplyLogType.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
public static String getInfo(int index) {
|
for (ApplyLogType c : ApplyLogType.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
public static List<Integer> getTypeList(int type) {
|
List<Integer> list = new ArrayList<>();
|
for (ApplyLogType c : ApplyLogType.values()) {
|
if (c.getType() == type) {
|
list.add(c.getKey());
|
}
|
}
|
return list;
|
}
|
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
|
|
public int getType() {
|
return type;
|
}
|
|
public void setType(int type) {
|
this.type = type;
|
}
|
}
|
|
public enum UnionApplyStatus {
|
MERGE(0, "待审核","",0),
|
WAIT_SIGNATURE(1, "待签署","",0),
|
UPLOAD_INSURANCE_POLICY(2, "待出单","",0),
|
FINISH(3, "保障中","",0),
|
CLOSE(4, "已退回","",0),
|
RETRIAL(5, "待审核","",0),
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private int key;
|
private int collectStatus;
|
|
|
// 构造方法
|
UnionApplyStatus(int key, String name,String info,int collectStatus) {
|
this.name = name;
|
this.key = key;
|
this.info = info;
|
this.collectStatus = collectStatus;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (UnionApplyStatus c : UnionApplyStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
public static List<Integer> getKesByStatus(Integer collectStatus) {
|
List<Integer> list = new ArrayList<>();
|
if(collectStatus!=null){
|
for (UnionApplyStatus c : UnionApplyStatus.values()) {
|
if (Constants.equalsInteger(c.getCollectStatus() ,collectStatus)) {
|
list.add(c.getKey());
|
}
|
}
|
}
|
return list;
|
}
|
public static Integer getCollectStatus(Integer index) {
|
for (UnionApplyStatus c : UnionApplyStatus.values()) {
|
if (Constants.equalsInteger(c.getKey() , index)) {
|
return c.collectStatus;
|
}
|
}
|
return null;
|
}
|
public static String getInfo(int index) {
|
for (UnionApplyStatus c : UnionApplyStatus.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
|
public int getCollectStatus() {
|
return collectStatus;
|
}
|
|
public void setCollectStatus(int collectStatus) {
|
this.collectStatus = collectStatus;
|
}
|
}
|
|
/**
|
* 方案 周期单位
|
* coefficient 以半月为最小颗粒
|
*/
|
public enum TimeUnit {
|
DAY(0,"日",0),
|
MONTH(2,"月",2),
|
QUARTER(3,"季度",6),
|
HALF_YEAR(4,"半年",12),
|
YEAR(5,"年",24);
|
private Integer value;
|
private String des;
|
private Integer coefficient;
|
|
|
TimeUnit(Integer value, String des, Integer coefficient) {
|
this.value = value;
|
this.des = des;
|
this.coefficient = coefficient;
|
}
|
|
public Integer getValue() {
|
return value;
|
}
|
|
public void setValue(Integer value) {
|
this.value = value;
|
}
|
|
public String getDes() {
|
return des;
|
}
|
|
public void setDes(String des) {
|
this.des = des;
|
}
|
|
public Integer getCoefficient() {
|
return coefficient;
|
}
|
|
public void setCoefficient(Integer coefficient) {
|
this.coefficient = coefficient;
|
}
|
|
public static TimeUnit getTimeUnit(Integer value) {
|
for (TimeUnit c : TimeUnit.values()) {
|
if (Constants.equalsInteger(c.getValue() , value)) {
|
return c;
|
}
|
}
|
return null;
|
}
|
}
|
|
/**
|
* 方案 周期单位 INSURE_CYCLE_UNIT
|
* coefficient 以半月为最小颗粒
|
*/
|
public enum InsureCycleUnit {
|
DAY(0,"日",new BigDecimal(1),0),
|
HALF_MONTH(1,"半月",new BigDecimal(15.5),1),
|
MONTH(2,"月",new BigDecimal(31),2),
|
QUARTER(3,"季度",new BigDecimal(92),6),
|
HALF_YEAR(4,"半年", new BigDecimal(184),12),
|
YEAR(5,"年", new BigDecimal(365),24);
|
private Integer value;
|
private String des;
|
private BigDecimal days;
|
private Integer coefficient;
|
|
|
public static InsureCycleUnit getInsureCycleUnit(Integer value) {
|
for (InsureCycleUnit c : InsureCycleUnit.values()) {
|
if (Constants.equalsInteger(c.getValue() , value)) {
|
return c;
|
}
|
}
|
return null;
|
}
|
|
InsureCycleUnit(Integer value, String des,BigDecimal days, Integer coefficient) {
|
this.value = value;
|
this.des = des;
|
this.days = days;
|
this.coefficient = coefficient;
|
}
|
|
public Integer getValue() {
|
return value;
|
}
|
|
public void setValue(Integer value) {
|
this.value = value;
|
}
|
|
public String getDes() {
|
return des;
|
}
|
|
public void setDes(String des) {
|
this.des = des;
|
}
|
public BigDecimal getDays() {
|
return days;
|
}
|
|
public void setDays(BigDecimal days) {
|
this.days = days;
|
}
|
|
public Integer getCoefficient() {
|
return coefficient;
|
}
|
|
public void setCoefficient(Integer coefficient) {
|
this.coefficient = coefficient;
|
}
|
|
}
|
|
|
|
|
public enum UnionChangeStatus {
|
MERGE(0, "待签署",""),
|
UPLOAD_INSURANCE_POLICY(1, "待出单",""),
|
FINISH(2, "保障中",""),
|
CLOSE(3, "已退回",""),
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private int key;
|
|
|
// 构造方法
|
UnionChangeStatus(int key, String name,String info) {
|
this.name = name;
|
this.key = key;
|
this.info = info;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (UnionChangeStatus c : UnionChangeStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
public static String getInfo(int index) {
|
for (UnionChangeStatus c : UnionChangeStatus.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
}
|
|
public enum InsuranceApplyStatus {
|
UPLOAD(0, "提交投保","",0),
|
PLATFORM_RETURN(1, "审核不通过","提交意见：${param}",4),
|
WAIT_SIGNATURE(2, "已上传代签申请表待企业签章","",7),
|
SIGNATURE(3, "已签章待上传保险单","",1),
|
FAIL_RETURN(4, "保单出具失败退回","",4),
|
UPLOAD_INSURANCE(5, "保单完成","保险生效起期：${param}变更为${param1}",2),
|
COMPANY_BACK_APPLY_UPLOAD(6, "企业申请退回(提交投保)","提交意见：${param}",5),
|
COMPANY_BACK_APPLY_WAIT_SIGNATURE(7, "企业申请退回(待签章)","提交意见：${param}",5),
|
COMPANY_BACK_APPLY_SIGNATURE(8, "企业申请退回(已签章)","提交意见：${param}",5),
|
CLOSE(9, "订单关闭","",6),
|
PLATFORM_CHECK_PASS(10,"平台投保审核通过","提交意见：${param}",0),
|
COMPANY_BACK_APPLY_PASS(11, "企业申请退回(平台投保审核通过)","提交意见：${param}",5),
|
REEXAMINE(12, "商户或平台复审","复审意见：${param}",0),
|
|
|
WTB_UPLOAD(20, "提交投保","",28),
|
WTB_COMPANY_APPLY_SIGNATURE(21, "企业已签署投保确认书","提交意见：${param}",28),
|
WTB_COMPANY_MEMBER_LIST_SIGNATURE(22, "企业已签署人员名单","提交意见：${param}",22),
|
WTB_BUSINESS_CHECK_PASS(23,"商户投保审核通过","提交意见：${param}",23),
|
WTB_RETURN(24, "已退回","提交意见：${param}",24),
|
WTB_CLOSED(25, "已关闭","提交意见：${param}",25),
|
WTB_TOUBAOING(26, "待出单","提交意见：${param}",26),
|
WTB_DONE(27, "保障中","提交意见：${param}",27),
|
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private int key;
|
private int collectStatus;
|
|
|
// 构造方法
|
InsuranceApplyStatus(int key, String name,String info,int collectStatus) {
|
this.name = name;
|
this.key = key;
|
this.info = info;
|
this.collectStatus = collectStatus;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (InsuranceApplyStatus c : InsuranceApplyStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
public static List<Integer> getKesByStatus(Integer collectStatus) {
|
List<Integer> list = new ArrayList<>();
|
if(collectStatus!=null){
|
for (InsuranceApplyStatus c : InsuranceApplyStatus.values()) {
|
if (Constants.equalsInteger(c.getCollectStatus() ,collectStatus)) {
|
list.add(c.getKey());
|
}
|
}
|
}
|
return list;
|
}
|
public static Integer getCollectStatus(Integer index) {
|
for (InsuranceApplyStatus c : InsuranceApplyStatus.values()) {
|
if (Constants.equalsInteger(c.getKey() , index)) {
|
return c.collectStatus;
|
}
|
}
|
return null;
|
}
|
public static String getInfo(int index) {
|
for (InsuranceApplyStatus c : InsuranceApplyStatus.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
|
public int getCollectStatus() {
|
return collectStatus;
|
}
|
|
public void setCollectStatus(int collectStatus) {
|
this.collectStatus = collectStatus;
|
}
|
}
|
|
|
public enum NoticeObjectType {
|
INSURANCE_APPLY(0, "投保申请","保险方案"),
|
APPLY_CHANGE(1, "加减保申请","保险方案"),
|
CHANGE_FACTORY(2, "员工换厂申请","保险方案"),
|
DISPATCH_UNIT(3, "派遣单位申请","派遣单位"),
|
TAXES(4, "开票申请","开票金额"),
|
SETTLE_CLAIMS(5, "理赔提醒","报案信息"),
|
CONTRACT(6, "合同签署","合同签署"),
|
SOLUTIONS(7, "方案签署","方案签署"),
|
COMPANY_USER_APPLY(8, "集团申请","集团申请"),
|
SETTLE_CLAIMS_APPLY_ADMIN(9, "报案理赔","待立案"),
|
;
|
// 成员变量
|
private int key;
|
private String name;
|
private String info;
|
|
// 构造方法
|
NoticeObjectType(int key, String name,String info) {
|
this.name = name;
|
this.key = key;
|
this.info = info;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (NoticeObjectType c : NoticeObjectType.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
|
}
|
|
|
public enum NoticeType {
|
|
ZERO(0, "待审核","","","待审核","待处理","风险案件待审核","待签署","待签署"),
|
//理赔通知企业（非待办）
|
ONE(1, "企业待签署","","","工种待审核","","风险案件立案退回","",""),
|
TWO(2, "待出单","待审核","待审核","","","已立案待受理","",""),
|
THREE(3, "申请退回","申请退回","申请退回","","","已受理，需要补充材料","",""),
|
//理赔通知企业（非待办）
|
FOUR(4, "已退回","已退回","已退回","","","已拒绝受理","",""),
|
FIVE(5, "申请驳回","申请驳回","申请驳回","","","商议待领导审批","",""),
|
//续保通知
|
SIX(6, "","","","","","商议审批拒绝","",""),
|
//商户端 委托保 - 投保待审核 加减保 换厂 待审核, 理赔通知企业（非待办）
|
SEVEN(7, "待审核","待审核","待审核","","","商议审批拒绝通知","",""),
|
//待复审
|
EIGHT(8, "待审核","","","","","待理算","",""),
|
NINE(9, "","","","","","待核赔","",""),
|
TEN(10, "","","","","","待核赔确认","",""),
|
ELEVEN(11, "","","","","","赔付金额已变更","",""),
|
TWELVE(12, "","","","","","待结案","",""),
|
//理赔通知平台（非代办）
|
THIRTEEN(13, "","","","","","已结案，赔付款项将在1-3个工作日内到账","",""),
|
//理赔通知平台（非代办）
|
FOURTEEN(14, "","","","","","已撤案","",""),
|
//理赔通知企业（非待办）
|
FIFTEEN(15, "","","","","","已受理待理算","",""),
|
//理赔通知企业(非待办）
|
SIXTEEN(16, "","","","","","受理审批中","",""),
|
//理赔通知企业(非待办）
|
SEVENTEEN(17, "","","","","","已理算待核赔","",""),
|
//理赔通知企业(非待办）
|
EIGHTEEN(18, "","","","","","待结案，赔付金额已变更","",""),
|
;
|
|
// 成员变量
|
private int status;
|
private String insuranceApplyDetail;
|
private String applyChangeDetail;
|
private String changeFactoryDetail;
|
private String dispatchUnitDetail;
|
private String taxesDetail;
|
private String settleClaimsDetail;
|
private String contract;
|
private String solutions;
|
|
// 构造方法
|
NoticeType(int status, String insuranceApplyDetail,String applyChangeDetail
|
, String changeFactoryDetail,String dispatchUnitDetail
|
, String taxesDetail,String settleClaimsDetail,String contract,String solutions) {
|
this.status = status;
|
this.insuranceApplyDetail = insuranceApplyDetail;
|
this.applyChangeDetail = applyChangeDetail;
|
this.changeFactoryDetail = changeFactoryDetail;
|
this.dispatchUnitDetail = dispatchUnitDetail;
|
this.taxesDetail = taxesDetail;
|
this.settleClaimsDetail = settleClaimsDetail;
|
this.contract = contract;
|
this.solutions = solutions;
|
}
|
|
// 普通方法
|
public static String getDetail(int status,int type) {
|
for (NoticeType c : NoticeType.values()) {
|
if (c.getStatus() == status) {
|
if(type==NoticeObjectType.INSURANCE_APPLY.getKey() ){
|
return c.getInsuranceApplyDetail();
|
}else if(type == NoticeObjectType.APPLY_CHANGE.getKey()){
|
return c.getApplyChangeDetail();
|
}else if(type == NoticeObjectType.CHANGE_FACTORY.getKey()){
|
return c.getChangeFactoryDetail();
|
}else if(type == NoticeObjectType.DISPATCH_UNIT.getKey()){
|
return c.getDispatchUnitDetail();
|
}else if(type == NoticeObjectType.TAXES.getKey()){
|
return c.getTaxesDetail();
|
}else if(type == NoticeObjectType.SETTLE_CLAIMS.getKey()){
|
return c.getSettleClaimsDetail();
|
}else if(type == NoticeObjectType.CONTRACT.getKey()){
|
return c.getContract();
|
}else if(type == NoticeObjectType.SOLUTIONS.getKey()){
|
return c.getContract();
|
}
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public int getStatus() {
|
return status;
|
}
|
|
public void setStatus(int status) {
|
this.status = status;
|
}
|
|
public String getInsuranceApplyDetail() {
|
return insuranceApplyDetail;
|
}
|
|
public void setInsuranceApplyDetail(String name) {
|
this.insuranceApplyDetail = insuranceApplyDetail;
|
}
|
|
public String getApplyChangeDetail() {
|
return applyChangeDetail;
|
}
|
|
public void setApplyChangeDetail(String info) {
|
this.applyChangeDetail = applyChangeDetail;
|
}
|
|
public String getChangeFactoryDetail() {
|
return changeFactoryDetail;
|
}
|
|
public void setChangeFactoryDetail(String info) {
|
this.changeFactoryDetail = changeFactoryDetail;
|
}
|
|
public String getDispatchUnitDetail() {
|
return dispatchUnitDetail;
|
}
|
|
public void setDispatchUnitDetail(String info) {
|
this.dispatchUnitDetail = dispatchUnitDetail;
|
}
|
|
public String getTaxesDetail() {
|
return taxesDetail;
|
}
|
|
public void setTaxesDetail(String info) {
|
this.taxesDetail = taxesDetail;
|
}
|
|
public String getSettleClaimsDetail() {
|
return settleClaimsDetail;
|
}
|
|
public void setSettleClaimsDetail(String info) {
|
this.settleClaimsDetail = settleClaimsDetail;
|
}
|
|
public String getContract() {
|
return contract;
|
}
|
|
public void setContract(String info) {
|
this.contract = contract;
|
}
|
|
}
|
|
|
public static BigDecimal countDetailFee(Solutions solutions,Date startDate, Date endDate){
|
//查询保险实际周期
|
Integer cycle = DateUtil.calculateBetween(endDate,startDate,solutions.getTimeUnit());
|
if(cycle==-1){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"日期信息错误!");
|
}
|
return solutions.getPrice().multiply(new BigDecimal(cycle));
|
}
|
|
public static BigDecimal countDetailFee(int timeUnit ,BigDecimal price,Date startDate, Date endDate){
|
//查询保险实际周期
|
Integer cycle = DateUtil.calculateBetween(endDate,startDate,timeUnit);
|
if(cycle==-1){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"日期信息错误!");
|
}
|
return Constants.formatBigdecimal(price).multiply(new BigDecimal(cycle));
|
}
|
|
|
public enum ApplyChangeStatus {
|
UPLOAD(0, "提交加减保/换厂申请"),
|
SIGNATURE(1, "已签章"),
|
APPROVE(2, "已上传审核"),
|
RETURN_APPLY_UPLOAD(3, "发起退回申请(待审核)"),
|
RETURN_APPLY_SIGNATURE(4, "发起退回申请（已签章）"),
|
PLATFORM_AGREE(5, "平台同意（已退回）"),
|
CLOSE(6, "已关闭"),
|
CHECHED_PASSED(7, "审核通过"),
|
PALTFORM_CHECK_PASS_NO(8, "审核不通过"),
|
WTB_TOUBAOING(9, "批改申请中"),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
|
// 构造方法
|
ApplyChangeStatus(int key, String name) {
|
this.name = name;
|
this.key = key;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (InsuranceApplyStatus c : InsuranceApplyStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
}
|
|
public enum CONTRACT_STATUS{
|
WAIT(0, "待签署"),
|
OUT_SIGN(1, "我方已签署"),
|
COMPANY_SIGN(2, "企业/商户已签署"),
|
FINISH(3, "已完成"),
|
CANCEL(4, "已取消"),
|
CLOSE(5, "已关闭"),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
|
// 构造方法
|
CONTRACT_STATUS(int key, String name) {
|
this.name = name;
|
this.key = key;
|
}
|
// 普通方法
|
public static String getName(int index) {
|
for (CONTRACT_STATUS c : CONTRACT_STATUS.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
|
|
}
|
|
|
public enum SettleClaimsStatus {
|
//状态 0暂存中 1已报案 2待立案 3已立案 4立案退回 5待受理 6拒绝受理 7商议待审批
|
// 8商议审批拒绝 9已受理 10待核赔 11已核赔 12已确认金额 13已结案 14已撤案
|
WAIT_ACCEPTANCE(0, "暂存中",0),
|
RETURN_ACCEPTANCE(1, "已报案",1),
|
DEAL_ING(2, "待立案",0),//弃用
|
CONFIRM_INFORMATION(3, "已立案",2),
|
FINISH_ACCEPTANCE(4, "立案退回",2),
|
WAIT_DEAL(5, "待受理",3),//弃用
|
REJECT_DEAL(6, "拒绝受理",3),
|
WAIT_DISCUSS_AUDIT(7, "待商议审批",3),
|
WAIT_DISCUSS_REJECT(8, "商议审批拒绝",3),
|
ACCEPTANCE(9, "已受理",3),//待理算
|
WAIT_AUDIT_COMPENSATION(10, "待核赔",4),
|
COMPENSATION(11, "已核赔",5),
|
CONFIRM_FEE(12, "待结案",5),
|
CLOSE_CASE(13, "已结案",6),
|
RETURN(14, "已撤案",7),
|
;
|
// 成员变量
|
private String name;//业务描述
|
private int key;//业务状态
|
private int parentKey;//主流程 1=报案 2=立案 3=受理 4=理算 5=核赔 6=结案/已撤案
|
|
// 构造方法
|
SettleClaimsStatus(int key, String name,int parentKey) {
|
this.name = name;
|
this.key = key;
|
this.parentKey = parentKey;
|
}
|
// 普通方法
|
public static String getName(int index) {
|
for (SettleClaimsStatus c : SettleClaimsStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public int getParentKey() {
|
return parentKey;
|
}
|
|
public void setParentKey(int parentKey) {
|
this.parentKey = parentKey;
|
}
|
}
|
|
public enum SettleClaimsLogType {
|
UPLOAD(0, "提交报案","提交意见：${param}"),
|
PLATFORM_RETURN(1, "平台退回","提交意见：${param}"),
|
PLATFORM_CONFIRM_INFORMATION(2, "平台确认资料",""),
|
PLATFORM_FINISH(3, "已结案","提交意见：${param}"),
|
UPDATE_DATA(4, "修改信息","提交意见：${param}"),
|
SUPPLEMENT(5, "补充说明","提交意见：${param}"),
|
PLATFORM_LP_DEAL(6, "平台理赔处理","已在平台完成理赔"),
|
PLATFORM_REMARK(7, "备注标签","${param}"),
|
PLATFORM_ADDCODE(8, "平台修改报案号","备案号：${param}"),
|
PLATFORM_UN_AGREE_BACK(9, "企业下载资料",""),
|
PLATFORM_DOWNLOAD(10, "平台下载资料",""),
|
PLATFORM_CHECK_PASS(11, "平台上传资料",""),
|
SUPPLEMENT_DESCRIBE(12, "平台填写需补充内容",""),
|
RETURN_SETTLE(13, "撤销报案",""),
|
PLATFORM_REGISTER(14, "平台立案",""),
|
PLATFORM_ACCEPTANCE(15, "受理-已受理",""),
|
PLATFORM_REFUSE_ACCEPTANCE(16, "受理-拒绝受理","拒绝原因：${param}"),
|
PLATFORM_DISCUSS(17, "受理-商议",""),
|
PLATFORM_DISCUSS_PASS(18, "受理-商议通过",""),
|
PLATFORM_DISCUSS_REFUSE(19, "受理-商议拒绝","拒绝原因：${param}"),
|
PLATFORM_WAIT_DISCUSS(20, "受理-商议待审批",""),
|
PLATFORM_HP_DEAL(21, "核赔-提交核赔金额","已提交赔付金额，待用户确认"),
|
PLATFORM_UPD_FEE(22, "核赔-修改金额",""),
|
CONFIRM_FEE(22, "核赔-客户确认金额","已确认金额"),
|
UPD_CASE_TYPE(23, "受理-确认案件类型","已确认案件类型"),
|
UPD_HURT_TYPE(24, "修改伤残类型信息","是否伤残修改为“{param}”"),
|
UPD_RECEIVE_INFO(25, "收款信息变更","修改收款信息"),
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private int key;
|
|
// 构造方法
|
SettleClaimsLogType(int key, String name,String info) {
|
this.name = name;
|
this.info = info;
|
this.key = key;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (SettleClaimsLogType c : SettleClaimsLogType.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
public static String getInfo(int index) {
|
for (SettleClaimsLogType c : SettleClaimsLogType.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
}
|
|
|
public enum SettleClaimsLogParentStatus {
|
BA(1, "报案","已报案","已报案"),
|
LA(2, "立案","已立案","待立案"),
|
SL(3, "受理","已受理","待受理"),
|
LS(4, "理算","已理算","待理算"),
|
HP(5, "核赔","已核赔","待核赔"),
|
JA(6, "结案","已结案","待结案"),
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private String waitInfo;
|
private int key;
|
|
// 构造方法
|
SettleClaimsLogParentStatus(int key, String name,String info,String waitInfo) {
|
this.name = name;
|
this.info = info;
|
this.key = key;
|
this.waitInfo = waitInfo;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (SettleClaimsLogParentStatus c : SettleClaimsLogParentStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// 普通方法
|
public static SettleClaimsLogParentStatus getAll(int index) {
|
for (SettleClaimsLogParentStatus c : SettleClaimsLogParentStatus.values()) {
|
if (c.getKey() == index) {
|
return c;
|
}
|
}
|
return null;
|
}
|
|
public static String getInfo(int index) {
|
for (SettleClaimsLogParentStatus c : SettleClaimsLogParentStatus.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
|
|
public String getWaitInfo() {
|
return waitInfo;
|
}
|
|
public void setWaitInfo(String waitInfo) {
|
this.waitInfo = waitInfo;
|
}
|
|
}
|
|
|
|
|
public enum ApplyChangeLogStatus {
|
UPLOAD(0, "发起申请",""),
|
RETURN_APPLY(3, "发起退回申请","提交意见：${param}"),
|
PLATFORM_AGREE(4, "平台审核通过" ,"提交意见：${param}"),
|
PLATFORM_UN_AGREE(0, "审核驳回","提交意见：${param}"),
|
CLOSE(5, "关闭",""),
|
;
|
// 成员变量
|
private String name;
|
private String info;
|
private int key;
|
|
// 构造方法
|
ApplyChangeLogStatus(int key, String name,String info) {
|
this.name = name;
|
this.info = info;
|
this.key = key;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (ApplyChangeLogStatus c : ApplyChangeLogStatus.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
public static String getInfo(int index) {
|
for (ApplyChangeLogStatus c : ApplyChangeLogStatus.values()) {
|
if (c.getKey() == index) {
|
return c.info;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getInfo() {
|
return info;
|
}
|
|
public void setInfo(String info) {
|
this.info = info;
|
}
|
|
}
|
|
|
|
public enum ProjectRecord {
|
|
COM_EDITING(0, "企业保存数据", "由 ${param2} ${param3}保存成功，当前进度为 【${param4}】"),
|
COM_SUBMIT(1, "企业提交数据", "由 ${param2} ${param3}提交成功，当前进度为 【${param4}】"),
|
XQ_CHECK_PASS(2, "县区审核通过", "由 ${param2} ${param3}审核通过，审核备注为：${param5}；当前进度为 【${param4}】"),
|
XQ_CHECK_EDIT(3, "县区审核退回修改", "由 ${param2} ${param3}审核退回修改，审核备注为：${param5}；当前进度为 【${param4}】"),
|
XQ_CHECK_BACK(4, "县区审核驳回", "由 ${param2} ${param3}审核驳回，审核备注为：${param5}；当前进度为 审核驳回，流程结束。"),
|
COM_SELECT_SO(5, "企业选择服务机构", "由 ${param2} ${param3}选择 ${param5}，当前进度为 【${param4}】"),
|
SO_PASS(6, "服务机构确认服务", "由 ${param2} ${param3}确认服务，当前进度为 【${param4}】"),
|
SO_BACK(7, "服务机构拒绝服务", "由 ${param2} ${param3}拒绝服务，当前进度为 【${param4}】"),
|
SJ_SELECT_SO(8, "市局分配服务机构", "由 ${param2} ${param3}完成分配服务机构，当前进度为 【${param4}】"),
|
SD_SELECT_SO(9, "综合服务单位分配服务机构", "由 ${param2} ${param3}完成分配服务机构，当前进度为 【${param4}】"),
|
SJ_RESELECT_SO(10, "市局重新分配服务机构", "由 ${param2} ${param3}完成重新分配服务机构，当前进度为 【${param4}】"),
|
SD_RESELECT_SO(11, "综合服务单位重新分配服务机构", "由 ${param2} ${param3}完成重新分配服务机构，当前进度为 【${param4}】"),
|
SO_SERVICE_UPLOAD(12, "服务机构上传服务数据", "由 ${param2} ${param3}完成上传服务数据，当前进度为 【${param4}】"),
|
SO_DONE_SERVICE(13, "服务机构完成服务", "由 ${param2} ${param3}完成服务，当前进度为 【${param4}】"),
|
SJ_SELECT_EXPERT(14, "市局分配评分专家", "由 ${param2} ${param3}完成分配评分专家，当前进度为 【${param4}】"),
|
SD_SELECT_EXPERT(15, "综合服务单位分配评分专家", "由 ${param2} ${param3}完成分配评分专家，当前进度为 【${param4}】"),
|
SJ_RESELECT_EXPERT(16, "市局重新分配评分专家", "由 ${param2} ${param3}完成重新分配评分专家，当前进度为 【${param4}】"),
|
SD_RESELECT_EXPERT(17, "综合服务单位重新分配评分专家", "由 ${param2} ${param3}完成重新分配评分专家，当前进度为 【${param4}】"),
|
EXPERT_SCORE(18, "专家上传评分", "由 ${param2} ${param3}完成评分，当前进度为 【${param4}】"),
|
SD_SERVICE_UPLOAD(19, "综合服务单位上传诊断资料", "由 ${param2} ${param3}完成上传诊断资料，当前进度为 【${param4}】"),
|
SD_BACK_DONE(20, "综合服务单位退回修改", "由 ${param2} ${param3}退回修改，当前进度为 【${param4}】"),
|
|
SO_BACK_SUBMIT(21 , "服务机构修改完成服务", "由 ${param2} ${param3}完成服务，当前进度为 【${param4}】"),
|
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
private String noteinfo;// 描述
|
|
// 构造方法
|
ProjectRecord(int key, String name, String noteinfo) {
|
this.name = name;
|
this.key = key;
|
this.noteinfo = noteinfo;
|
}
|
|
// 普通方法
|
public static String getName(int index) {
|
for (ProjectRecord c : ProjectRecord.values()) {
|
if (c.getKey() == index) {
|
return c.name;
|
}
|
}
|
return null;
|
}
|
|
// 普通方法
|
public static String getInfo(int index) {
|
for (ProjectRecord c : ProjectRecord.values()) {
|
if (c.getKey() == index) {
|
return c.noteinfo;
|
}
|
}
|
return null;
|
}
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
public String getNoteinfo() {
|
return noteinfo;
|
}
|
|
public void setNoteinfo(String noteinfo) {
|
this.noteinfo = noteinfo;
|
}
|
|
public static String getContentWithData(ProjectRecord template, Map<String, String> params){
|
String pattern = "\\$\\{(.+?)\\}";
|
Pattern p = Pattern.compile(pattern);
|
Matcher m = p.matcher(template.noteinfo);
|
StringBuffer sb = new StringBuffer();
|
while (m.find()){
|
String key = m.group(1);
|
String value = params.get(key);
|
m.appendReplacement(sb, value == null ? "" : value);
|
}
|
m.appendTail(sb);
|
return sb.toString();
|
}
|
|
}
|
|
/**
|
* 数据状态枚举
|
*
|
*/
|
public enum Status {
|
|
/** 用户启用禁用枚举值*/
|
ENABLE(0,"正常"),
|
DISABLE(1,"禁用");
|
|
private Integer value;
|
private String des;
|
|
|
Status(Integer value, String des) {
|
this.value = value;
|
this.des = des;
|
}
|
|
public Integer getValue() {
|
return value;
|
}
|
|
public void setValue(Integer value) {
|
this.value = value;
|
}
|
|
public String getDes() {
|
return des;
|
}
|
|
public void setDes(String des) {
|
this.des = des;
|
}
|
}
|
|
|
public enum goodsType {
|
|
/** 用户启用禁用枚举值*/
|
CREATE(0,"自建"),
|
PULL(1,"拉取");
|
|
private Integer value;
|
private String des;
|
|
|
goodsType(Integer value, String des) {
|
this.value = value;
|
this.des = des;
|
}
|
|
public Integer getValue() {
|
return value;
|
}
|
|
public void setValue(Integer value) {
|
this.value = value;
|
}
|
|
public String getDes() {
|
return des;
|
}
|
|
public void setDes(String des) {
|
this.des = des;
|
}
|
}
|
|
|
public enum CompanyType{
|
|
BUSINESS_COMPANYTYPE(0,"企业"),
|
|
SERVICE_COMPANYTYPE(1,"服务机构"),
|
|
ZF_SERVICE_COMPANY(2,"综合服务单位");
|
|
private Integer value;
|
private String des;
|
|
CompanyType(Integer value, String des) {
|
this.value = value;
|
this.des = des;
|
}
|
|
public Integer getValue() {
|
return value;
|
}
|
|
public void setValue(Integer value) {
|
this.value = value;
|
}
|
|
public String getDes() {
|
return des;
|
}
|
|
public void setDes(String des) {
|
this.des = des;
|
}
|
}
|
|
public static File getFileByNetFile(String url,String fileName) {
|
//对本地文件命名
|
File file = null;
|
try {
|
URL urlfile;
|
InputStream inStream = null;
|
OutputStream os = null;
|
try {
|
String tempDir = "C:\\hj\\jars\\temp\\";
|
File f = new File(tempDir);
|
if(!f.exists() ){
|
f.mkdirs();
|
}
|
tempDir += fileName;
|
System.out.println(url+"================="+tempDir);
|
file = new File(tempDir);
|
//下载
|
urlfile = new URL(url);
|
inStream = urlfile.openStream();
|
os = new FileOutputStream(file);
|
int bytesRead = 0;
|
byte[] buffer = new byte[8192];
|
while ((bytesRead = inStream.read(buffer, 0, 8192)) != -1) {
|
os.write(buffer, 0, bytesRead);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
} finally {
|
try {
|
if (null != os) {
|
os.close();
|
}
|
if (null != inStream) {
|
inStream.close();
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
}
|
|
return file;
|
}
|
public static void packFilesToZip(List<File> files, OutputStream os) throws IOException {
|
try {
|
ZipArchiveOutputStream zipOutputStream = new ZipArchiveOutputStream(os);
|
zipOutputStream.setUseZip64(Zip64Mode.AsNeeded);
|
for (File file : files) {
|
if(!file.exists()){
|
System.out.println("===文件不存在======="+file.getPath());
|
continue;
|
}else{
|
System.out.println("===文件存在======="+file.getPath());
|
}
|
ZipArchiveEntry entry = new ZipArchiveEntry(file.getName());
|
zipOutputStream.putArchiveEntry(entry);
|
FileInputStream fileInputStream = new FileInputStream(file);
|
byte[] buffer = new byte[1024];
|
int length;
|
while ((length = fileInputStream.read(buffer)) > 0) {
|
zipOutputStream.write(buffer, 0, length);
|
}
|
zipOutputStream.closeArchiveEntry();
|
zipOutputStream.flush();
|
IoUtil.close(fileInputStream);
|
file.delete();
|
}
|
}catch (Exception e){
|
throw new BusinessException(ResponseStatus.EXPORT_EXCEL_ERROR.getCode(),"对不起，下载压缩文件失败");
|
}finally {
|
if (os != null) {
|
try {
|
os.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
}
|
|
|
|
/**
|
* 减保 总费用
|
* @param solutions
|
* @param fee
|
* @param startTime
|
* @param endTime
|
* @param reduceStartTime
|
* @param reduceEndTime
|
* @return
|
*/
|
public static BigDecimal reduceFee(Solutions solutions,BigDecimal fee,Date startTime ,Date endTime,Date reduceStartTime,Date reduceEndTime){
|
Integer days = DateUtil.daysBetweenDates(reduceEndTime, reduceStartTime) + 1;
|
Integer countDays = DateUtil.daysBetweenDates(endTime, startTime) + 1;
|
Constants.TimeUnit timeUnit = Constants.TimeUnit.getTimeUnit(solutions.getTimeUnit());
|
Constants.InsureCycleUnit insureCycleUnit = Constants.InsureCycleUnit.getInsureCycleUnit(solutions.getInsureCycleUnit());
|
if(solutions.getTimeUnit().equals(solutions.getInsureCycleUnit())){
|
return fee;
|
}else{
|
if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.DAY.getValue())){
|
//天为批改单位
|
return fee.multiply(new BigDecimal(days)).divide(new BigDecimal(countDays),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_MONTH.getValue())) {
|
//半月为批改单位
|
BigDecimal cycle = new BigDecimal(days).divide(insureCycleUnit.getDays(),0,RoundingMode.CEILING);
|
//根据投保周期 定义的 每个周期 = X个 半月周期 进行计算
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数
|
return fee.multiply(cycle).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.MONTH.getValue())) {
|
//月份为批改单位
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(reduceEndTime,reduceStartTime));
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 2
|
return fee.multiply(cycle).multiply(new BigDecimal(2)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.QUARTER.getValue())) {
|
//季度为批改单位
|
//查询产生费用总月份
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(reduceEndTime,reduceStartTime));
|
//转换为 总季度
|
cycle = cycle.divide(new BigDecimal(3),0,RoundingMode.CEILING);
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(cycle).multiply(new BigDecimal(6)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_YEAR.getValue())) {
|
//半年为批改单位
|
//查询产生费用总月份
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(reduceEndTime,reduceStartTime));
|
//转换为 半年
|
cycle = cycle.divide(new BigDecimal(6),0,RoundingMode.CEILING);
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(cycle).multiply(new BigDecimal(12)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"方案配置错误");
|
}
|
}
|
}
|
|
/**
|
* 加保业务 根据方案计算总费用
|
* @param solutions
|
* @param startTime
|
* @param endTime
|
* @param newStartTime
|
* @return
|
*/
|
public static BigDecimal addFee(Solutions solutions,BigDecimal fee,Date startTime ,Date endTime,Date newStartTime,Date newEndTime){
|
Integer days = DateUtil.daysBetweenDates(newEndTime, newStartTime) + 1;
|
Integer countDays = DateUtil.daysBetweenDates(endTime, startTime) + 1;
|
Constants.TimeUnit timeUnit = Constants.TimeUnit.getTimeUnit(solutions.getTimeUnit());
|
Constants.InsureCycleUnit insureCycleUnit = Constants.InsureCycleUnit.getInsureCycleUnit(solutions.getInsureCycleUnit());
|
if(solutions.getTimeUnit().equals(solutions.getInsureCycleUnit())){
|
return fee;
|
}else{
|
if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.DAY.getValue())){
|
//天为批改单位
|
return fee.multiply(new BigDecimal(days)).divide(new BigDecimal(countDays),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_MONTH.getValue())) {
|
//半月为批改单位
|
BigDecimal cycle = new BigDecimal(days).divide(insureCycleUnit.getDays(),0,RoundingMode.CEILING);
|
//根据投保周期 定义的 每个周期 = X个 半月周期 进行计算
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数
|
return fee.multiply(cycle).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.MONTH.getValue())) {
|
//月份为批改单位
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(newEndTime,newStartTime));
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 2
|
return fee.multiply(cycle).multiply(new BigDecimal(2)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.QUARTER.getValue())) {
|
//季度为批改单位
|
//查询产生费用总月份
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(newEndTime,newStartTime));
|
//转换为 总季度
|
cycle = cycle.divide(new BigDecimal(3),0,RoundingMode.CEILING);
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(cycle).multiply(new BigDecimal(6)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_YEAR.getValue())) {
|
//半年为批改单位
|
//查询产生费用总月份
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(newEndTime,newStartTime));
|
//转换为 半年
|
cycle = cycle.divide(new BigDecimal(6),0,RoundingMode.CEILING);
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(cycle).multiply(new BigDecimal(12)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"方案配置错误");
|
}
|
}
|
}
|
|
|
|
/**
|
* 计算已产生费用
|
* @param solutions
|
* @param fee
|
* @param startTime
|
* @param endTime
|
* @return
|
*/
|
public static BigDecimal produceFee(Solutions solutions,BigDecimal fee,Date startTime ,Date endTime,Date produceStartTime){
|
//超出天数
|
Integer days = DateUtil.daysBetweenDates(DateUtil.getMontageDate(new Date(), 2), produceStartTime) + 1;
|
Integer countDays = DateUtil.daysBetweenDates(endTime, startTime) + 1;
|
Constants.TimeUnit timeUnit = Constants.TimeUnit.getTimeUnit(solutions.getTimeUnit());
|
Constants.InsureCycleUnit insureCycleUnit = Constants.InsureCycleUnit.getInsureCycleUnit(solutions.getInsureCycleUnit());
|
if(solutions.getTimeUnit().equals(solutions.getInsureCycleUnit())){
|
return fee;
|
}else{
|
if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.DAY.getValue())){
|
//天为批改单位
|
return fee.multiply(new BigDecimal(days)).divide(new BigDecimal(countDays),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_MONTH.getValue())) {
|
//半月为批改单位
|
BigDecimal cycle = new BigDecimal(days).divide(insureCycleUnit.getDays(),0,RoundingMode.CEILING);
|
//根据投保周期 定义的 每个周期 = X个 半月周期 进行计算
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数
|
return fee.multiply(cycle).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.MONTH.getValue())) {
|
//月份为批改单位
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(new Date(),startTime));
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 2
|
return fee.multiply(cycle).multiply(new BigDecimal(2)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.QUARTER.getValue())) {
|
//季度为批改单位
|
//查询产生费用总月份
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(new Date(),startTime));
|
//转换为 总季度
|
cycle = cycle.divide(new BigDecimal(3),0,RoundingMode.CEILING);
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(cycle).multiply(new BigDecimal(6)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_YEAR.getValue())) {
|
//半年为批改单位
|
//查询产生费用总月份
|
BigDecimal cycle = new BigDecimal(DateUtil.getDifferenceMonths(new Date(),startTime));
|
//转换为 半年
|
cycle = cycle.divide(new BigDecimal(6),0,RoundingMode.CEILING);
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(cycle).multiply(new BigDecimal(12)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"方案配置错误");
|
}
|
}
|
}
|
|
public static BigDecimal singleCycleFee(Solutions solutions,Date startTime ,Date endTime){
|
Integer countDays = DateUtil.daysBetweenDates(endTime, startTime) + 1;
|
Constants.TimeUnit timeUnit = Constants.TimeUnit.getTimeUnit(solutions.getTimeUnit());
|
BigDecimal fee = solutions.getPrice();
|
if(solutions.getTimeUnit().equals(solutions.getInsureCycleUnit())){
|
return fee;
|
}else{
|
if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.DAY.getValue())){
|
//天为批改单位
|
return fee.divide(new BigDecimal(countDays),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_MONTH.getValue())) {
|
//根据投保周期 定义的 每个周期 = X个 半月周期 进行计算
|
// 总金额 / 投保周期定义的 半月周期数
|
return fee.divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.MONTH.getValue())) {
|
// 总金额 / 投保周期定义的 半月周期数 * 2
|
return fee.multiply(new BigDecimal(2)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.QUARTER.getValue())) {
|
//季度为批改单位
|
// 总金额 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(new BigDecimal(6)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else if(solutions.getInsureCycleUnit().equals(Constants.InsureCycleUnit.HALF_YEAR.getValue())) {
|
//半年为批改单位
|
// 总金额 * 产生费用的周期 / 投保周期定义的 半月周期数 * 6
|
return fee.multiply(new BigDecimal(12)).divide(new BigDecimal(timeUnit.getCoefficient()),6, RoundingMode.HALF_UP);
|
}else {
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"方案配置错误");
|
}
|
}
|
}
|
|
public static BigDecimal getTwoPoint(BigDecimal bigDecimal){
|
if(Objects.isNull(bigDecimal)){
|
return BigDecimal.ZERO;
|
}
|
if(BigDecimal.ZERO.compareTo(bigDecimal) == 0){
|
return BigDecimal.ZERO;
|
}
|
return bigDecimal.setScale(2,BigDecimal.ROUND_DOWN);
|
}
|
|
|
/**
|
* 赔付项
|
*/
|
public enum compensation{
|
YL_COMPENSATION(0, "医疗理赔",0),
|
WG_COMPENSATION(1, "误工理赔",0),
|
SC_COMPENSATION(2, "伤残理赔",0),
|
SW_COMPENSATION(3, "死亡理赔",0),
|
HSF_FEE(4, "伙食费",1),
|
XY_FEE(5, "续医费",1),
|
YY_FEE(6, "营养费",1),
|
HL_FEE(7, "护理费",1),
|
ZDJB_FEE(8, "重大疾病赔偿金",1),
|
TB_FEE(9, "特别费用",1),
|
ZS_FEE(10, "住宿费",1),
|
JT_FEE(11, "津贴",1),
|
CJ_FEE(12, "残疾赔偿金",1),
|
BFYR_FEE(13, "被抚养人生活费",1),
|
SCF_FEE(14, "丧葬费",1),
|
JSFXJ_FEE(15, "精神抚恤金",1),
|
JD_FEE(16, "鉴定费",1),
|
SS_FEE(17, "诉讼费",1),
|
LS_FEE(18, "律师费",1),
|
TRAFFIC_FEE(19, "交通费",1),
|
CJQJ_FEE(20, "残疾器具费",1),
|
QT_FEE(21, "其他费用",1),
|
ZFPJEYPF_FEE(22, "总发票金额药品费",2),
|
ZL_FEE(23, "诊疗费",2),
|
CL_FEE(24, "材料费",2),
|
ZKJJE_FEE(25, "总扣减金额",2),
|
BFZF_FEE(26, "部分自费",2),
|
QZF_FEE(27, "全自费金额",2),
|
BHL_FEE(28, "不合理费用",2),
|
DSFGF_FEE(29, "第三方给付费用",2),
|
;
|
// 成员变量
|
private String name;
|
private int key;
|
private int type;
|
|
// 构造方法
|
compensation(int key, String name, int type) {
|
this.name = name;
|
this.key = key;
|
this.type = type;
|
}
|
|
|
// get set 方法
|
public String getName() {
|
return name;
|
}
|
|
public void setName(String name) {
|
this.name = name;
|
}
|
|
public int getKey() {
|
return key;
|
}
|
|
public void setKey(int key) {
|
this.key = key;
|
}
|
|
|
public int getType() {
|
return type;
|
}
|
|
public void setType(int type) {
|
this.type = type;
|
}
|
|
}
|
|
public static void initApplyStatus(InsuranceApply apply){
|
apply.setStatusCollect(Constants.InsuranceApplyStatus.getCollectStatus(apply.getStatus()));
|
if(Constants.equalsInteger(apply.getStatus(),Constants.InsuranceApplyStatus.UPLOAD_INSURANCE.getKey())
|
|| Constants.equalsInteger(apply.getStatus(),Constants.InsuranceApplyStatus.WTB_DONE.getKey())){
|
//如果已完成
|
if(apply.getEndTime()==null || System.currentTimeMillis()>apply.getEndTime().getTime()){
|
apply.setStatusCollect(Constants.THREE);//已过期
|
}
|
}
|
Constants.setServiceDays(apply);
|
apply.setStatusInfo(Constants.ApplyCollectStatus.getName(apply.getStatusCollect()));
|
if(Constants.equalsInteger(apply.getStatus(),Constants.InsuranceApplyStatus.UPLOAD_INSURANCE.getKey())
|
|| Constants.equalsInteger(apply.getStatus(),Constants.InsuranceApplyStatus.WTB_DONE.getKey()) ){
|
if(apply.getStartTime().getTime()>System.currentTimeMillis()){
|
apply.setStatusInfo("待生效");
|
}else if(apply.getEndTime().getTime()<System.currentTimeMillis()){
|
apply.setStatusInfo("已过期");
|
}else{
|
apply.setStatusInfo("保障中");
|
}
|
}
|
}
|
|
public static void setServiceDays(InsuranceApply insuranceApply) {
|
//设置在保时长（天数）
|
insuranceApply.setServiceDays(Constants.ZERO);
|
if(insuranceApply.getStatus().equals(Constants.InsuranceApplyStatus.UPLOAD_INSURANCE.getKey())
|
|| insuranceApply.getStatus().equals(Constants.InsuranceApplyStatus.WTB_DONE.getKey())){
|
//如果当前时间大于结束日期 则使用结束日期对比开始日期
|
if(DateUtil.compareDate(new Date(),insuranceApply.getEndTime())>=Constants.ZERO){
|
insuranceApply.setServiceDays(
|
DateUtil.daysBetweenDates(insuranceApply.getEndTime(),insuranceApply.getStartTime())+1
|
);
|
}else if(DateUtil.compareDate(insuranceApply.getStartTime(),new Date())>=Constants.ZERO){
|
//未开始
|
insuranceApply.setServiceDays(Constants.ZERO);
|
}else{
|
insuranceApply.setServiceDays(DateUtil.daysBetweenDates(new Date(),insuranceApply.getStartTime())+1);
|
}
|
}
|
}
|
|
public static ApplyPowerVO getApplyPowerStatic(ApplyPowerDTO applyPowerDTO, InsuranceApply insuranceApply, Solutions solutions){
|
if(Objects.isNull(applyPowerDTO)
|
|| Objects.isNull(applyPowerDTO.getApplyId())){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"参数错误");
|
}
|
if(Objects.isNull(applyPowerDTO.getBeginDate())){
|
applyPowerDTO.setBeginDate(new Date());
|
}
|
ApplyPowerVO applyPowerVO = new ApplyPowerVO();
|
//获取方案 结束时间
|
Date endTime = insuranceApply.getEndTime();
|
//查询当前去加保的开始日期 yyyy-MM-dd HH:mm:ss 2024-10-29 00:00:00
|
Date addStartDate = DateUtil.getMontageDate(
|
DateUtil.afterDateByType(applyPowerDTO.getBeginDate(),Constants.ZERO,solutions.getAddValidDays()),
|
1
|
);
|
applyPowerVO.setAddStartDate(addStartDate);
|
//加保生效日期大于 保单结束日期 则不可以进行加保
|
if(addStartDate.getTime()>=endTime.getTime()){
|
applyPowerVO.setAddTrue(Constants.ONE);
|
}else{
|
applyPowerVO.setAddTrue(Constants.ZERO);
|
}
|
//查询当前去减保的开始日期 yyyy-MM-dd HH:mm:ss 2024-10-29 00:00:00
|
Date delStartDate = DateUtil.getMontageDate(
|
DateUtil.afterDateByType(applyPowerDTO.getBeginDate(),Constants.ZERO,solutions.getAddValidDays()),
|
1
|
);
|
applyPowerVO.setDelStartDate(delStartDate);
|
//加保生效日期大于 保单结束日期 则不可以进行减保
|
if(delStartDate.getTime()>=endTime.getTime()){
|
applyPowerVO.setDelTrue(Constants.ONE);
|
}else{
|
applyPowerVO.setDelTrue(Constants.ZERO);
|
}
|
return applyPowerVO;
|
}
|
|
|
}
|
