Skip to content

傅伟强-富德 / test

Go to a project
Commit 3dff8c8d by 傅伟强-富德
Options

Add new file

1 parent b9fc1e21
Inline Side-by-side
Showing with 1811 additions and 0 deletions
ResultCheckServiceImpl 0 → 100644
package com.funde.gras.allot.service.impl;
import java.util.*;
import java.util.stream.Collectors;
import com.funde.gras.api.utils.*;
import org.springframework.beans.factory.annotation.Autowired;
import com.alibaba.dubbo.config.annotation.Reference;
import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.funde.gras.api.common.MyConstant;
import com.funde.gras.api.common.PaasHttpRequest;
import com.funde.gras.api.common.PageInfo;
import com.funde.gras.api.domain.*;
import com.funde.gras.api.service.*;
/**
* ClassName: ResultCheckServiceImpl
* Description: []
* Date: 2018年8月3日 下午4:46:39
*
* @author ASUS
*/
@Service(version = "1.0.0", timeout = 15000000, interfaceName = "com.funde.gras.api.service.ResultCheckService")
public class ResultCheckServiceImpl implements ResultCheckService {
private Integer failedCount = 0;
private final String SUCCESSFUL_FLAG = "1";
private final String FAILED_FLAG = "2";
private Integer succesCount = 0;
@Reference(version = "1.0.0")
private OracleGrasSysTempService sysTempService;
@Reference(version = "1.0.0")
private OracleBranchInfoService branchInfoService;
@Reference(version = "1.0.0")
private OracleRuleDealService ruleDealService;
@Reference(version = "1.0.0")
private OraclePolicyPremInfoService premInfoService;
@Reference(version = "1.0.0")
private OracleGrasAssignBatchRecordService batchRecordService;
@Reference(version = "1.0.0")
private OraclePolicyService policyService;
@Reference(version = "1.0.0")
private OracleGrasAssignFailedRecordService failedRecordService;
//@Reference(version = "1.0.0")
//private FallingMapService mapService;
@Reference(version = "1.0.0")
private OracleStaffInfoService staffInfoService;
@Reference(version = "1.0.0")
private OracleEmpStatusService oracleEmpStatusService;
@Reference(version = "1.0.0")
private OracleGrasSysTempService tempService;
@Reference(version = "1.0.0")
private OracleGrasSysDataTransService transService;
@Reference(version = "1.0.0")
private OracleRenewalStaffInfoOtherService otherService;
@Reference(version = "1.0.0")
private OracleRnServicerInfoService servicerInfoService;
@Reference(version = "1.0.0")
private OracleRNPolicyServicerChgRecordService changeService;
@Reference(version = "1.0.0")
private OracleLapsePolicy lapsePolicyService;
@Reference(version = "1.0.0")
private OraclePolicyProductService policyProductService;
@Reference(version = "1.0.0")
private OraclePolicyPremInfoService policyPremInfoService;
@Reference(version = "1.0.0")
private ElasticSearchService elasticSearchService;
@Autowired
private PaasHttpRequest paasHttpRequest;
private LogUtils logUtils = new LogUtils(getClass());
@Override
public List<GrasSysTemp> selectByBranchCode(String branchCode) {
return sysTempService.selectByBranchCode(branchCode);
}
/***
* MethodName: [queryStaffs]
* Description: [分单结果检查查询查询保单服务人员]
* @param: [branchCode, flag]
* @return: java.util.List<com.funde.gras.api.domain.StaffInfo>
*/
@Override
public PageInfo<StaffInfo> queryStaffs(String branchCode, String channelType, String flag, Integer pageNum, Integer pageSize,String month) {
Integer total = 0;
List<StaffInfo> staffs = new ArrayList<>();
String nowMonth = DateUtil.getPerFirstDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
String nextMonth = DateUtil.getPerLastDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
//recordList 符合条件的全部的流水号
List<String> recordList = batchRecordService.batchRecordsByBrancodeAndMoth(branchCode, nowMonth, nextMonth);
List<String> channelTypeList = Arrays.asList(channelType.split(","));
if (recordList!=null && recordList.size()>0) {
//已分单业务员 1为前端传输的标记 意为已分单
if (flag != null && !flag.equals("") && flag.equals(SUCCESSFUL_FLAG)) {
staffs = sysTempService.queryHavePolicyStaffs(branchCode, channelTypeList, pageNum, pageSize, recordList);
total = sysTempService.countServicersForPageInfoSuccess(branchCode, channelTypeList, recordList);
//未分单业务员 2为前端传输的标记 意为未分单
} else if (flag != null && !flag.equals("") && flag.equals(FAILED_FLAG)) {
staffs = sysTempService.queryHaveNoPolicyStaffs(branchCode, channelTypeList, pageNum, pageSize, recordList);
total = sysTempService.countServicersForPageInfoFailed(branchCode, channelTypeList, recordList);
}
}
return new PageInfo<StaffInfo>(pageNum, pageSize, total, staffs);
}
/***
* MethodName: [queryPolicy]
* Description: [方法注释]
* @param: [flag, branchCode, channelType, month]
* @return: java.util.List<com.alibaba.fastjson.JSONObject>
*/
@Override
public PageInfo<Map<String,String>> queryPolicy(String flag, String branchCode, String month, Integer pageNum, Integer pageSize, List channelType) {
String nowMonth = null;
String nextMonth = null;
Integer total = 0;
List<Map<String,String>> resultList = new ArrayList<>();
if (month != null && !"".equals(month)) {
nowMonth = DateUtil.getPerFirstDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
nextMonth = DateUtil.getPerLastDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
}
//recordList 符合条件的全部的流水号
List<String> recordList = batchRecordService.batchRecordsByBrancodeAndMoth(branchCode, nowMonth, nextMonth);
//查询不到机构对应的分单记录流水号
if (recordList == null || recordList.size() == 0) {
// JSONObject noresultJSON = new JSONObject();
Map<String,String> noresultMap = new HashMap<>();
noresultMap.put("result", "没有该机构的分单记录");
resultList.add(noresultMap);
return new PageInfo<Map<String,String>>(0, pageSize, 0, resultList);
} else {
if (flag.equals(SUCCESSFUL_FLAG)) {
resultList = sysTempService.querySuccesPolicy(recordList,branchCode, pageNum, pageSize, channelType);
total = sysTempService.countPolicyForPageInfoSuccess(recordList, branchCode,channelType);
} else if (flag.equals(FAILED_FLAG)) {
resultList = sysTempService.queryFailedPolicy(recordList, branchCode, pageNum, pageSize, channelType);
total = sysTempService.countPolicyForPageInfoFailed(recordList, branchCode, channelType);
}
}
return new PageInfo<Map<String,String>>(pageNum, pageSize, total, resultList);
}
/***
* MethodName: [getCount]
* Description: [方法注释]
* @param: [branchCode, channelType, month]
* @return: java.util.Map<java.lang.String,java.lang.Integer>
*/
@Override
public Map<String, Integer> getCount(String branchCode, String month, List channelType) {
Map<String, Integer> resultMap = new HashMap<>();
String nowMonth = null;
String nextMonth = null;
if (month != null && !"".equals(month)) {
// Map<String, String> allotMonth = DateUtil.allotMonth(month);
//起始日
// nowMonth = allotMonth.get("nowMonth");
nowMonth = DateUtil.getPerFirstDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
//截止日
// nextMonth = allotMonth.get("nextMonth");
nextMonth = DateUtil.getPerLastDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
}
//分单批次编号组
List<String> batchRecordsList = batchRecordService.batchRecordsByBrancodeAndMoth(branchCode, nowMonth, nextMonth);
if (batchRecordsList != null && batchRecordsList.size() != 0) {
failedCount = sysTempService.getCountForFailed(batchRecordsList, channelType);
succesCount = sysTempService.getCountForSuccess(batchRecordsList, channelType);
}
resultMap.put("success", succesCount);
resultMap.put("failed", failedCount);
resultMap.put("count", succesCount + failedCount);
succesCount = 0;
failedCount = 0;
return resultMap;
}
@Override
public Map<String, Integer> getCountForManu(String batchSeq) {
Map<String, Integer> resultMap = new HashMap<>();
String channelType = null;
//成功分单总数
Integer succesCount = sysTempService.getSuccesCount(batchSeq, channelType, null);
if (succesCount == null) {
succesCount = 0;
}
//失败分单总数
Integer failedCount = sysTempService.getFailedCount(batchSeq, channelType, null);
if (succesCount == null) {
succesCount = 0;
}
resultMap.put("success", succesCount);
resultMap.put("failed", failedCount);
resultMap.put("count", succesCount + failedCount);
return resultMap;
}
/**
* 校验保单和服务人员
* @param condition
* @param branchCode
* @param policyList
* @return
*/
@Override
public JSONObject checkPolicAndServicer(String condition,String branchCode, List<JSONObject> policyList){
List<Map<String,String>> policyFailedList = new ArrayList<>();
Map<String,String> policyFailedMap = null;
List<Map<String,String>> policySuccessList = new ArrayList<>();
Map<String,String> policySuccessMap = null;
JSONObject resultJson = new JSONObject();
List<String> policyNoList = new ArrayList<>();
try {
//所有能进行分单的保单号
//传入的EXCEL中错误的保单的信息
Set<String> failedList = new HashSet<>();
// List<String> policies = checkPolicyNo(branchCode);
//以下这个是符合条件的能进行分单的保单号的数组
//对保单号与续收人员逐一进行核对
for (JSONObject policyJson : policyList) {
//保单号
String policyNo = policyJson.getString("policyNo");
//服务人员编号
String servicerNo = policyJson.getString("servicerNo");
//判断文件不为空
if (policyList == null || policyList.size() == 0) {
resultJson.put("文件不能为空", failedList);
return resultJson;
}
//产品层的保单信息
List<PolicyProduct> policyProducts = policyProductService.selectByPolicyNo(policyNo);
if(policyProducts == null || policyProducts.size() == 0){
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","无效的保单号");
policyFailedList.add(policyFailedMap);
// policyFailedList.add(policyNo+"无效的保单号");
failedList.add(policyNo);
}else {
boolean flag = true;
//应缴件判定
if("1".equals(condition)){
//失效件
}else if("2".equals(condition)){
//失效条件：POS_lapse_policy表中 的lapse_date 到当天不超过两年
PosLapsePolicy posLapsePolicy = null;
for (PolicyProduct policyProduct : policyProducts) {
//保单产品编号
Short prodSeq = policyProduct.getProdSeq();
posLapsePolicy = lapsePolicyService.selectByPolicyNoAndProSeq(policyNo, prodSeq);
if(posLapsePolicy != null){
//失效日期
Date lapseDate = posLapsePolicy.getLapseDate();
//失效原因
String lapseReason = policyProduct.getLapseReason();
//如果不是符合规则的失效原因，就不予操作
boolean contains = MyConstant.LAPSE_POLICIES.contains(lapseReason);
if(contains==true){
//日期要在当天到两年内
Date twoYearsLater = DateUtil.getTwoYearsAgo();
//int fromCompare = lapseDate.compareTo(new Date());
int endCompare = lapseDate.compareTo(twoYearsLater);
if(endCompare == -1){
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","保单失效日期不合要求");
policyFailedList.add(policyFailedMap);
// policyFailedList.add(policyNo + "保单失效日期不合要求");
failedList.add(policyNo);
flag = false;
}
}else {
failedList.add(policyNo);
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","保单渠道不合要求");
policyFailedList.add(policyFailedMap);
// policyFailedList.add(policyNo + "保单渠道不合要求");
flag = false;
}
break;
}
}
if(posLapsePolicy == null) {
failedList.add(policyNo);
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","保单不是规定的失效件");
policyFailedList.add(policyFailedMap);
// policyFailedList.add(policyNo + "保单不是规定的失效件");
flag = false;
}
//缓交件
}else if("3".equals(condition)){
for (PolicyProduct policyProduct : policyProducts) {
//缓交件除了人员信息外的条件是有效状态的长险
String productCode = policyProduct.getProductCode();
boolean contains = MyConstant.ALL_KIND_PROD.contains(productCode);
if(contains == false){
failedList.add(policyNo);
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","保单不是规定的缓交件");
policyFailedList.add(policyFailedMap);
// policyFailedList.add(policyNo + "保单不是规定的缓交件");
flag = false;
}
}
}
//如果保单校验没有问题，执行人员校验
if (flag) {
//服务人员资质确认
StaffInfo staffInfo = staffInfoService.selectByPrimaryKey(servicerNo);
//人员不存在
if (staffInfo == null || "".equals(staffInfo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员不存在");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员不存在");
policyFailedList.add(policyFailedMap);
failedCount += 1;
continue;
} else {
String empStatusCode = staffInfo.getEmpStatusCode();
boolean ifInPosition = empStatusCode.endsWith("01");
//人员资质不是在职
if (!ifInPosition == true) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员已离职");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员已离职");
policyFailedList.add(policyFailedMap);
failedCount += 1;
continue;
}
}
//保单的渠道
String policyChannel = policyService.selectChannelTypeByPolicyNo(policyNo);
//人员的渠道
String empChannelType = staffInfoService.selectChannelTypeByEmpNp(servicerNo);
//保单对应渠道缺失，错误
if (policyChannel == null || "".equals(policyChannel)) {
failedList.add(policyNo);
// policyFailedList.add(policyNo + "无效保单");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "无效保单");
policyFailedList.add(policyFailedMap);
failedCount += 1;
continue;
//保单为个险渠道
} else if (MyConstant.CHANNEL_01.equals(policyChannel)) {
//在当前机构不为总共的情况下，个险保单必须与续收人员在同一三级机构下。
if (!branchCode.equals("86")) {
//员工机构
String branchCodeByEmpNo = staffInfoService.getBranchCodeByEmpNo(servicerNo);
//保单对应机构
String branchCodeByPolicyNo = policyService.selectBranchCodeByPolicyNo(policyNo);
BranchInfo empBranchInfo = branchInfoService.selectByPrimaryKey(branchCodeByEmpNo);
BranchInfo policyBranchInfo = branchInfoService.selectByPrimaryKey(branchCodeByPolicyNo);
String empBranchInfoBranchLevel = empBranchInfo.getBranchLevel();
String policyBranchInfoBranchLevel = policyBranchInfo.getBranchLevel();
//四级机构的处理
//员工机构不是三级机构
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(empBranchInfoBranchLevel)) {
Map paramMap = new HashMap();
paramMap.put("branchCode", branchCodeByEmpNo);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCodeByEmpNo = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//保单所属机构不是三级机构
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(policyBranchInfoBranchLevel)) {
Map paramMap = new HashMap();
paramMap.put("branchCode", branchCodeByPolicyNo);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCodeByPolicyNo = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//两者不是一个三级机构 不通过
if (branchCodeByEmpNo == null || branchCodeByPolicyNo == null || !branchCodeByEmpNo.equals(branchCodeByPolicyNo)) {
// servicerFailedList.add(servicerNo + "人员无权操作此保单（跨机构）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（跨机构）");
policyFailedList.add(policyFailedMap);
failedList.add(policyNo);
continue;
} else {
//个险分几种种情况 1.人员也为个险 2.人员不为个险但是 MARKET_FLAG 为Y 取反例即可 3 人员的职务为续收专员、续收主任、个险兼收、银代兼收 这四种
RenewalStaffInfoOther staffInfoOther = otherService.selectByEmpNo(servicerNo);
//人员的职务
String position = staffInfo.getPosition();
//是否个险兼收人员标示
// assignAbility(servicerFailedList,failedList, policyNo, staffInfoOther, position, servicerNo);
assignAbility(policyFailedList, failedList, policyNo, staffInfoOther, position, servicerNo);
}
//总公司
} else {
//个险分几种种情况 1.人员也为个险 2.人员不为个险但是 MARKET_FLAG 为Y 取反例即可 3 人员的职务为续收专员、续收主任、个险兼收、银代兼收 这四种
RenewalStaffInfoOther staffInfoOther = otherService.selectByEmpNo(servicerNo);
//人员的职务
String position = staffInfo.getPosition();
//是否个险兼收人员标示
// assignAbility(servicerFailedList,failedList, policyNo, staffInfoOther, position, servicerNo);
assignAbility(policyFailedList, failedList, policyNo, staffInfoOther, position, servicerNo);
}
//银代
} else if (MyConstant.CHANNEL_02.equals(policyChannel)) {
//不是总公司
if (!branchCode.equals("86")) {
//银代保单必须与续收人员在同一三级机构下。银代（仅指保单机构为二级机构的保单）
String branchCodeByEmpNo = staffInfoService.getBranchCodeByEmpNo(servicerNo);
//人员所属的上级
String parentBranchByEmpNo = policyService.selectParentBranchByEmpNo(servicerNo);
//保单所属上级公司
String branchCodeByPolicyNo = policyService.selectBranchCodeByPolicyNo(policyNo);
//人员所属上级公司
String policyParentBranch = policyService.selectParentBranchByPolicyNo(policyNo);
//保单所属机构信息
BranchInfo policyBranchInfo = branchInfoService.selectByPrimaryKey(branchCodeByPolicyNo);
//保单属于四级机构
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(policyBranchInfo.getBranchLevel())) {
Map paramMap = new HashMap();
paramMap.put("branchCode", branchCodeByPolicyNo);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCodeByPolicyNo = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//人员所属机构信息
BranchInfo empBranchInfo = branchInfoService.selectByPrimaryKey(branchCodeByEmpNo);
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(empBranchInfo.getBranchLevel())) {
Map paramMap = new HashMap();
paramMap.put("branchCode", branchCodeByEmpNo);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCodeByEmpNo = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//保单上级公司是总公司 本级机构就是二级机构
if (policyParentBranch != null && policyParentBranch.length() == 2) {
//人员也是二级机构的人员
if (parentBranchByEmpNo != null && parentBranchByEmpNo.length() == 2) {
//两者不是一样的
if (!branchCodeByEmpNo.equals(branchCodeByPolicyNo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员无权操作此保单（跨机构）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（跨机构）");
policyFailedList.add(policyFailedMap);
continue;
}
//人员的上级机构就是二级机构
} else if (parentBranchByEmpNo != null && parentBranchByEmpNo.length() == 4) {
if (!branchCodeByEmpNo.equals(parentBranchByEmpNo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员无权操作此保单（跨机构）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（跨机构）");
policyFailedList.add(policyFailedMap);
continue;
}
}
//三级机构保单
} else {
//两者不是一个机构 不通过
if (branchCodeByEmpNo == null || branchCodeByPolicyNo == null || !branchCodeByEmpNo.equals(branchCodeByPolicyNo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（跨机构）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（跨机构）");
policyFailedList.add(policyFailedMap);
continue;
} else {
verifyBankChannel(policyFailedList, failedList, policyNo, servicerNo, staffInfo, empChannelType);
}
}
//总公司
} else {
verifyBankChannel(policyFailedList, failedList, policyNo, servicerNo, staffInfo, empChannelType);
}
//经代
} else if (MyConstant.CHANNEL_03.equals(policyChannel)) {
//不是总公司
if (!branchCode.equals("86")) {
//经代必须与续收人员在同一二级机构下。
String serviceBranch = policyService.selectParentBranchByEmpNo(servicerNo);
//服务人员所属机构信息
BranchInfo servicerBranchInfo = branchInfoService.selectByPrimaryKey(serviceBranch);
//保单机构
String policyBranch = policyService.selectParentBranchByPolicyNo(policyNo);
BranchInfo policyBranchInfo = branchInfoService.selectByPrimaryKey(policyBranch);
//保单属于四级机构
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(policyBranchInfo.getBranchLevel())) {
Map paramMap = new HashMap();
paramMap.put("branchCode", policyBranch);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
policyBranch = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//人员所属机构信息
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(servicerBranchInfo.getBranchLevel())) {
Map paramMap = new HashMap();
paramMap.put("branchCode", serviceBranch);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
serviceBranch = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//上级公司是总公司 当前公司就是二级公司
if (policyBranch.length() == 2) {
policyBranch = policyService.selectBranchCodeByPolicyNo(policyNo);
}
//两者的二级公司不一样
if (serviceBranch == null || policyBranch == null || !serviceBranch.equals(policyBranch)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员无权操作此保单（跨机构）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（跨机构）");
policyFailedList.add(policyFailedMap);
} else {
veryfyEcoChannel(policyFailedList, failedList, policyNo, servicerNo, staffInfo, empChannelType);
}
//总公司无视分公司权限
} else {
veryfyEcoChannel(policyFailedList, failedList, policyNo, servicerNo, staffInfo, empChannelType);
}
//收展
} else if (MyConstant.CHANNEL_07.equals(policyChannel)) {
if (!branchCode.equals("86")) {
//收展保单必须与续收人员在同一三级机构下。
String branchCodeByEmpNo = staffInfoService.getBranchCodeByEmpNo(servicerNo);
String branchCodeByPolicyNo = policyService.selectBranchCodeByPolicyNo(policyNo);
//人员机构信息
BranchInfo empBranchInfo = branchInfoService.selectByPrimaryKey(branchCodeByEmpNo);
//保单机构信息
BranchInfo policyBranchInfo = branchInfoService.selectByPrimaryKey(branchCodeByPolicyNo);
//保单属于四级机构
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(policyBranchInfo.getBranchLevel())) {
Map paramMap = new HashMap();
paramMap.put("branchCode", branchCodeByPolicyNo);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCodeByPolicyNo = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//人员所属机构信息
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(empBranchInfo.getBranchLevel())) {
Map paramMap = new HashMap();
paramMap.put("branchCode", empBranchInfo);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCodeByEmpNo = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//收展保单如保单业务员在职，则不允许调整给其它人。
RNPolicyServiceInfo rnPolicyServiceInfo = servicerInfoService.selectByPolicyNo(policyNo);
String agentNo = rnPolicyServiceInfo.getAgentNo();
StaffInfo staff = staffInfoService.selectByPrimaryKey(agentNo);
//在职
if (staff!=null && staff.getEmpStatusCode().endsWith("01")) {
//两者不同
if (!agentNo.equals(servicerNo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（收展服务人员在职，不能调整）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（收展服务人员在职，不能调整）");
policyFailedList.add(policyFailedMap);
}
}
//两者不是一个机构 不通过
if (branchCodeByEmpNo == null || branchCodeByPolicyNo == null || !branchCodeByEmpNo.equals(branchCodeByPolicyNo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（跨机构）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（跨机构）");
policyFailedList.add(policyFailedMap);
} else {
verifyShouzhanChannel(policyFailedList, failedList, policyNo, servicerNo, staffInfo, empChannelType);
}
//总公司
} else {
//收展保单如保单业务员在职，则不允许调整给其它人。
RNPolicyServiceInfo rnPolicyServiceInfo = servicerInfoService.selectByPolicyNo(policyNo);
String agentNo = rnPolicyServiceInfo.getAgentNo();
StaffInfo staff = staffInfoService.selectByPrimaryKey(agentNo);
//在职
if (staff!=null && staff.getEmpStatusCode().endsWith("01")) {
//两者不同
if (!agentNo.equals(servicerNo)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（收展服务人员在职，不能调整）");
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "人员无权操作此保单（收展服务人员在职，不能调整）");
policyFailedList.add(policyFailedMap);
}
}
verifyShouzhanChannel(policyFailedList, failedList, policyNo, servicerNo, staffInfo, empChannelType);
}
}
}
}
policyNoList.add(policyNo);
}
policyNoList.removeAll(failedList);
//处理保单人员离职交接
policySuccessList=quitAssign(policyNoList,policyList,policyFailedList,failedList);
policyNoList.removeAll(failedList);
resultJson.put("policyFailed", policyFailedList);
resultJson.put("policySuccess",policySuccessList);
resultJson.put("failedPolicyNo",failedList);
resultJson.put("successPolicyNo",policyNoList);
resultJson.put("failed", failedList.size());
resultJson.put("total", policyList.size());
resultJson.put("success", policyList.size() - failedList.size());
}catch (Exception e){
logUtils.error(e);
}
return resultJson;
}
/***
* MethodName: [adjustFailedPolicy]
* Description: 根据传入的excel进行保单人员指定
* @param: [policyList]
* @return: java.util.Map<java.lang.String,java.lang.Integer>
*/
@Override
public JSONObject adjustFailedPolicy(String condition,String branchCode, List<JSONObject> policyList,String user) {
JSONObject resultJson = new JSONObject();
try {
//校验保单和人员
resultJson = checkPolicAndServicer(condition,branchCode,policyList);
//校验成功的保单将存到gras_sys_temp表中
if (resultJson.containsKey("successPolicyNo")){
//获取校验成功保单号
List<String> policyNoList = (List<String> )resultJson.get("successPolicyNo");
//往成功表中添加这些数据
List<GrasSysTemp> sysTempList = new ArrayList<>();
List<Map<String,String>> successList = new ArrayList<>();
//在分单失败表中删除调传入的保单号
if (policyNoList != null && policyNoList.size() != 0) {
// String batchSeq = NumberUtil.random10();
// String batchCode = NumberUtil.random4();
//向批次申请中添加一个信息
// GrasAssignBatchRecord batchRecord = new GrasAssignBatchRecord(batchSeq,"N",NumberUtil.random10(),MyConstant.SYS_USER,new Date(),MyConstant.SYS_USER,new Date());
for (String policyNo : policyNoList) {
//封装参数用于数据库操作
//传入的值并不会很多（最多1000个）
String servicerNo = "";
for (JSONObject inJSON : policyList) {
String inPolicyNo = inJSON.getString("policyNo");
//找到对应的服务人员
if (inPolicyNo != null && !"".equals(inPolicyNo) && inPolicyNo.equals(policyNo)) {
servicerNo = inJSON.getString("servicerNo");
Map<String,String> itemSuccessMap = new HashMap<>();
itemSuccessMap.put("policyNo",policyNo);
itemSuccessMap.put("servicerNo",servicerNo);
successList.add(itemSuccessMap);
break;
}
}
//根据保单号查询保单缴费信息，获得应缴月
PolicyPremInfo policyPremInfo = policyPremInfoService.selectByPolicyNo(policyNo);
if (policyPremInfo != null) {
String dateMonth = policyPremInfo.getPremDueDate();
dateMonth = dateMonth.substring(0,7);
//根据机构号和应缴月查询分单批次申请，获得流水号
GrasAssignBatchRecord grasAssignBatchRecord = batchRecordService.selectBatchRecord(branchCode, dateMonth);
if (grasAssignBatchRecord != null) {
GrasSysTemp temp = new GrasSysTemp(policyNo, branchCode, servicerNo, MyConstant.ASSIGN_RULE_11, grasAssignBatchRecord.getBatchSeq(),user);
temp.setServicerNo(servicerNo);
sysTempList.add(temp);
}
}
}
//往成功表中添加这些数据 并向批次表中添加数据
try {
if (sysTempList != null && sysTempList.size() != 0) {
// batchRecord.setBranchCode(branchCode);
// Date dueMonthDate = DateUtil.getDateFormat(DateUtil.getPerFirstDayOfDate(dueMonth,DateUtil.DATE_DEFAULT_FORMAT));
// batchRecord.setDueMonth(dueMonthDate);
// batchRecord.setBatchCode(NumberUtil.random4());
// batchRecordService.insertBatchRecord(batchRecord);
for (List mergeSuccessList : subListPolicyList(sysTempList)) {
sysTempService.insertOrUpdateBatch(mergeSuccessList);
}
}
//在失败表中删除这些数据
if (policyNoList != null && policyNoList.size() != 0) {
for (List listForDelete : subListPolicyList(policyNoList)) {
// failedRecordService.deleteList(listForDelete);
failedRecordService.updateList("N",listForDelete);
}
}
} catch (Exception e) {
resultJson.put("内部错误", e.getMessage());
return resultJson;
}
}
failedCount = 0;
succesCount = 0;
}
return resultJson;
} catch (Exception e) {
logUtils.error(e);
resultJson.put("错误信息:", e.getMessage());
failedCount = 0;
succesCount = 0;
return resultJson;
}
}
/**
* MethodName: quitAssign
* Description: [保单离职交接规则]
* @param policyNoList
* @param policyList
* @return String
*
* @author Mamba
* @date 2019年1月8日 下午2:26:28
*/
private List<Map<String, String>> quitAssign(List<String> policyNoList, List<JSONObject> policyList, List<Map<String,String>> policyFailedList,Set<String> failedList)
{
//key：应缴日(1812)年份加月份 value{现服务人员代码,服务人员代码}
Map<String, Map> map = new HashMap<String, Map>();
//{现服务人员代码,服务人员代码}
Map<String, String> policyMap = new HashMap<String, String>();
//最后符合条件的保单信息
List<Map<String, String>> policySuccessList = new ArrayList<>();
Map<String, String> policySuccessMap = null;
Date nowDate = new Date();
//获取当前年份
int nowYear = DateUtil.getYear(nowDate);
int nowMonth = DateUtil.getMonth(nowDate);
Map<String,String> paramMap=new HashMap<String,String>();
//错误信息
Map<String,String> policyFailedMap = null;
for (String item : policyNoList)
{
for (JSONObject policyJson : policyList)
{
String policyNo = policyJson.getString("policyNo");
String servicerNo = policyJson.getString("servicerNo");
try
{
if (item.equals(policyNo))
{
policySuccessMap = new HashMap<>();
/**
* 处理离职交接规则
*/
//根据保单号从数据库取现服务人员
RNPolicyServiceInfo rnPolicyServiceInfo = servicerInfoService.selectByPolicyNo(policyNo);
StaffInfo staffInfo = null;
if (rnPolicyServiceInfo != null)
{
staffInfo = staffInfoService.selectByPrimaryKey(rnPolicyServiceInfo.getServiceNo());
}
int month = 0;
int year = 0;
if (staffInfo != null && staffInfo.getLeaveDate() != null)
{
Date leaveDate = DateUtil.formatDate(staffInfo.getLeaveDate(), "yyyy-MM-dd");
month = DateUtil.getMonth(leaveDate);
year = DateUtil.getYear(leaveDate);
}
//1：先判断该保单的现服务人员是否在当月或者上月离职 人员离职时间：STAFF_INFO.LEAVE_DATE
if (quitTime(nowYear, nowMonth, year, month))
{
//3.离职人员名下未收件交接遵循“应缴月为同一个月份的保单只能交接给同一个人，不允许分别交接给多个人员”；未收件：保单缴费状态为1的时候为未收件，即POLICY_PREM_INFO.PREM_STATUS=1
//例如：A人员当月离职，他12月名下有3笔保单，分别为1,2,3，分别会出现两种情况，1：A人员应缴日在12月的保单从未有过交接记录 2：A人员应缴日在12月的保单存在交接记录
//情况1：上传文件中，把1,2,3分别分配给B,C,D，文件格式如下：
//数据库获取保单应缴日，得到应缴月
PolicyPremInfo policyPremInfo = premInfoService.selectByPolicyNo(policyNo);
Date premDueDate = DateUtil.formatDate(policyPremInfo.getPremDueDate(), "yyyy-MM-dd");
int premDueMonth = DateUtil.getMonth(premDueDate);
int premDueYear = DateUtil.getYear(premDueDate);
//校验考核期
if(checkAssessmentPeriod(premDueYear,premDueMonth)){
//那么这种情况，1先分给了B,那根据规则同一月保单只能分配给同一人，那么2,3保单就只能B
//校验如下，校验保单交出服务人员是否和该保单现服务人员相同，若不相同则没有发生保单离职交接记录
//注：数据库获取保单服务人员交接记录表，该保单最近一次交接记录，获取交出服务人员字段 RN_POLICY_SERVICER_CHG_RECORD.EARLIER_AGENT
String startMonths = DateUtil.getPerFirstDayOfDate(policyPremInfo.getPremDueDate(), DateUtil.DATETIME_DEFAULT_FORMAT);
String endMonth = DateUtil.getPerLastDayOfDate(policyPremInfo.getPremDueDate(), DateUtil.DATETIME_DEFAULT_FORMAT);
paramMap.put("sreceiveNo", rnPolicyServiceInfo.getServiceNo());
paramMap.put("startMonths", startMonths);
paramMap.put("endMonth", endMonth);
RNPolicyServicerChgRecord record = changeService.queryLastTimeServicerChg(paramMap);
/**保 原 接收
* p1 H1 H2
* p2 H1 H3
*/
//交出服务人员代码
String outSer = null;
//接收服务人员代码
String receiveSer = null;
//现服务人员代码
String nowServicerNo = rnPolicyServiceInfo.getServiceNo();
if (record == null
|| DateUtil.compareToDate(staffInfo.getLeaveDate(),
DateUtil.getDateFormat(record.getChangeDate())) != -1)
{
//情况一：没有记录，或者离职时间大于调整时间（离职之前交接的保单） 小于根据应缴月从map中取值（应缴月值应该每次去查保单的应缴日），从值中取该保单号的现服务人员，
Map<String, String> m = map.get(String.valueOf(premDueYear)
+ String.valueOf(premDueMonth));
//现服务人员代码
String nowServicer = null;
//准备交接的服务人员代码
String servicer = null;
/**
* map H1:H2
*/
if(m!=null){
for (Map.Entry<String, String> s : m.entrySet())
{
if (s.getKey().equals(nowServicerNo))//H1==1
{
nowServicer = s.getKey();
servicer = s.getValue();//H2
}
}
}
//情况1：如果没值，那就符合条件
//情况2：如果有值，根据同月只能分配给同一人员原则,比较收服务人员与上个接收服务人员是否相同为同一人
if (nowServicer != null && !servicerNo.equals(servicer))
{
failedList.add(policyNo);
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "离职人员下同一应缴月下的保单只能分配给一个人");
policyFailedList.add(policyFailedMap);
break;
}
}
else
{
//情况二：若保单交出服务人员和该保单现服务人员相同，则说明之前有发生过保单离职交接，那根据一个月中只能分给同一个服务人员原则，那只能分配给接收服务人员
//处理脏数据 NextAgent离职 --通过，可以调整 NextAgent 未离职 --保持原服务人员，不可以调整
//如果离职后调整的服务人员也处于离职状态的话，则允许此次操作
StaffInfo staffInfo1 = staffInfoService.selectByPrimaryKey(record.getNextAgent());
//若是离职，则不可调整 break
if(staffInfo1 != null && staffInfo1.getLeaveDate() != null){
failedList.add(policyNo);
policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo", policyNo);
policyFailedMap.put("servicerNo", servicerNo);
policyFailedMap.put("cause", "离职人员下同一应缴月下的保单只能分配给一个人");
policyFailedList.add(policyFailedMap);
break;
}
}
policyMap.put(nowServicerNo, servicerNo);
map.put(String.valueOf(premDueYear) + String.valueOf(premDueMonth), policyMap);
}
}
/**
* end
*/
policySuccessMap.put("policyNo", policyNo);
policySuccessMap.put("servicerNo", servicerNo);
policySuccessList.add(policySuccessMap);
break;
}
}
catch (Exception e)
{
e.printStackTrace();
policySuccessMap.put("policyNo", policyNo);
policySuccessMap.put("servicerNo", servicerNo);
policySuccessList.add(policySuccessMap);
break;
}
}
}
return policySuccessList;
}
/**
*
* MethodName: checkAssessmentPeriod
* Description: [校验考核期]
*@param premDueYear
*@param premDueMonth
*@return boolean
*
* @author Mamba
* @date 2019年5月5日 下午5:33:23
*/
private boolean checkAssessmentPeriod(int premDueYear, int premDueMonth)
{
//例如：当前5月份操作离职交接时，只对应缴月在3月、4月、5月的保单进行规则校验
Date nowDate=DateUtil.getNowDate();
int nowYear=DateUtil.getYear(nowDate);
int nowMonth=DateUtil.getMonth(nowDate);
//最小月
Date earliestDate=DateUtil.getDateMonthFormat(DateUtil.getDateMonthFormat(DateUtil.getFirstMonth(3)));
int earliestYear=DateUtil.getYear(earliestDate);
int earliestMonth=DateUtil.getMonth(earliestDate);
//同年 当前：2019-4 最小月：2019-1 应缴月：2019-3
if(earliestYear==nowYear){
//同年 ： 小于等于当前月 && 大于最小月 --3月小于5月，大于2月
if(nowYear==premDueYear && premDueMonth<=nowMonth && premDueMonth>earliestMonth){
return true;
}
}
//不同年
if(earliestYear<nowYear){
//当前：2019-3 最小月：2018-12 应缴月：2019-3
//应缴月与当前时间同年 && 应缴月小于等于当前月
if(nowYear==premDueYear && premDueMonth<=nowMonth){
return true;
}
//应缴月与最小月同年 && 应缴月大于最小月
if(nowYear==earliestYear && premDueMonth>earliestMonth){
return true;
}
}
return false;
}
private boolean quitTime(int nowYear, int nowMonth, int year, int month)
{
//同年--当月&上月
if (nowYear == year && (nowMonth == month || nowMonth == (month - 1)))
{
return true;
}
//去年 ---上月
if ((nowYear - year) == 1 && month == 12)
{
return true;
}
return false;
}
private void verifyShouzhanChannel(List<Map<String,String>> policyFailedList,Set<String> failedList, String policyNo, String servicerNo, StaffInfo staffInfo, String empChannelType) {
//收展分几种种情况 1.人员也为收展 2.人员不为收展但是 shouzhanflag? 为Y 取反例即可 3 人员的职务为个险收展专员、银代收展专员、收展主任、个险兼收、银代兼收 这四种
if (!MyConstant.CHANNEL_07.equals(empChannelType)) {
RenewalStaffInfoOther staffInfoOther = otherService.selectByEmpNo(servicerNo);
//人员的职务
String position = staffInfo.getPosition();
assignAbility(policyFailedList,failedList, policyNo, staffInfoOther, position, servicerNo);
}
}
private void veryfyEcoChannel(List<Map<String,String>> policyFailedList,Set<String> failedList, String policyNo, String servicerNo, StaffInfo staffInfo, String empChannelType) {
Map<String,String> policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","人员无权操作此保单（不能负责该渠道）");
//经代分几种种情况 1.人员也为经代 2.人员不为经代但是 agentFlag 为Y 取反例即可 3 人员的职务为银代督导、续收主任、个险兼收、银代兼收 这四种
if (!MyConstant.CHANNEL_03.equals(empChannelType)) {
RenewalStaffInfoOther staffInfoOther = otherService.selectByEmpNo(servicerNo);
//人员的职务
String position = staffInfo.getPosition();
if (staffInfoOther != null) {
//个险兼收人员标示
String marketFlag = staffInfoOther.getMarketFlag();
//经代兼收标示
String agentFlag = staffInfoOther.getAgentFlag();
//银代兼收标示
String bankFlag = staffInfoOther.getBankFlag();
//不是兼收人员
//续收专员、续收主任、个险兼收、银代兼收 这四种都可以分经代的单子
if ((!"Y".equals(marketFlag)) && (!"Y".equals(bankFlag)) && (!"Y".equals(agentFlag))) {
if (position != null && !"".equals(position)) {
//续收专员、银代收展专员、续收主任
if (!MyConstant.BANK_AGENT_SERVICER.equals(position) && !MyConstant.PERSONAL_INSURANCE_SERVICER.equals(position) && !MyConstant.CD_DIRECTOR.equals(position)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
} else {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
}
} else {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
}
}
private void verifyBankChannel(List<Map<String,String>> policyFailedList,Set<String> failedList, String policyNo, String servicerNo, StaffInfo staffInfo, String empChannelType) {
Map<String,String> policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","人员无权操作此保单（不能负责该渠道）");
//银代分几种种情况 1.人员也为银代 2.人员不为银代但是 bank——flag 为Y 取反例即可 3 人员的职务为银代督导、续收主任、个险兼收、银代兼收 这四种
if (!MyConstant.CHANNEL_02.equals(empChannelType)) {
RenewalStaffInfoOther staffInfoOther = otherService.selectByEmpNo(servicerNo);
//人员的职务
String position = staffInfo.getPosition();
//是否银代兼收人员标示
if (staffInfoOther != null) {
String marketFlag = staffInfoOther.getMarketFlag();
//银代兼收标示
String bankFlag = staffInfoOther.getBankFlag();
//不是兼收人员
if ((!"Y".equals(marketFlag)) && (!"Y".equals(bankFlag))) {
if (position != null && !"".equals(position)) {
//银代督导、续收主任、个险兼收、银代兼收 这四种都可以分银代的单子
//续收专员、银代收展专员
if (!MyConstant.BANK_AGENT_SERVICER.equals(position) && !MyConstant.CD_DIRECTOR.equals(position)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
} else {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
}
} else {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo);
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
}
}
private void assignAbility(List<Map<String,String>> policyFailedList,Set<String> failedList, String policyNo, RenewalStaffInfoOther staffInfoOther, String position, String servicerNo) {
Map<String,String> policyFailedMap = new HashMap<>();
policyFailedMap.put("policyNo",policyNo);
policyFailedMap.put("servicerNo",servicerNo);
policyFailedMap.put("cause","人员无权操作此保单（不能负责该渠道）");
if (staffInfoOther != null) {
//个险兼收人员标示
String marketFlag = staffInfoOther.getMarketFlag();
//银代兼收标示
String bankFlag = staffInfoOther.getBankFlag();
//不是兼收人员
//个险收展专员、收展主任、个险兼收、银代兼收 这四种都可以分收展的单子
if ((!"Y".equals(marketFlag)) && (!"Y".equals(bankFlag))) {
if (position != null && !"".equals(position)) {
//续收专员、银代收展专员、续收主任
if (!MyConstant.PERSONAL_INSURANCE_SERVICER.equals(position) && !MyConstant.CD_DIRECTOR.equals(position)) {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
} else {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo+ "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
}
} else {
failedList.add(policyNo);
// servicerFailedList.add(servicerNo + "人员无权操作此保单（不能负责该渠道）");
policyFailedList.add(policyFailedMap);
failedCount += 1;
}
}
/**
* 根据保单号查询到能服务该保单的人员
*
* @param policyNo
* @return
*/
@Override
public List<StaffInfo> getEmpsByBranchCodeAndchannelType(String policyNo) {
//保单所属机构号
String branchCode = policyService.selectBranchCodeByPolicyNo(policyNo);
//保单渠道
String channelType = policyService.selectChannelTypeByPolicyNo(policyNo);
//结果集
List resultList = new ArrayList();
//机构信息
BranchInfo branchInfo = branchInfoService.selectByPrimaryKey(branchCode);
//机构级别
String branchLevel = branchInfo.getBranchLevel();
//如果保单是四级机构，那就找他对应的三级机构
if (!Arrays.asList(MyConstant.BRANCH_LEVEL_LIST).contains(branchLevel)) {
Map<String, String> paramMap = new HashMap<>();
paramMap.put("branchCode", branchCode);
paramMap.put("branchLevel", MyConstant.BRANCH_LEVEL_03);
branchCode = ruleDealService.queryBranchCodeByLevel(paramMap);
}
//保单对应的机构下所有符合条件的人员
List<StaffInfo> empsByBranchCodeAndchannelType = staffInfoService.getEmpsByBranchCodeAndchannelType(branchCode);
for (StaffInfo staffInfo : empsByBranchCodeAndchannelType) {
String empNo = staffInfo.getEmpNo();
//人员能服务的渠道
Set<String> checkChannelTypes = checkChannelTypes(empNo);
//人员服务的渠道包含了保单的渠道
if (checkChannelTypes.contains(channelType)) {
resultList.add(staffInfo);
}
}
return resultList;
}
/**
* 回写核心数据库的操作
* @param user
* @param policyServicerList
* @param assginRule
* @return
*/
@Override
public JSONObject resultBackRN(String user,List<Map<String,String>> policyServicerList,String assginRule){
JSONObject resultJson = new JSONObject();
String transFlag = "传输异常";
String reason = "";
List<RNPolicyServicerChgRecord> RNPSCRList=new ArrayList<RNPolicyServicerChgRecord>();
try{
List<String> policys = new ArrayList<>();
JSONArray paramArray = new JSONArray();
for (Map<String, String> item : policyServicerList) {
String policyNo = item.get("policyNo");
String servicerNo = item.get("servicerNo");
//用于存放给核心系统传输数据的
JSONObject dataJSON = new JSONObject(){{
put("policyNo", policyNo);
put("servicerNo", servicerNo);
put("orphanMark", "0");
put("assignRule", assginRule);
put("lastAssignUser", user);
put("lastAssignDate", DateUtil.getDateTimeFormat(new Date()));
}};
//保单交接记录
setPolicyServicerChgRecord(policyNo,servicerNo,assginRule,user,RNPSCRList);
paramArray.add(dataJSON);
policys.add(policyNo);
}
//向核心系统传数据
logUtils.info("核心系统回写...时间：" + new Date() + "向核心系统传入的参数为：" + paramArray);
//此处要求是按3000条进行传输一次
List<JSONArray> jsonArrays = submit3000Datas(paramArray, 3000);
//传输失败的保单数组
List<String> failedPolicyNos = new ArrayList<>();
//传输记录 用于记录
List<GrasSysDataTrans> transList = new ArrayList<>();
//分批传输
for (JSONArray pageDatas : jsonArrays) {
//每次传输的结果
JSONObject everyTimeSyncResult = AllotResultsBack.syncPolicyRule(pageDatas);
logUtils.info(new Date() + "本次回写结果：" + everyTimeSyncResult);
//传输成功与否的标示
String flag = everyTimeSyncResult.getString("flag");
//接口返回的传输失败的保单
JSONArray failedPolicys = everyTimeSyncResult.getJSONArray("policyNos");
if("0".equals(flag)){
//失败保单处理
if (failedPolicys != null && failedPolicys.size() != 0) {
for (int i = 0; i < failedPolicys.size(); i++) {
//失败的保单，key为policyNo，value为失败的原因
JSONObject failedPolicy = failedPolicys.getJSONObject(i);
for (String policyNo : failedPolicy.keySet()) {
String failedReason = failedPolicy.getString(policyNo);
failedPolicyNos.add(policyNo);
GrasSysDataTrans transData = new GrasSysDataTrans("GRAS_SYS_TEMP",policyNo,"N","Y",failedReason,user,user);
transList.add(transData);
}
}
}
//传输成功
transFlag = "传输成功";
}else {
transFlag = "传输失败";
//传输失败保单处理
if (failedPolicys != null && failedPolicys.size() != 0) {
for (int i = 0; i < failedPolicys.size(); i++) {
//失败的保单，key为policyNo，value为失败的原因
JSONObject failedPolicy = failedPolicys.getJSONObject(i);
for (String policyNo : failedPolicy.keySet()) {
String failedReason = "";
failedPolicyNos.add(policyNo);
//接口返回的结果 可能长度很长不符合数据库规范
if (failedPolicy.getString(policyNo).length() >= 200) {
failedReason = failedPolicy.getString(policyNo).substring(0, 199);
} else {
failedReason = failedPolicy.getString(policyNo);
}
GrasSysDataTrans transData = new GrasSysDataTrans("GRAS_SYS_TEMP",policyNo,"N","Y",failedReason,user,user);
transList.add(transData);
}
}
}
}
}
//传输成功的保单的处理 移除失败的就是成功的
policys.removeAll(failedPolicyNos);
if (policys != null && policys.size() != 0) {
for (String policyNo : policys) {
GrasSysDataTrans transData = new GrasSysDataTrans("GRAS_SYS_TEMP",policyNo,"Y","Y","传输成功",user,user);
transList.add(transData);
}
}
//写入到数据库
if (transList != null && transList.size() != 0) {
for (List mergeList : subListPolicyList(transList)) {
transService.mergeDataTransList(mergeList);
}
}
//报存保单交接记录
/* for (RNPolicyServicerChgRecord policyServicer : RNPSCRList)
{
if(policys.contains(policyServicer.getPolicyNo())){
changeService.insert(policyServicer);
}
}*/
//更新es
JSONObject jsonObject=new JSONObject();
List<JSONObject> policyNolist=new ArrayList<JSONObject>();
for (Object object : paramArray)
{
jsonObject=(JSONObject)object;
for(String policyNo:policys){
if(policyNo.equals(jsonObject.get("policyNo"))){
String servicerNo=(String) jsonObject.get("servicerNo");
StaffInfo staffInfo=staffInfoService.selectByPrimaryKey(servicerNo);
if(staffInfo!=null){
jsonObject.put("empName", staffInfo.getEmpName());
policyNolist.add(jsonObject);
}
break;
}
}
}
elasticSearchService.updateAssignPolicyInfo(policyNolist);
}catch (Exception e){
logUtils.error(e);
}
return resultJson;
}
/**
* MethodName: setPolicyServicerChgRecord
* Description: [设置保单服务人员交接记录信息]
*@param policyNo
*@param servicerNo
*@param assginRule
*@param user void
*
* @author Mamba
* @date 2019年2月18日 上午10:58:55
*/
private void setPolicyServicerChgRecord(String policyNo, String servicerNo, String assginRule, String user,List<RNPolicyServicerChgRecord> RNPSCRList)
{
Date nowTime=new Date();
//交出服务人员--原服务人员
String earlierAgent=null;
RNPolicyServiceInfo policyServiceInfo=servicerInfoService.selectByPolicyNo(policyNo);
if(policyServiceInfo!=null){
earlierAgent=policyServiceInfo.getServiceNo();
}
PolicyPremInfo policyPremInfo=premInfoService.selectByPolicyNo(policyNo);
Date premDueDate=null;
if(policyPremInfo!=null){
premDueDate= DateUtil.getDateFormat(policyPremInfo.getPremDueDate());
}
String branchCode=policyService.selectBranchCodeByPolicyNo(policyNo);
RNPolicyServicerChgRecord policyServicer=new RNPolicyServicerChgRecord();
policyServicer.setChangeSeq(NumberUtil.random20());
policyServicer.setPolicyNo(policyNo);
policyServicer.setBranchCode(branchCode);
policyServicer.setEarlierAgent(earlierAgent);
policyServicer.setNextAgent(servicerNo);
policyServicer.setChangeDate(nowTime);
//均为业务员
policyServicer.setChangeMode("0");
policyServicer.setPremDueDate(premDueDate);
policyServicer.setCreatedUser(user);
policyServicer.setCreatedDate(nowTime);
policyServicer.setUpdatedUser(user);
policyServicer.setUpdatedDate(nowTime);
policyServicer.setPkSerial(NumberUtil.random20());
//policyServicer.setAssignPolicyType(assginRule);
RNPSCRList.add(policyServicer);
}
/**
* 回写核心数据库的操作
*
* @param user 当前用户
* @param policys 保单号数组
* @return
*/
@Override
public JSONObject resultBack(String user, List<String> policys) {
JSONObject resultJson = new JSONObject();
String transFlag = "传输异常";
String reason = "";
List<RNPolicyServicerChgRecord> RNPSCRList=new ArrayList<RNPolicyServicerChgRecord>();
//创建向接口传输数据的数组
try {
JSONArray paramArray = new JSONArray();
//需要传输的参数有,policyNo,servicerNo,orphanMark,assignRule,lastAssignUser,lastAssignDate
//查询到保单号对应的待分单的保单对应的服务人员等信息
List<GrasSysTemp> grasSysTempList = new ArrayList<>();
if (policys != null && policys.size() > 0) {
List<List> policyLists = subListPolicyList(policys);
for (List policyList : policyLists) {
List policyListResults = tempService.getByPolicyList(policyList);
grasSysTempList.addAll(policyListResults);
}
}
//判空 分单成功的这些向数据库传输
if (grasSysTempList != null && grasSysTempList.size() != 0) {
for (GrasSysTemp sysTemp : grasSysTempList) {
//保单号
String policyNo = sysTemp.getPolicyNo();
//分单规则
String assginRule = sysTemp.getAssignRule();
//保单对应服务人员编号
String servicerNo = sysTemp.getServicerNo();
//保单已经分配了服务人员
if (servicerNo != null && !"".equals(servicerNo)) {
//用于存放给核心系统传输数据的
JSONObject dataJSON = new JSONObject(){{
put("policyNo", policyNo);
put("servicerNo", servicerNo);
put("orphanMark", "0");
put("assignRule", assginRule);
put("lastAssignUser", user);
put("lastAssignDate", DateUtil.getDateTimeFormat(new Date()));
}};
// //保单号
// dataJSON.put("policyNo", policyNo);
// //对应服务人员
// dataJSON.put("servicerNo", servicerNo);
// //孤儿单标记
// dataJSON.put("orphanMark", "0");
// //对应的分单规则
// dataJSON.put("assignRule", assginRule);
// //分单操作人，就是当前用户
// dataJSON.put("lastAssignUser", user);
// //操作日期
// dataJSON.put("lastAssignDate", DateUtil.getDateTimeFormat(new Date()));
paramArray.add(dataJSON);
//保单没有分配人员
} else {
JSONObject dataJSON = new JSONObject(){{
put("policyNo", policyNo);
put("servicerNo", "");
put("orphanMark", "1");
put("assignRule", assginRule);
put("lastAssignUser", user);
put("lastAssignDate", DateUtil.getDateTimeFormat(new Date()));
}};
// dataJSON.put("policyNo", policyNo);
// dataJSON.put("servicerNo", "");
// dataJSON.put("orphanMark", "1");
// dataJSON.put("assignRule", assginRule);
// dataJSON.put("lastAssignUser", user);
// dataJSON.put("lastAssignDate", DateUtil.getDateTimeFormat(new Date()));
paramArray.add(dataJSON);
}
setPolicyServicerChgRecord(policyNo, servicerNo, assginRule, user, RNPSCRList);
}
}
//向核心系统传数据
logUtils.info("核心系统回写...时间：" + new Date() + "向核心系统传入的参数为：" + paramArray);
//此处要求是按3000条进行传输一次
List<JSONArray> jsonArrays = submit3000Datas(paramArray, 3000);
//传输失败的保单数组
List<String> failedPolicyNos = new ArrayList<>();
//传输记录 用于记录
List<GrasSysDataTrans> transList = new ArrayList<>();
//分批传输
for (JSONArray pageDatas : jsonArrays) {
//每次传输的结果
JSONObject everyTimeSyncResult = AllotResultsBack.syncPolicyRule(pageDatas);
logUtils.info(new Date() + "本次回写结果：" + everyTimeSyncResult);
//传输成功与否的标示
String flag = everyTimeSyncResult.getString("flag");
//接口返回的传输失败的保单
JSONArray failedPolicys = everyTimeSyncResult.getJSONArray("policyNos");
if("0".equals(flag)){
//失败保单处理
if (failedPolicys != null && failedPolicys.size() != 0) {
for (int i = 0; i < failedPolicys.size(); i++) {
//失败的保单，key为policyNo，value为失败的原因
JSONObject failedPolicy = failedPolicys.getJSONObject(i);
for (String policyNo : failedPolicy.keySet()) {
String failedReason = failedPolicy.getString(policyNo);
failedPolicyNos.add(policyNo);
GrasSysDataTrans transData = new GrasSysDataTrans("GRAS_SYS_TEMP",policyNo,"N","Y",failedReason,user,user);
transList.add(transData);
}
}
}
//传输成功
transFlag = "传输成功";
}else {
transFlag = "传输失败";
//传输失败保单处理
if (failedPolicys != null && failedPolicys.size() != 0) {
for (int i = 0; i < failedPolicys.size(); i++) {
//失败的保单，key为policyNo，value为失败的原因
JSONObject failedPolicy = failedPolicys.getJSONObject(i);
for (String policyNo : failedPolicy.keySet()) {
String failedReason = "";
failedPolicyNos.add(policyNo);
//接口返回的结果 可能长度很长不符合数据库规范
if (failedPolicy.getString(policyNo).length() >= 200) {
failedReason = failedPolicy.getString(policyNo).substring(0, 199);
} else {
failedReason = failedPolicy.getString(policyNo);
}
GrasSysDataTrans transData = new GrasSysDataTrans("GRAS_SYS_TEMP",policyNo,"N","Y",failedReason,user,user);
transList.add(transData);
}
}
}
}
}
//传输成功的保单的处理 移除失败的就是成功的
policys.removeAll(failedPolicyNos);
if (policys != null && policys.size() != 0) {
for (String policyNo : policys) {
GrasSysDataTrans transData = new GrasSysDataTrans("GRAS_SYS_TEMP",policyNo,"Y","Y","传输成功",user,user);
transList.add(transData);
}
}
//临时表中数据的剔除 回写成功了的
if (policys != null && policys.size() != 0) {
for (List deleteList : subListPolicyList(policys)) {
sysTempService.deleteByPolicyList(deleteList);
}
}
//写入到数据库
if (transList != null && transList.size() != 0) {
for (List mergeList : subListPolicyList(transList)) {
transService.mergeDataTransList(mergeList);
}
}
//报存保单交接记录
/*for (RNPolicyServicerChgRecord policyServicer : RNPSCRList)
{
if(policys.contains(policyServicer.getPolicyNo())){
changeService.insert(policyServicer);
}
}*/
//更新es
JSONObject jsonObject=new JSONObject();
List<JSONObject> policyNolist=new ArrayList<JSONObject>();
for (Object object : paramArray)
{
jsonObject=(JSONObject)object;
for(String policyNo:policys){
if(policyNo.equals(jsonObject.get("policyNo"))){
String servicerNo=(String) jsonObject.get("servicerNo");
StaffInfo staffInfo=staffInfoService.selectByPrimaryKey(servicerNo);
if(staffInfo!=null){
jsonObject.put("empName", staffInfo.getEmpName());
policyNolist.add(jsonObject);
}
break;
}
}
}
elasticSearchService.updateAssignPolicyInfo(policyNolist);
} catch (Exception e) {
transFlag = "传输失败";
reason = e.getMessage();
resultJson.put("result", transFlag);
resultJson.put("reason", reason);
//错误输出
logUtils.error(e.toString());
e.printStackTrace();
}
resultJson.put("result", transFlag);
resultJson.put("reason", reason);
return resultJson;
}
@Override
public boolean adjustEmp(String branchCode, String policyNo, String empNo,String userName) {
String batch = "";
List<GrasAssignBatchRecord> batchRecords = batchRecordService.assignBatchRecordMonth(branchCode);
if (batchRecords != null && batchRecords.size() > 0) {
GrasAssignBatchRecord batchRecord = batchRecords.get(0);
batch = batchRecord.getBatchSeq();
}
GrasSysTemp temp = new GrasSysTemp(policyNo,branchCode,empNo,MyConstant.ASSIGN_RULE_11,batch,userName);
List<GrasSysTemp> tempList = new ArrayList<>();
tempList.add(temp);
int mergeResult = sysTempService.insertOrUpdateBatch(tempList);
if (mergeResult == 1) {
//成功后要删除失败表的数据
// failedRecordService.deleteByPolicy(policyNo);
failedRecordService.updatePolicy("N",policyNo);
return true;
}
return false;
}
@Override
public List<Map<String,String>> selectForExcel(String flag, String branchCode, String month, List channelType) {
//月份格式化
List<JSONObject> resultJson = new ArrayList<>();
String nowMonth = null;
String nextMonth = null;
Integer total = 0;
List<Map<String,String>> resultList = new ArrayList<>();
if (month != null && !"".equals(month)) {
//起始日
nowMonth = DateUtil.getPerFirstDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
//截止日
nextMonth = DateUtil.getPerLastDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
}
List<String> batchRecordsList = batchRecordService.batchRecordsByBrancodeAndMoth(branchCode, nowMonth, nextMonth);
if (batchRecordsList != null && batchRecordsList.size() != 0) {
if (flag.equals(SUCCESSFUL_FLAG)) {
//总数
total = sysTempService.countPolicyForPageInfoSuccess(batchRecordsList, branchCode, channelType);
//总页数
int totalPages = (total / 10) + 1;
for (int i = 1; i <= totalPages; i++) {
List<Map<String,String>> pageList = sysTempService.querySuccesPolicy(batchRecordsList, branchCode, i, 10, channelType);
resultList.addAll(pageList);
}
} else if (flag.equals(FAILED_FLAG)) {
total = sysTempService.countPolicyForPageInfoFailed(batchRecordsList, branchCode, channelType);
//总页数
int totalPages = (total / 10) + 1;
for (int i = 1; i <= totalPages; i++) {
List<Map<String,String>> pageList = sysTempService.queryFailedPolicy(batchRecordsList, branchCode, i, 10, channelType);
resultList.addAll(pageList);
}
}
}
return resultList;
}
/**
* 自动提交保单至核心系统
* 剩下的所有保单都是要提交的
*/
@Override
public void autoResultBack() {
List<String> policies = sysTempService.selectAllPolicies();
JSONObject resultBack = resultBack(MyConstant.SYS_USER, policies);
String result = resultBack.getString("result");
//传输失败
if (result == null || !result.equals("传输成功")) {
//再次提交
autoResultBack();
}
}
//list长度可能过长 进行截取
private List<List> subListPolicyList(List policyList) {
List<List> resultList = new ArrayList();
if (policyList == null || policyList.size() == 0) {
return null;
}
for (int i = 0; i < policyList.size(); i++) {
if (i % 999 == 0) {
int count = i / 999;
List subList = (List) policyList.stream().limit((count + 1) * 999).skip(count * 999).collect(Collectors.toList());
resultList.add(subList);
}
}
return resultList;
}
//查看人员能服务哪些渠道
private Set<String> checkChannelTypes(String empNo) {
Set<String> channelList = new LinkedHashSet<>();
//人员本身的渠道
String channelTypeByEmpNp = staffInfoService.selectChannelTypeByEmpNp(empNo);
channelList.add(channelTypeByEmpNp);
//兼收范围查看
RenewalStaffInfoOther staffInfoOther = otherService.selectByEmpNo(empNo);
//个险兼收标示OK 个险兼收 可服务保单渠道：个险，经代，收展，银代 SFP 区拓 创新拓展
if (staffInfoOther != null && "Y".equals(staffInfoOther.getMarketFlag())) {
addChannelTypes(channelList, MyConstant.CHANNEL_02, MyConstant.CHANNEL_03, MyConstant.CHANNEL_04, MyConstant.CHANNEL_05, MyConstant.CHANNEL_09, MyConstant.CHANNEL_07);
}
//银代兼收标示OK 可服务保单渠道：个险，经代，收展，银代
if (staffInfoOther != null && "Y".equals(staffInfoOther.getBankFlag())) {
addChannelTypes(channelList, MyConstant.CHANNEL_05, MyConstant.CHANNEL_02, MyConstant.CHANNEL_03, MyConstant.CHANNEL_04, MyConstant.CHANNEL_09, MyConstant.CHANNEL_07);
}
//人员职位
StaffInfo staffInfo = staffInfoService.selectByPrimaryKey(empNo);
if (staffInfo != null) {
//人员职位
String position = staffInfo.getPosition();
//收展主任 可以负责：个险，经代，收展，银代，SFP（属于银代），区拓（属于个险），创新（属于银代）
if (position != null && !"".equals(position) && MyConstant.CD_DIRECTOR.equals(position)) {
addChannelTypes(channelList, MyConstant.CHANNEL_02, MyConstant.CHANNEL_03, MyConstant.CHANNEL_04, MyConstant.CHANNEL_05, MyConstant.CHANNEL_07, MyConstant.CHANNEL_09);
}
//个险收展专员 个险，经代，收展
if (position != null && !"".equals(position) && MyConstant.PERSONAL_INSURANCE_SERVICER.equals(position)) {
channelList.addAll(Arrays.asList(MyConstant.CHANNEL_01,MyConstant.CHANNEL_03,MyConstant.CHANNEL_05,MyConstant.CHANNEL_07));
}
//银代收展专员 银代
if (position != null && !"".equals(position) && MyConstant.BANK_AGENT_SERVICER.equals(position)) {
channelList.addAll(Arrays.asList(MyConstant.CHANNEL_02,MyConstant.CHANNEL_04,MyConstant.CHANNEL_09));
}
}
return channelList;
}
private void addChannelTypes(Set<String> channelList, String e2, String e3, String e4, String e5, String e6, String e7) {
channelList.add(MyConstant.CHANNEL_01);
channelList.addAll(Arrays.asList(e2,e3,e4,e5,e6,e7));
}
/**
* MethodName: queryPoServerInfoExportToExcel
* Description: [根据应缴月查询机构保单服务信息]
*@param branchCode
*@param channelType
*@param month
*@return
*/
@Override
public List<JSONObject> queryPoServerInfoExportToExcel(String branchCode, String channelType, String month)
{
Map<String, String> paramMap=new HashMap<String,String>();
String nowMonth = null;
String nextMonth = null;
if (month != null && !"".equals(month)) {
// Map<String, String> allotMonth = DateUtil.allotMonth(month);
//起始日
// nowMonth = allotMonth.get("nowMonth");
nowMonth = DateUtil.getPerFirstDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
//截止日
// nextMonth = allotMonth.get("nextMonth");
nextMonth = DateUtil.getPerLastDayOfDate(month,DateUtil.DATETIME_DEFAULT_FORMAT);
}
paramMap.put("branchCode", branchCode);
paramMap.put("nowMonth", nowMonth);
paramMap.put("nextMonth", nextMonth);
List<String> channelTypeList = null;
if(!StringUtils.isEmpty(channelType)){
String[] channelTpList=channelType.split(",");
channelTypeList=Arrays.asList(channelTpList);
//paramMap.put("channelType", channelType);
}
//List<JSONObject> list=new ArrayList<JSONObject>();
List<JSONObject> normalAssignList=null;
//List<JSONObject> spanBranchList=null;
try
{
normalAssignList=servicerInfoService.queryPoSericeInfoByPremDueDate(branchCode,nowMonth,nextMonth,channelTypeList);
/*if(normalAssignList!=null){
list.addAll(normalAssignList);
}*/
//获取跨机构分单保单
/* spanBranchList=servicerInfoService.querySpanBranchAssignPolicy(paramMap);
if(spanBranchList!=null){
list.addAll(spanBranchList);
}*/
}
catch (Exception e)
{
e.printStackTrace();
}
return normalAssignList;
}
/**
* 数据分3000条一次向RN系统传输
* @param allDatas 全部数据
* @param pageData 每次传多少
* @return
*/
private List<JSONArray> submit3000Datas(JSONArray allDatas,int pageData){
List<JSONArray> resultList = new ArrayList();
if(allDatas == null || allDatas.size() == 0){
return null;
}
int num = 0;
JSONArray tempArray = new JSONArray();
for(int i = 0 ; i<allDatas.size();i++){
JSONObject itemObject = allDatas.getJSONObject(i);
tempArray.add(itemObject);
num++;
if (num == pageData){
resultList.add(tempArray);
num = 0;
tempArray.clear();
}
// if(i % pageData == 0){
// int count = i/pageData;
// JSONArray subList = JSONArray.parseArray(allDatas.stream().limit((count + 1) * pageData).skip(count * pageData).collect(Collectors.toList()).toString()) ;
// resultList.add(subList);
// }
}
if (tempArray.size()>0){
resultList.add(tempArray);
}
return resultList;
}
}
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!