productDev/yunyibao.git

			@@ -1,21 +1,77 @@
			package com.doumee.core.utils;

			import cn.hutool.core.io.IoUtil;
			import cn.hutool.core.util.IdcardUtil;
			import com.aliyun.auth.credentials.Credential;
			import com.aliyun.auth.credentials.provider.StaticCredentialProvider;
			import com.aliyun.sdk.service.cloudauth20190307.AsyncClient;
			import com.aliyun.sdk.service.cloudauth20190307.models.Id2MetaVerifyRequest;
			import com.aliyun.sdk.service.cloudauth20190307.models.Id2MetaVerifyResponse;
			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 com.google.gson.Gson;
			import darabonba.core.client.ClientOverrideConfiguration;
			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 java.io.File;
			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.concurrent.CompletableFuture;
			import java.util.regex.Matcher;
			import java.util.regex.Pattern;

			import com.aliyun.auth.credentials.Credential;
			import com.aliyun.auth.credentials.provider.StaticCredentialProvider;
			import com.aliyun.core.http.HttpClient;
			import com.aliyun.core.http.HttpMethod;
			import com.aliyun.core.http.ProxyOptions;
			import com.aliyun.httpcomponent.httpclient.ApacheAsyncHttpClientBuilder;
			import com.aliyun.sdk.service.cloudauth20190307.models.*;
			import com.aliyun.sdk.service.cloudauth20190307.*;
			import com.google.gson.Gson;
			import darabonba.core.RequestConfiguration;
			import darabonba.core.client.ClientOverrideConfiguration;
			import darabonba.core.utils.CommonUtil;
			import darabonba.core.TeaPair;

			//import javax.net.ssl.KeyManager;
			//import javax.net.ssl.X509TrustManager;
			import java.net.InetSocketAddress;
			import java.time.Duration;
			import java.util.*;
			import java.util.concurrent.CompletableFuture;
			import java.io.*;

			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
			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";
			@@ -31,12 +87,20 @@
			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";//本地文件访问地址配置
			@@ -66,7 +130,130 @@
			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后台导入
			*/
			@@ -93,6 +280,15 @@
			// 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);
			@@ -125,6 +321,277 @@
			}
			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 已完成退回修改
			@@ -352,8 +819,33 @@
			BD_APPLY_PDF(8, "保单申请表PDF ", "保单申请表PDF "),
			BD_SIGNED_PDF(9, "签署后保单申请表PDF", "签署后保单申请表PDF"),
			COM_SING_IMG(10, "企业印章", "企业印章"),
			BD_DONE_PDF(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, "补充材料", "补充材料"),

			;
			// 成员变量
			@@ -370,7 +862,7 @@

			// 普通方法
			public static String getName(int index) {
			for (ProjectRecord c : ProjectRecord.values()) {
			for (MultiFile c : MultiFile.values()) {
			if (c.getKey() == index) {
			return c.name;
			}
			@@ -380,7 +872,7 @@

			// 普通方法
			public static String getInfo(int index) {
			for (ProjectRecord c : ProjectRecord.values()) {
			for (MultiFile c : MultiFile.values()) {
			if (c.getKey() == index) {
			return c.noteinfo;
			}
			@@ -470,10 +962,7 @@

			}

			public static void main(String[] args) {

			System.out.println("hello&&devicenumber=22110002&&uuid=1e52008fb8ff\n".length());
			}
			/**
			* 用户类型 0系统用户 1企业用户 2服务机构管理员 3服务机构子账号 4综合服务单位管理员 5综合服务单位子账号 6专家 7县区用户 8市局用户
			*/
			@@ -481,7 +970,7 @@

			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)),
			ZHUBO(2, "商户", "商户",Arrays.asList(-1)),
			;
			// 成员变量
			private String name;
			@@ -603,32 +1092,39 @@

			}

			public enum ApplyCollectStatus {
			DSP(0, "待审核"),
			DCD(1, "待出单"),
			BZZ(2, "保障中"),
			YGQ(3, "已过期"),
			YTH(4, "已退回"),
			THSQZ(5, "申请退回"),
			YGB(6, "已关闭"),
			DQYQZ(7, "待签署"),

			public enum ApplyLogType {
			UPLOAD(0, "提交投保申请"),
			PLATFORM_RETURN(1, "平台退回保单"),
			WAIT_SIGNATURE(2, "已上传代签申请表待企业签章"),
			SIGNATURE(3, "已签章待上传保险单"),
			FAIL_RETURN(4, "保单出具失败退回"),
			UPLOAD_INSURANCE(5, "已上传保单"),
			COMPANY_APPLY_RETURN(6, "企业申请退回"),
			COMPANY_APPLY_CLOSE(7, "企业关闭申请"),
			PLATFORM_AGREE(8, "平台同意企业退回申请"),
			PLATFORM_UN_AGREE(9, "平台拒绝企业退回申请"),
			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;

			// 构造方法
			ApplyLogType(int key, String name) {
			ApplyCollectStatus(int key, String name) {
			this.name = name;
			this.key = key;
			}

			// 普通方法
			public static String getName(int index) {
			for (ApplyLogType c : ApplyLogType.values()) {
			for (ApplyCollectStatus c : ApplyCollectStatus.values()) {
			if (c.getKey() == index) {
			return c.name;
			}
			@@ -655,30 +1151,802 @@

			}


			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, "提交投保申请"),
			PLATFORM_RETURN(1, "平台退回保单"),
			WAIT_SIGNATURE(2, "已上传代签申请表待企业签章"),
			SIGNATURE(3, "已签章待上传保险单"),
			FAIL_RETURN(4, "保单出具失败退回"),
			UPLOAD_INSURANCE(5, "已上传保单"),
			COMPANY_APPLY_RETURN(6, "企业申请退回"),
			COMPANY_APPLY_CLOSE(7, "企业关闭申请"),
			CLOSE(8, "订单关闭"),
			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;

			// 构造方法
			InsuranceApplyStatus(int key, String name) {
			ApplyChangeStatus(int key, String name) {
			this.name = name;
			this.key = key;
			}

			// 普通方法
			public static String getName(int index) {
			for (ApplyLogType c : ApplyLogType.values()) {
			for (InsuranceApplyStatus c : InsuranceApplyStatus.values()) {
			if (c.getKey() == index) {
			return c.name;
			}
			@@ -701,6 +1969,359 @@

			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;
			}

			}
			@@ -909,4 +2530,584 @@
			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;
			}

			public static void main(String[] args) throws Exception {
			// 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\"}");

			// Constants constants = new Constants();
			// constants.test("LTAI5tRBTeQKoeUs41yVdW4F","rYHEOw2l7AooAOz88JSZ2aSQxfQQTS","340621199310134818","任康");



			StaticCredentialProvider provider = StaticCredentialProvider.create(Credential.builder()
			// Please ensure that the environment variables ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set.
			.accessKeyId("LTAI5tKzCBb4CU1bwUfSoakP")
			.accessKeySecret("7HNswKVfXJkSmiQDTT5wL3KjH1oS16")
			//.securityToken(System.getenv("ALIBABA_CLOUD_SECURITY_TOKEN")) // use STS token
			.build());

			// Configure the Client
			AsyncClient client = AsyncClient.builder()
			.region("cn-hangzhou") // Region ID
			//.httpClient(httpClient) // Use the configured HttpClient, otherwise use the default HttpClient (Apache HttpClient)
			.credentialsProvider(provider)
			//.serviceConfiguration(Configuration.create()) // Service-level configuration
			// Client-level configuration rewrite, can set Endpoint, Http request parameters, etc.
			.overrideConfiguration(
			ClientOverrideConfiguration.create()
			// Endpoint 请参考 https://api.aliyun.com/product/Cloudauth
			.setEndpointOverride("cloudauth.aliyuncs.com")
			//.setConnectTimeout(Duration.ofSeconds(30))
			)
			.build();

			// Parameter settings for API request
			Id2MetaVerifyRequest id2MetaVerifyRequest = Id2MetaVerifyRequest.builder()
			.identifyNum("340621199310134818")
			.userName("任康")
			.paramType("normal")
			// Request-level configuration rewrite, can set Http request parameters, etc.
			// .requestConfiguration(RequestConfiguration.create().setHttpHeaders(new HttpHeaders()))
			.build();

			// Asynchronously get the return value of the API request
			CompletableFuture<Id2MetaVerifyResponse> response = client.id2MetaVerify(id2MetaVerifyRequest);
			// Synchronously get the return value of the API request
			Id2MetaVerifyResponse resp = response.get();
			System.out.println(new Gson().toJson(resp));
			// Asynchronous processing of return values
			/*response.thenAccept(resp -> {
			System.out.println(new Gson().toJson(resp));
			}).exceptionally(throwable -> { // Handling exceptions
			System.out.println(throwable.getMessage());
			return null;
			});*/

			// Finally, close the client
			client.close();
			}

			public void test(String accessKeyId,String accessKeySecret,String identifyNum,String name) throws Exception{

			// HttpClient Configuration
			/*HttpClient httpClient = new ApacheAsyncHttpClientBuilder()
			.connectionTimeout(Duration.ofSeconds(10)) // Set the connection timeout time, the default is 10 seconds
			.responseTimeout(Duration.ofSeconds(10)) // Set the response timeout time, the default is 20 seconds
			.maxConnections(128) // Set the connection pool size
			.maxIdleTimeOut(Duration.ofSeconds(50)) // Set the connection pool timeout, the default is 30 seconds
			// Configure the proxy
			.proxy(new ProxyOptions(ProxyOptions.Type.HTTP, new InetSocketAddress("<your-proxy-hostname>", 9001))
			.setCredentials("<your-proxy-username>", "<your-proxy-password>"))
			// If it is an https connection, you need to configure the certificate, or ignore the certificate(.ignoreSSL(true))
			.x509TrustManagers(new X509TrustManager[]{})
			.keyManagers(new KeyManager[]{})
			.ignoreSSL(false)
			.build();*/

			// Configure Credentials authentication information, including ak, secret, token
			StaticCredentialProvider provider = StaticCredentialProvider.create(Credential.builder()
			// Please ensure that the environment variables ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set.
			.accessKeyId(System.getenv(accessKeyId))
			.accessKeySecret(System.getenv(accessKeySecret))
			//.securityToken(System.getenv("ALIBABA_CLOUD_SECURITY_TOKEN")) // use STS token
			.build());

			// Configure the Client
			AsyncClient client = AsyncClient.builder()
			.region("cn-hangzhou") // Region ID
			//.httpClient(httpClient) // Use the configured HttpClient, otherwise use the default HttpClient (Apache HttpClient)
			.credentialsProvider(provider)
			//.serviceConfiguration(Configuration.create()) // Service-level configuration
			// Client-level configuration rewrite, can set Endpoint, Http request parameters, etc.
			.overrideConfiguration(
			ClientOverrideConfiguration.create()
			// Endpoint 请参考 https://api.aliyun.com/product/Cloudauth
			.setEndpointOverride("cloudauth.aliyuncs.com")
			//.setConnectTimeout(Duration.ofSeconds(30))
			)
			.build();

			// Parameter settings for API request
			Id2MetaVerifyRequest id2MetaVerifyRequest = Id2MetaVerifyRequest.builder()
			.identifyNum(identifyNum)
			.userName(name)
			.paramType("normal")
			// Request-level configuration rewrite, can set Http request parameters, etc.
			// .requestConfiguration(RequestConfiguration.create().setHttpHeaders(new HttpHeaders()))
			.build();

			// Asynchronously get the return value of the API request
			CompletableFuture<Id2MetaVerifyResponse> response = client.id2MetaVerify(id2MetaVerifyRequest);
			// Synchronously get the return value of the API request
			Id2MetaVerifyResponse resp = response.get();
			System.out.println(new Gson().toJson(resp));
			// Asynchronous processing of return values
			/*response.thenAccept(resp -> {
			System.out.println(new Gson().toJson(resp));
			}).exceptionally(throwable -> { // Handling exceptions
			System.out.println(throwable.getMessage());
			return null;
			});*/

			// Finally, close the client
			client.close();

			}






			}