package cn.timer.api.controller.jxgl;

import java.util.List;
import java.util.stream.Collectors;

import javax.validation.constraints.NotNull;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.timer.api.aspect.lang.annotation.Role;
import cn.timer.api.bean.jxgl.JxglAppraisal;
import cn.timer.api.bean.jxgl.JxglAppraisalAssessment;
import cn.timer.api.bean.jxgl.JxglAppraisalIndicators;
import cn.timer.api.bean.jxgl.JxglAppraisalIndicatorsAssessment;
import cn.timer.api.bean.jxgl.JxglAppraisalIndicatorsT;
import cn.timer.api.bean.jxgl.JxglAppraisalItem;
import cn.timer.api.bean.jxgl.JxglAppraisalItemT;
import cn.timer.api.bean.jxgl.JxglAppraisalLog;
import cn.timer.api.bean.jxgl.JxglAppraisalT;
import cn.timer.api.bean.jxgl.JxglBasicSetting;
import cn.timer.api.bean.jxgl.JxglPerformanceAppraisal;
import cn.timer.api.bean.jxgl.JxglPerformanceRating;
import cn.timer.api.bean.jxgl.JxglProcessNode;
import cn.timer.api.bean.spmk.SpmkApproveSummary;
import cn.timer.api.bean.yggl.YgglMainEmp;
import cn.timer.api.bean.zzgl.ZzglBmgwM;
import cn.timer.api.config.annotation.CurrentUser;
import cn.timer.api.config.annotation.UserBean;
import cn.timer.api.config.enuminterface.JxglEnumInterface.AppraisalLogType;
import cn.timer.api.config.enuminterface.JxglEnumInterface.AppraisalSts;
import cn.timer.api.config.enuminterface.JxglEnumInterface.AssessmentType;
import cn.timer.api.config.enuminterface.JxglEnumInterface.BeingAppraisalSts;
import cn.timer.api.config.enuminterface.JxglEnumInterface.BeingAppraisalType;
import cn.timer.api.config.enuminterface.JxglEnumInterface.ExecuteType;
import cn.timer.api.config.enuminterface.JxglEnumInterface.IndicatorsType;
import cn.timer.api.config.enuminterface.JxglEnumInterface.PerformanceAppraisalSts;
import cn.timer.api.config.enuminterface.JxglEnumInterface.ProcessNodeSts;
import cn.timer.api.config.enuminterface.JxglEnumInterface.ProcessType;
import cn.timer.api.config.exception.CustomException;
import cn.timer.api.config.validation.ValidList;
import cn.timer.api.controller.yggl.service.YgglService;
import cn.timer.api.controller.zzgl.service.ZzglBmgwMService;
import cn.timer.api.dao.jxgl.JxglAppraisalAssessmentMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalIndicatorsAssessmentMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalIndicatorsMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalIndicatorsTMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalItemMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalItemTMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalLogMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalMapper;
import cn.timer.api.dao.jxgl.JxglAppraisalTMapper;
import cn.timer.api.dao.jxgl.JxglBasicSettingMapper;
import cn.timer.api.dao.jxgl.JxglPerformanceAppraisalMapper;
import cn.timer.api.dao.jxgl.JxglPerformanceRatingMapper;
import cn.timer.api.dao.jxgl.JxglProcessNodeMapper;
import cn.timer.api.dao.qyzx.QyzxEmpEntAssoMapper;
import cn.timer.api.dao.yggl.YgglMainEmpMapper;
import cn.timer.api.dao.zzgl.ZzglBmgwMMapper;
import cn.timer.api.dto.jxgl.AppraisalAssessment;
import cn.timer.api.dto.jxgl.AppraisalDetail;
import cn.timer.api.dto.jxgl.AppraisalQuery;
import cn.timer.api.dto.jxgl.AppraisalReject;
import cn.timer.api.dto.jxgl.AppraisalUpdate;
import cn.timer.api.dto.jxgl.AppraisalUpdateSts;
import cn.timer.api.dto.jxgl.BeingAppraisalPerson;
import cn.timer.api.dto.jxgl.EmpAppraisalQuery;
import cn.timer.api.dto.jxgl.EmpPerformanceQuery;
import cn.timer.api.dto.jxgl.MyPerformance;
import cn.timer.api.dto.jxgl.PerformanceAppraisal;
import cn.timer.api.dto.jxgl.PerformanceAppraisalQuery;
import cn.timer.api.dto.jxgl.ProcessNode;
import cn.timer.api.dto.jxgl.ProcessNodeUpdate;
import cn.timer.api.utils.Result;
import cn.timer.api.utils.ResultUtil;
import cn.timer.api.utils.StreamUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api(tags = "3.1绩效管理")
@RestController
@Transactional(rollbackFor = Exception.class)
@RequestMapping(value = "/jxgl",  
produces = { "application/json","multipart/form-data" })
public class JxglController {

	@Autowired
	private QyzxEmpEntAssoMapper qyzxEmpEntAssoMapper;
	
	@Autowired
	private ZzglBmgwMMapper zzglBmgwMMapper;
	
	@Autowired
	private JxglBasicSettingMapper jxglBasicSettingMapper;
	
	@Autowired
	private JxglPerformanceRatingMapper jxglPerformanceRatingMapper;
	
	@Autowired
	private JxglAppraisalTMapper jxglAppraisalTMapper;
	
	@Autowired
	private JxglAppraisalIndicatorsTMapper jxglAppraisalIndicatorsTMapper;
	
	@Autowired
	private JxglAppraisalItemTMapper jsxglAppraisalItemTMapper;
	
	@Autowired
	private JxglAppraisalAssessmentMapper jxglAppraisalAssessmentMapper;
	
	@Autowired
	private JxglAppraisalIndicatorsAssessmentMapper jxglAppraisalIndicatorsAssessmentMapper;
	
	//TODO 基础设置
	/**
	 * 新增或编辑-基础设置
	 */
	@PostMapping(value = "/save_basic_setting")
	@ApiOperation(value = "1.新增或编辑-基础设置", httpMethod = "POST", notes = "新增或编辑-审批模板组")
	@ApiOperationSupport(order = 1)
	@Role
	public Result<Object> saveAtg(@CurrentUser UserBean userBean ,@Validated @RequestBody JxglBasicSetting basicSetting) throws Exception{
		Integer orgCode = userBean.getOrgCode();
		
		List<JxglPerformanceRating> listPr = basicSetting.getPerformanceRatings();
		if (listPr != null) {
			for (JxglPerformanceRating pr : listPr) {
				if (pr.getSectionMaxScore() > basicSetting.getMaxScore()) {
					return ResultUtil.error("区间值不能超过 最高分");
				}else if (pr.getSectionMinScore() >= pr.getSectionMaxScore()) {
					return ResultUtil.error("区间值 设置不正确");
				}
			}
		}
		JxglBasicSetting bS = jxglBasicSettingMapper.selectOne(new QueryWrapper<JxglBasicSetting>().lambda()
				.select(JxglBasicSetting::getId)
				.eq(JxglBasicSetting::getOrgCode, orgCode));
		if (bS != null) {
			// 删除 绩效等级
			jxglPerformanceRatingMapper.delete(new QueryWrapper<JxglPerformanceRating>().lambda()
					.eq(JxglPerformanceRating::getBasicSettingId, bS.getId()));
			// 删除 基础设置
			jxglBasicSettingMapper.delete(new QueryWrapper<JxglBasicSetting>().lambda()
					.eq(JxglBasicSetting::getOrgCode, orgCode));
		}
		
		basicSetting.setOrgCode(orgCode);
		basicSetting.insert();
		if (listPr != null && listPr.size() > 0) {
			listPr.stream().forEach(pr -> pr.setBasicSettingId(basicSetting.getId()));
			int i = jxglPerformanceRatingMapper.insertList(listPr);
		}

		return ResultUtil.success();

	}
	
	/**
	 * 查询-基础设置
	 */
	@GetMapping(value = "/select_basic_setting")
	@ApiOperation(value = "2.查询-基础设置", httpMethod = "GET", notes = "查询-基础设置")
	@ApiOperationSupport(order = 2)
	@Role
	public Result<Object> selectAT(@CurrentUser UserBean userBean){
		
		JxglBasicSetting bS = jxglBasicSettingMapper.selectAll(userBean.getOrgCode());

		return ResultUtil.data(bS);
		
	}
	
	
	
	//TODO 考核模板
	/**
	 * 新增或编辑-考核模板
	 */
	@PostMapping(value = "/save_appraisal_t")
	@ApiOperation(value = "3.新增或编辑-考核模板", httpMethod = "POST", notes = "新增或编辑-考核模板")
	@ApiOperationSupport(order = 3)
	@Role
	public Result<Object> saveAtg(@CurrentUser UserBean userBean ,@Validated @RequestBody JxglAppraisalT jxglAppraisalT) throws Exception{
		
		if (jxglAppraisalT.getId() != null && jxglAppraisalT.selectCount(new QueryWrapper<JxglAppraisalT>().lambda()
				.eq(JxglAppraisalT::getId, jxglAppraisalT.getId())) > 0) {
			jxglAppraisalT.updateById();
		}else {
			jxglAppraisalT.setOrgCode(userBean.getOrgCode());
			jxglAppraisalT.insert();
		}
		LambdaQueryWrapper<JxglAppraisalIndicatorsT> q = new QueryWrapper<JxglAppraisalIndicatorsT>().lambda()
		.eq(JxglAppraisalIndicatorsT::getAppraisalTId, jxglAppraisalT.getId());
		
		List<JxglAppraisalIndicatorsT> listAIT = jxglAppraisalIndicatorsTMapper.selectList(q.select(JxglAppraisalIndicatorsT::getId));
		
		List<Integer> listAITId = listAIT != null && listAIT.size() > 0 ? listAIT.stream().map(JxglAppraisalIndicatorsT::getId).collect(Collectors.toList()) : null;
		
		// 删除 原 考核指标模板
		jxglAppraisalIndicatorsTMapper.delete(q);
		// 删除 原 考核项模板
		if (listAITId != null) {
			jsxglAppraisalItemTMapper.delete(new QueryWrapper<JxglAppraisalItemT>().lambda()
					.in(JxglAppraisalItemT::getAppraisalIndicatorsTId, listAITId));
		}
		
		List<JxglAppraisalIndicatorsT> aITs = jxglAppraisalT.getAppraisalIndicatorsTs();
		for (JxglAppraisalIndicatorsT aIT : aITs) {
			aIT.setAppraisalTId(jxglAppraisalT.getId());
			// 新增 考核指标模板
			if (aIT.insert()) {
				List<JxglAppraisalItemT> aItemTs = aIT.getAppraisalItemTs();
				if (aItemTs != null && aItemTs.size() > 0) {
					// 批量新增 考核项模板
					aItemTs.stream().forEach(aItemT -> aItemT.setAppraisalIndicatorsTId(aIT.getId()));
					int c = jsxglAppraisalItemTMapper.insertList(aItemTs);
				}
			}else {
				throw new Exception();
			}
			
		}

		return ResultUtil.success();
	}
	
	
	/**
	 * 查询-考核模板-列表
	 */
	@PostMapping(value = "/selects_appraisal_t")
	@ApiOperation(value = "4.查询-考核模板-列表", httpMethod = "POST", notes = "查询-考核模板-列表")
	@ApiOperationSupport(order = 4)
	@Role
	public Result<Object> selectListAT(@CurrentUser UserBean userBean,@RequestBody cn.timer.api.utils.Page page){
		
		IPage<JxglAppraisalT> p = new Page<JxglAppraisalT>(page.getCurrentPage(),page.getTotalPage());
		
		IPage<JxglAppraisalT> pageAT = jxglAppraisalTMapper.selectPage(p, new QueryWrapper<JxglAppraisalT>().lambda()
				.eq(JxglAppraisalT::getOrgCode, userBean.getOrgCode()));
		
		List<JxglAppraisalT> listAT = pageAT.getRecords();
		
		return ResultUtil.data(pageAT, listAT);
		
	}
	
	/**
	 * 查询-考核模板-详情
	 */
	@GetMapping(value = "/selects_appraisal_t/{id}")
	@ApiOperation(value = "5.查询-考核模板-详情", httpMethod = "GET", notes = "查询-考核模板-详情")
	@ApiOperationSupport(order = 5)
	@Role
	public Result<Object> selectAT(@CurrentUser UserBean userBean,@PathVariable Integer id){
		
		JxglAppraisalT aT = jxglAppraisalTMapper.selectDetailById(id);

		return ResultUtil.data(aT);
		
	}
	
	/**
	 * 删除-考核模板
	 */
	@DeleteMapping(value = "/del_appraisal_t/{id}")
	@ApiOperation(value = "6.删除-考核模板", httpMethod = "DELETE", notes = "删除-考核模板")
	@ApiOperationSupport(order = 6)
	@Role
	public Result<Object> delAT(@CurrentUser UserBean userBean,@PathVariable Integer id) throws Exception{
		
		jxglAppraisalTMapper.delete(new QueryWrapper<JxglAppraisalT>().lambda()
				.eq(JxglAppraisalT::getId, id)
				.eq(JxglAppraisalT::getOrgCode, userBean.getOrgCode()));

		return ResultUtil.success();
		
	}
	
	@Autowired
	private ZzglBmgwMService zzglBmgwMService;
	
	@Autowired
	private YgglService ygglService;
	
	@Autowired
	private JxglPerformanceAppraisalMapper jxglPerformanceAppraisalMapper;
	
	@Autowired
	private JxglAppraisalMapper jxglAppraisalMapper;
	
	@Autowired
	private JxglAppraisalIndicatorsMapper jxglAppraisalIndicatorsMapper;
	
	@Autowired
	private JxglAppraisalItemMapper jsxglAppraisalItemMapper;
	
	@Autowired
	private JxglAppraisalLogMapper jxglAppraisalLogMapper;
	
	@Autowired
	private YgglMainEmpMapper ygglMainEmpMapper;
	
	/**
	 * 新增-绩效考核
	 */
	@PostMapping(value = "/save_performance_appraisal")
	@ApiOperation(value = "7.新增-绩效考核", httpMethod = "POST", notes = "新增-绩效考核")
	@ApiOperationSupport(order = 7)
	public Result<Object> savePA(@CurrentUser UserBean userBean,@Validated @RequestBody PerformanceAppraisal performanceAppraisal) throws Exception{
		Integer orgCode = userBean.getOrgCode();
		JxglPerformanceAppraisal pA = JxglPerformanceAppraisal.builder().build();
		BeanUtil.copyProperties(performanceAppraisal, pA, "processNode","beingAppraisalPerson","appraisalTId");
		
		List<ProcessNode> listPN = performanceAppraisal.getProcessNode();
		List<BeingAppraisalPerson> listBAP = performanceAppraisal.getBeingAppraisalPerson();
		pA.setOrgCode(orgCode);
		pA.setProcessNode(ObjectUtil.serialize(listPN));
		pA.setBeingAppraisalPerson(ObjectUtil.serialize(listBAP));
		
		// 被考核人员
		List<Integer> listEmpId = listBAP.stream()
			.filter(bAP -> 
				BeingAppraisalType.EMPLOYEE.getType().equals(bAP.getType()) && 
				BeingAppraisalSts.NEED.getType().equals(bAP.getSts()))
			.map(BeingAppraisalPerson::getId)
			.collect(Collectors.toList());

		// 被考核部门id
		List<Integer> listDeptId = listBAP.stream()
				.filter(bAP -> 
					BeingAppraisalType.DEPARTMENT.getType().equals(bAP.getType()))
				.map(BeingAppraisalPerson::getId)
				.collect(Collectors.toList());
		List<YgglMainEmp> listEmp2 = ListUtil.toList();
		for (Integer deptId : listDeptId) {
			CollUtil.addAll(listEmp2, zzglBmgwMService.selectOtherlistent(userBean.getOrgCode(), deptId));
		}
		if (!CollUtil.isEmpty(listEmp2)) {
			// 员工信息数据 去重
			List<Integer> listEmp2Id = listEmp2.stream()
					.filter(StreamUtils.distinctByKey(e -> e.getEmpNum()))
					.map(YgglMainEmp::getEmpNum)
					.collect(Collectors.toList());
			// 合并 集合
			CollUtil.addAll(listEmpId, listEmp2Id);
		}
		
		// 无需被考核人id
		List<Integer> listNotEmpId = listBAP.stream()
				.filter(bAP -> 
					BeingAppraisalType.EMPLOYEE.getType().equals(bAP.getType()) && 
					BeingAppraisalSts.NOT_NEED.getType().equals(bAP.getSts()))
				.map(BeingAppraisalPerson::getId)
				.collect(Collectors.toList());
		
		// 去重+过滤掉 无需被考核人id
		listEmpId = listEmpId.stream().filter(e -> !listNotEmpId.contains(e)).distinct().collect(Collectors.toList());
		pA.setAppraisalPersonNum(listEmpId.size());
		// 新增 绩效考核 
		pA.insert();
		// 考核模板
		JxglAppraisalT aT = jxglAppraisalTMapper.selectById(performanceAppraisal.getAppraisalTId());
		if (aT == null) {
			throw new CustomException("考核模板不存在");
		}
		
		JxglProcessNode processNode = JxglProcessNode.builder().build();
		JxglAppraisal appraisal = JxglAppraisal.builder().build();
		JxglAppraisalIndicators appraisalIndicators = JxglAppraisalIndicators.builder().build();
		JxglAppraisalItem appraisalItem = JxglAppraisalItem.builder().build();
		JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
		
		System.out.println("listEmpId----"+listEmpId);
		for (Integer bAP : listEmpId) {
			// 考核
			appraisal.setPerformanceAppraisalId(pA.getId());
			appraisal.setEmpNum(bAP);
			appraisal.setName(aT.getName());
			appraisal.setAppraisalExplain(aT.getAppraisalExplain());
			appraisal.setSts(AppraisalSts.TARGET_FILL_IN.getType());
			// 新增 考核
			appraisal.insert();
			System.out.println("新增 考核:" + appraisal);
			
//			List<Integer> weights = listPN.stream()
//			.filter(p -> ProcessType.SELF_ASSESSMENT.getType().equals(p.getProcessType()) || 
//						 ProcessType.SUPERIOR_SCORE.getType().equals(p.getProcessType()))
//			.map(ProcessNode::getWeight)
//			.collect(Collectors.toList());
//			Integer weightSum = 0;
//			if (weights != null && weights.size() > 0) {
//				for (Integer i : weights) {
//					weightSum += i;
//				}
//				if (!weightSum.equals(100))
//					throw new CustomException("权重总和要等于 100%");
//			}
			
			listPN.stream().forEach(pN -> {
				Integer executeType = pN.getExecuteType();
				// 流程节点
				processNode.setAppraisalId(appraisal.getId());
				processNode.setExecuteType(executeType);
				processNode.setLeaderTier(pN.getLeaderTier());
				processNode.setName(ExecuteType.getName(executeType));
				Integer processType = pN.getProcessType();
				processNode.setProcessType(processType);
				if (ProcessType.TARGET_FILL_IN.getType().equals(processType)) {
					processNode.setSts(ProcessNodeSts.IN_EXECUTION.getType());
				}else {
					processNode.setSts(ProcessNodeSts.NON_EXECUTION.getType());
				}
				processNode.setWeight(pN.getWeight());
				
				if (ExecuteType.BEING_APPRAISAL_PERSON.getType().equals(executeType)) {
					processNode.setExecutorId(bAP);
				}else if (ExecuteType.LEADER.getType().equals(executeType)) {
					processNode.setExecutorId(ygglService.selectLeaderEmpNumById(userBean.getOrgCode(), bAP, pN.getLeaderTier()));
				}else if (ExecuteType.SPECIFIED_MEMBER.getType().equals(executeType)) {
					processNode.setExecutorId(pN.getExecutorId());
				}
				// 新增 流程节点
				processNode.insert();
				System.out.println("新增 流程节点:" + processNode);
				
			});
			
			List<JxglAppraisalIndicatorsT> listAIT = jxglAppraisalIndicatorsTMapper.selectList(new QueryWrapper<JxglAppraisalIndicatorsT>().lambda()
					.eq(JxglAppraisalIndicatorsT::getAppraisalTId, aT.getId())
					.ne(aT.getIsUseFixd() == 1 ,JxglAppraisalIndicatorsT::getType, IndicatorsType.FIXATION.getType())
					.ne(aT.getIsUseNotFixd() == 1 ,JxglAppraisalIndicatorsT::getType, IndicatorsType.NOT_FIXATION.getType()));
		
			if (listAIT == null || listAIT.size() <= 0) {
				throw new CustomException("考核指标不存在");
			}
			
			listAIT.stream().forEach(aIT -> {
					// 考核指标
					BeanUtil.copyProperties(aIT, appraisalIndicators, "appraisalId", "createTime", "updateTime");
					appraisalIndicators.setAppraisalId(appraisal.getId());
					// 新增 考核指标
					appraisalIndicators.insert();
//					System.out.println("新增 考核指标:" + appraisalIndicators);
					
					List<JxglAppraisalItemT> listAItemT = jsxglAppraisalItemTMapper.selectList(new QueryWrapper<JxglAppraisalItemT>().lambda()
							.eq(JxglAppraisalItemT::getAppraisalIndicatorsTId, aIT.getId()));
					
					if (listAItemT != null && listAItemT.size() > 0) {
						listAItemT.stream().forEach(aItemT -> {
							BeanUtil.copyProperties(aItemT, appraisalItem, "appraisalIndicatorsTId");
							appraisalItem.setAppraisalIndicatorsId(appraisalIndicators.getId());
							
							// 新增 考核项
							appraisalItem.insert();
//							System.out.println("新增 考核项:" + appraisalItem);
						});
					}
					
			});
			
			YgglMainEmp yME = ygglMainEmpMapper.selectOne(new QueryWrapper<YgglMainEmp>().lambda()
					.select(YgglMainEmp::getName)
					.eq(YgglMainEmp::getOrgCode, orgCode)
					.eq(YgglMainEmp::getEmpNum, bAP));
			
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(bAP);
			appraisalLog.setExecutorName(yME.getName());
			appraisalLog.setType(AppraisalLogType.START.getType());
			appraisalLog.insert();
		}
		
		return ResultUtil.success();
	}
	
	/**
	 * 删除-绩效考核
	 */
	@DeleteMapping(value = "/delete_performance_appraisal/{id}")
	@ApiOperation(value = "8.删除-绩效考核", httpMethod = "DELETE", notes = "删除-绩效考核")
	@ApiOperationSupport(order = 8)
	@Role
	public Result<Object> deletePA(@CurrentUser UserBean userBean,@PathVariable Integer id){
		
		JxglPerformanceAppraisal pA = jxglPerformanceAppraisalMapper.selectOne(new QueryWrapper<JxglPerformanceAppraisal>().lambda()
				.eq(JxglPerformanceAppraisal::getId, id)
				.eq(JxglPerformanceAppraisal::getOrgCode, userBean.getOrgCode()));
		
		if (pA == null) {
			return ResultUtil.error("绩效考核不存在");
		}
		
		List<Integer> aIds = CollUtil.toList();
		List<Integer> aIIds = CollUtil.toList();
		
		List<JxglAppraisal> listA = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
				.select(JxglAppraisal::getId)
				.eq(JxglAppraisal::getPerformanceAppraisalId, pA.getId()));
		
		aIds = listA != null && listA.size() > 0 ? listA.stream().map(JxglAppraisal::getId).collect(Collectors.toList()) : aIds;
		
		// 删除 绩效考核
		jxglPerformanceAppraisalMapper.deleteById(id);
		
		if (aIds.size() > 0) {
			
			// 批量删除 考核
			jxglAppraisalMapper.deleteBatchIds(aIds);
			
			// 批量删除 流程节点
			jxglProcessNodeMapper.delete(new QueryWrapper<JxglProcessNode>().lambda()
					.eq(aIds.size() == 1, JxglProcessNode::getAppraisalId, aIds)
					.in(aIds.size() > 1, JxglProcessNode::getAppraisalId, aIds));
			// 批量删除 考核评定
			jxglAppraisalAssessmentMapper.delete(new QueryWrapper<JxglAppraisalAssessment>().lambda()
					.eq(aIds.size() == 1, JxglAppraisalAssessment::getAppraisalId, aIds)
					.in(aIds.size() > 1, JxglAppraisalAssessment::getAppraisalId, aIds));
			// 批量删除 考核记录
			jxglAppraisalLogMapper.delete(new QueryWrapper<JxglAppraisalLog>().lambda()
					.eq(aIds.size() == 1, JxglAppraisalLog::getAppraisalId, aIds)
					.in(aIds.size() > 1, JxglAppraisalLog::getAppraisalId, aIds));
			
			List<JxglAppraisalIndicators> listAI = jxglAppraisalIndicatorsMapper.selectList(new QueryWrapper<JxglAppraisalIndicators>().lambda()
					.select(JxglAppraisalIndicators::getId)
					.eq(aIds.size() == 1, JxglAppraisalIndicators::getAppraisalId, aIds)
					.in(aIds.size() > 1, JxglAppraisalIndicators::getAppraisalId, aIds));
			
			aIIds = listAI != null && listAI.size() > 0 ? listAI.stream().map(JxglAppraisalIndicators::getId).collect(Collectors.toList()) : aIIds;
		
			if (aIIds.size() > 0) {
				
				jxglAppraisalIndicatorsMapper.deleteBatchIds(aIIds);
				
				// 批量删除 考核指标评定
				jxglAppraisalIndicatorsAssessmentMapper.delete(new QueryWrapper<JxglAppraisalIndicatorsAssessment>().lambda()
						.eq(aIds.size() == 1, JxglAppraisalIndicatorsAssessment::getAppraisalIndicatorsId, aIIds)
						.in(aIds.size() > 1, JxglAppraisalIndicatorsAssessment::getAppraisalIndicatorsId, aIIds));
				
				// 批量删除 考核项
				jxglAppraisalItemMapper.delete(new QueryWrapper<JxglAppraisalItem>().lambda()
						.eq(aIds.size() == 1, JxglAppraisalItem::getAppraisalIndicatorsId, aIIds)
						.in(aIds.size() > 1, JxglAppraisalItem::getAppraisalIndicatorsId, aIIds));
				
			}
		}
		
		return ResultUtil.success();
	}
	
	/**
	 * 修改-绩效管理状态
	 */
	@PostMapping(value = "/update_performance_appraisal_sts")
	@ApiOperation(value = "8.修改-绩效管理状态", httpMethod = "POST", notes = "修改-绩效管理状态")
	@ApiOperationSupport(order = 8)
	public Result<Object> updatePAS(@CurrentUser UserBean userBean,@RequestBody AppraisalUpdateSts appraisalUpdateSts){
		
		JxglPerformanceAppraisal performanceAppraisal = jxglPerformanceAppraisalMapper.selectOne(new QueryWrapper<JxglPerformanceAppraisal>().lambda()
				.eq(JxglPerformanceAppraisal::getId, appraisalUpdateSts.getId())
				.eq(JxglPerformanceAppraisal::getSts, appraisalUpdateSts.getSts())
				);
		
		if (performanceAppraisal == null) {
			return ResultUtil.error("绩效考核不存在");
		}
		if (performanceAppraisal.getSts() == PerformanceAppraisalSts.TERMINATION_ASSESSMENT.getType()) {
			return ResultUtil.error("考核已终止");
		}
		
		Integer sts = null;
		Integer id = performanceAppraisal.getId();
		
		List<JxglAppraisal> listA = CollUtil.toList();
		List<Integer> aIds =  CollUtil.toList();
		List<JxglProcessNode> listPN = CollUtil.toList();
		List<Integer> pNIds = CollUtil.toList();
		
		
		switch (performanceAppraisal.getSts()) {
		case 0:
			sts = PerformanceAppraisalSts.PERFORMANCE_SCORE.getType();
			
			listA = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
					.select(JxglAppraisal::getId)
					.eq(JxglAppraisal::getPerformanceAppraisalId, id));
			
			if (listA != null && listA.size() > 0) {
				aIds = listA.stream().map(JxglAppraisal::getId).collect(Collectors.toList());
				
				listPN = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
						.in(JxglProcessNode::getAppraisalId, aIds)
						.eq(JxglProcessNode::getProcessType, ProcessType.TARGET_CONFIRMED.getType())
						.eq(JxglProcessNode::getSts,  ProcessNodeSts.EXECUTED.getType()));
				
				if (listPN != null && listPN.size() > 0) {
					aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());
					System.out.println("1------"+ aIds);
					listPN = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
							.in(JxglProcessNode::getAppraisalId, aIds)
							.eq(JxglProcessNode::getProcessType, ProcessType.SELF_ASSESSMENT.getType())
							.eq(JxglProcessNode::getSts, ProcessNodeSts.NON_EXECUTION.getType()));
					if (listPN != null && listPN.size() > 0) {
						pNIds = listPN.stream().map(JxglProcessNode::getId).collect(Collectors.toList());
						aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());
						System.out.println("2------"+ pNIds);
						System.out.println("3------"+ aIds);
						JxglProcessNode.builder().sts(ProcessNodeSts.IN_EXECUTION.getType()).build().update(new UpdateWrapper<JxglProcessNode>().lambda()
								.in(JxglProcessNode::getId, pNIds));
						
						JxglAppraisal.builder().sts(AppraisalSts.SELF_ASSESSMENT.getType()).build().update(new UpdateWrapper<JxglAppraisal>().lambda()
								.in(JxglAppraisal::getId, aIds));
						
					}
					
				}
				
			}
			
			break;
		case 1:
			sts = PerformanceAppraisalSts.RESULT_VERIFICATION.getType();
			
			listA = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
					.select(JxglAppraisal::getId)
					.eq(JxglAppraisal::getPerformanceAppraisalId, id));
			
			if (listA != null && listA.size() > 0) {
				aIds = listA.stream().map(JxglAppraisal::getId).collect(Collectors.toList());
				
				listPN = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
						.in(JxglProcessNode::getAppraisalId, aIds)
						.eq(JxglProcessNode::getProcessType, ProcessType.SUPERIOR_SCORE.getType())
						.eq(JxglProcessNode::getSts,  ProcessNodeSts.EXECUTED.getType()));
				
				if (listPN != null && listPN.size() > 0) {
					aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());
					
					listPN = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
							.in(JxglProcessNode::getAppraisalId, aIds)
							.eq(JxglProcessNode::getProcessType, ProcessType.RESULT_VERIFICATION.getType())
							.eq(JxglProcessNode::getSts, ProcessNodeSts.NON_EXECUTION.getType()));
					if (listPN != null && listPN.size() > 0) {
						pNIds = listPN.stream().map(JxglProcessNode::getId).collect(Collectors.toList());
						aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());
						
						JxglProcessNode.builder().sts(ProcessNodeSts.IN_EXECUTION.getType()).build().update(new UpdateWrapper<JxglProcessNode>().lambda()
								.in(JxglProcessNode::getId, pNIds));
						
						JxglAppraisal.builder().sts(AppraisalSts.RESULT_VERIFICATION.getType()).build().update(new UpdateWrapper<JxglAppraisal>().lambda()
								.in(JxglAppraisal::getId, aIds));
						
					}
					
				}
				
			}
			break;
		case 2:
			sts = PerformanceAppraisalSts.PERFORMANCE_ARCHIVE.getType();
			
			listA = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
					.select(JxglAppraisal::getId)
					.eq(JxglAppraisal::getPerformanceAppraisalId, id));
			
			if (listA != null && listA.size() > 0) {
				aIds = listA.stream().map(JxglAppraisal::getId).collect(Collectors.toList());
				
				listPN = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
						.in(JxglProcessNode::getAppraisalId, aIds)
						.eq(JxglProcessNode::getProcessType, ProcessType.RESULT_VERIFICATION.getType())
						.eq(JxglProcessNode::getSts,  ProcessNodeSts.EXECUTED.getType()));
				
				if (listPN != null && listPN.size() > 0) {
					aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());
					
					listPN = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
							.in(JxglProcessNode::getAppraisalId, aIds)
							.eq(JxglProcessNode::getProcessType, ProcessType.TARGET_CONFIRMED.getType())
							.eq(JxglProcessNode::getSts, ProcessNodeSts.NON_EXECUTION.getType()));
					if (listPN != null && listPN.size() > 0) {
						pNIds = listPN.stream().map(JxglProcessNode::getId).collect(Collectors.toList());
						aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());
						
						JxglProcessNode.builder().sts(ProcessNodeSts.IN_EXECUTION.getType()).build().update(new UpdateWrapper<JxglProcessNode>().lambda()
								.in(JxglProcessNode::getId, pNIds));
						
						JxglAppraisal.builder().sts(AppraisalSts.SELF_ASSESSMENT.getType()).build().update(new UpdateWrapper<JxglAppraisal>().lambda()
								.in(JxglAppraisal::getId, aIds));
						
					}
					
				}
				
			}
			break;
		default:
			break;
		}
		
		// 修改 绩效考核状态
		jxglPerformanceAppraisalMapper.updateById(JxglPerformanceAppraisal.builder()
				.id(appraisalUpdateSts.getId())
				.sts(sts)
				.build());
		
		// 修改 考核状态
		jxglAppraisalMapper.update(JxglAppraisal.builder()
				.performanceAppraisalId(appraisalUpdateSts.getId())
				.sts(sts)
				.build(), new UpdateWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getPerformanceAppraisalId, appraisalUpdateSts.getId())
				.eq(JxglAppraisal::getSts, AppraisalSts.TARGET_CONFIRMED.getType())
				);
		
		return ResultUtil.success();
	}
	
	/**
	 * 删除-所有-绩效考核
	 */
	@DeleteMapping(value = "/delete_all_pa")
	@ApiOperation(value = "99.删除-所有-绩效考核", httpMethod = "DELETE", notes = "删除-所有-绩效考核")
	@ApiOperationSupport(order = 99)
	@Role
	public Result<Object> deleteAllPA(@CurrentUser UserBean userBean){
		
			jxglPerformanceAppraisalMapper.delete(null);
			jxglAppraisalMapper.delete(null);
			jxglProcessNodeMapper.delete(null);
			jxglAppraisalAssessmentMapper.delete(null);
			jxglAppraisalLogMapper.delete(null);
			jxglAppraisalIndicatorsMapper.delete(null);
			jxglAppraisalIndicatorsAssessmentMapper.delete(null);
			jxglAppraisalItemMapper.delete(null);
		
		return ResultUtil.success("删除-所有-绩效考核");
	}
	
	/**
	 * 查询-绩效考核-列表-归档
	 */
	@PostMapping(value = "/selects_performance_appraisal_archive")
	@ApiOperation(value = "8.查询-绩效考核-列表-归档", httpMethod = "POST", notes = "查询-绩效考核-列表-归档")
	@ApiOperationSupport(order = 8)
	@Role
	public Result<Object> selectsPAArchive(@CurrentUser UserBean userBean,@RequestBody PerformanceAppraisalQuery query){
		
		IPage<SpmkApproveSummary> page = new Page<SpmkApproveSummary>(query.getCurrentPage(),query.getTotalPage());
		
		query.setOrgCode(userBean.getOrgCode());
		
		IPage<JxglPerformanceAppraisal> pagePA = jxglPerformanceAppraisalMapper.selectArchiveListByQuery(page, query);
		
		List<JxglPerformanceAppraisal> listPA = pagePA.getRecords();

		return ResultUtil.data(pagePA,listPA);
		
	}
	
	/**
	 * 查询-绩效考核-列表-非归档
	 */
	@PostMapping(value = "/selects_performance_appraisal")
	@ApiOperation(value = "9.查询-绩效考核-列表-非归档", httpMethod = "POST", notes = "查询-绩效考核-列表-非归档")
	@ApiOperationSupport(order = 9)
	@Role
	public Result<Object> selectsPA(@CurrentUser UserBean userBean,@RequestBody PerformanceAppraisalQuery query){
		
		IPage<SpmkApproveSummary> page = new Page<SpmkApproveSummary>(query.getCurrentPage(),query.getTotalPage());
		
		query.setOrgCode(userBean.getOrgCode());
		
		IPage<JxglPerformanceAppraisal> pagePA = jxglPerformanceAppraisalMapper.selectListByQuery(page, query);
		
		List<JxglPerformanceAppraisal> listPA = pagePA.getRecords();

		return ResultUtil.data(pagePA,listPA);
		
	}
	
	/**
	 * 查询-考核-列表
	 */
	@PostMapping(value = "/selects_appraisal")
	@ApiOperation(value = "10.查询-考核-列表", httpMethod = "POST", notes = "查询-考核-列表")
	@ApiOperationSupport(order = 10)
	@Role
	public Result<Object> selectsA(@CurrentUser UserBean userBean,@RequestBody AppraisalQuery query){
		
		IPage<JxglAppraisal> page = new Page<JxglAppraisal>(query.getCurrentPage(),query.getTotalPage());
		query.setOrgCode(userBean.getOrgCode());
		
		IPage<JxglAppraisal> pageA = jxglAppraisalMapper.selectListByQuery(page, query);
		
		List<JxglAppraisal> listPA = pageA.getRecords();

		return ResultUtil.data(pageA,listPA);
		
	}
	
	/**
	 * 查询-考核-详情
	 */
	@GetMapping(value = "/select_appraisal/{id}")
	@ApiOperation(value = "11.查询-考核-详情", httpMethod = "GET", notes = "查询-考核-详情")
	@ApiOperationSupport(order = 11)
	@Role
	public Result<Object> selectA(@CurrentUser UserBean userBean,@PathVariable Integer id){
		
		AppraisalDetail aD = jxglAppraisalMapper.selectDetailById(userBean.getOrgCode(), id);
		
		if (aD != null) {
			JxglPerformanceAppraisal pA = jxglPerformanceAppraisalMapper.selectOne(new QueryWrapper<JxglPerformanceAppraisal>().lambda()
					.eq(JxglPerformanceAppraisal::getId, aD.getPerformanceAppraisalId()));
			
			if (pA != null && pA.getIsVisible() == 0) {
				return ResultUtil.data(aD);
			}else {
				List<JxglAppraisalAssessment> listAA = aD.getAppraisalAssessments();
				if (listAA != null) {
					listAA = listAA.stream().filter(a -> !userBean.getEmpNum().equals(a.getAssessorId())).collect(Collectors.toList());
					aD.setAppraisalAssessments(listAA);
				}
			}
		}
		
		return ResultUtil.data(aD);
		
	}
	
	/**
	 * 修改-流程执行人-转派
	 */
	@PutMapping(value = "/update_process_node")
	@ApiOperation(value = "12.修改-流程执行人-转派", httpMethod = "PUT", notes = "修改-流程执行人-转派")
	@ApiOperationSupport(order = 12)
	@Role
	public Result<Object> updatePN(@CurrentUser UserBean userBean,@Validated @RequestBody ProcessNodeUpdate processNodeUpdate){
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, processNodeUpdate.getAppraisalId())
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核 不存在");
		}
		
		Integer count = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, processNodeUpdate.getAppraisalId())
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		count = jxglProcessNodeMapper.selectCount(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, processNodeUpdate.getAppraisalId())
				.ne(JxglProcessNode::getSts, ProcessNodeSts.EXECUTED.getType()));
		
		if (count <= 0) {
			return ResultUtil.error("流程已执行,无法更改");
		}
		
		JxglProcessNode pN = JxglProcessNode.builder().build();
		BeanUtil.copyProperties(processNodeUpdate, pN);
		
		pN.updateById();
		
		return ResultUtil.data(pN);
	}
	
	/**
	 * 终止-考核
	 */
	@PutMapping(value = "/termination_assessment")
	@ApiOperation(value = "13.终止-考核", httpMethod = "PUT", notes = "终止-考核")
	@ApiOperationSupport(order = 13)
	@Role
	public Result<Object> terminationAssessment(@CurrentUser UserBean userBean,@NotNull @RequestParam Integer id){
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectById(id);
		
		if (appraisal == null) {
			return ResultUtil.error("考核 不存在");
		}else if (appraisal.getSts() <= AppraisalSts.RESULT_VERIFICATION.getType() ) {
			JxglAppraisal.builder().id(id).sts(AppraisalSts.TERMINATION_ASSESSMENT.getType()).build().updateById();
		}else if (appraisal.getSts() == AppraisalSts.ASSESSMENT_COMPLETE.getType()) {
			return ResultUtil.error("考核已完成，无法终止");
		}else if (appraisal.getSts() == AppraisalSts.TERMINATION_ASSESSMENT.getType()) {
			return ResultUtil.error("考核已终止，无法重复终止");
		}else if (appraisal.getSts() == AppraisalSts.PERFORMANCE_ARCHIVE.getType()) {
			return ResultUtil.error("考核已归档，无法终止");
		}
		return ResultUtil.success();
	}
	
	@Autowired
	private JxglAppraisalAssessmentMapper appraisalAssessmentMapper;
	
	@Autowired
	private JxglProcessNodeMapper processNodeMapper;
	
	/**
	 * 新增-考核评定
	 */
	@PutMapping(value = "/save_appraisal_assessment")
	@ApiOperation(value = "13.新增-考核评定", httpMethod = "PUT", notes = "新增-考核评定")
	@ApiOperationSupport(order = 13)
	public Result<Object> saveAA(@CurrentUser UserBean userBean,@RequestBody JxglAppraisalAssessment appraisalAssessment){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalAssessment.getAppraisalId())
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		Integer empNum =  userBean.getEmpNum();
		
		JxglProcessNode pN = processNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.in(JxglProcessNode::getProcessType, ProcessType.SELF_ASSESSMENT,ProcessType.SUPERIOR_SCORE));
		
		if (pN == null) {
			return ResultUtil.error("在该流程状态 无法评价");
		}else if (!empNum.equals(pN.getExecutorId())) {
			return ResultUtil.error("无权限 评价");
		}
		
		appraisalAssessment.setAssessorName(userBean.getUserInfo().getName());
		appraisalAssessment.setAssessorId(userBean.getEmpNum());
		appraisalAssessment.insert();
		
		return ResultUtil.data(appraisalAssessment);
	}
	
	/**
	 * 查询-所有员工绩效-汇总
	 */
	@PostMapping(value = "/selects_emp_performance")
	@ApiOperation(value = "14.查询-所有员工绩效-汇总", httpMethod = "POST", notes = "查询-所有员工绩效-汇总")
	@ApiOperationSupport(order = 14)
	@Role
	public Result<Object> selectsEP(@CurrentUser UserBean userBean,@RequestBody EmpPerformanceQuery query){
		
		IPage<JxglAppraisal> page = new Page<JxglAppraisal>(query.getCurrentPage(),query.getTotalPage());
		query.setOrgCode(userBean.getOrgCode());
		
		IPage<JxglAppraisal> pageA = jxglAppraisalMapper.selectListEmpByQuery(page, query);
		
		List<JxglAppraisal> listA = pageA.getRecords();

		return ResultUtil.data(pageA,listA);
		
	}
	
	/**
	 * 查询-某员工考核-列表
	 */
	@PostMapping(value = "/selects_emp_appraisal")
	@ApiOperation(value = "15.查询-某员工考核-列表", httpMethod = "POST", notes = "查询-某员工考核-列表")
	@ApiOperationSupport(order = 15)
	@Role
	public Result<Object> selectsEA(@CurrentUser UserBean userBean,@RequestBody EmpAppraisalQuery query){
		
		IPage<JxglPerformanceAppraisal> page = new Page<JxglPerformanceAppraisal>(query.getCurrentPage(),query.getTotalPage());
		query.setOrgCode(userBean.getOrgCode());
		
		IPage<JxglPerformanceAppraisal> pagePA = jxglPerformanceAppraisalMapper.selectListEmpByQuery(page, query);
		
		List<JxglPerformanceAppraisal> listPA = pagePA.getRecords();

		return ResultUtil.data(pagePA,listPA);
		
	}
	
	/**
	 * 查询-绩效考核-方案
	 */
	@GetMapping(value = "/selects_performance_appraisal/{id}")
	@ApiOperation(value = "16.查询-绩效考核-方案", httpMethod = "GET", notes = "查询-绩效考核-方案")
	@ApiOperationSupport(order = 16)
	@Role
	public Result<Object> selectPA(@CurrentUser UserBean userBean,@PathVariable Integer id){
		
		JxglPerformanceAppraisal pA = jxglPerformanceAppraisalMapper.selectById(id);
		if (pA == null) {
			return ResultUtil.error("方案不存在");
		}
		PerformanceAppraisal paDto = PerformanceAppraisal.builder()
				.name(pA.getName())
				.period(pA.getPeriod())
				.appraisalStartTime(pA.getAppraisalStartTime())
				.appraisalEndTime(pA.getAppraisalEndTime())
				.isVisible(pA.getIsVisible())
				.scope(pA.getScope())
				.appraisalTName(pA.getAppraisalTName())
				.processNode(ObjectUtil.deserialize(pA.getProcessNode()))
				.beingAppraisalPerson(ObjectUtil.deserialize(pA.getBeingAppraisalPerson()))
				.build();
		
		return ResultUtil.data(paDto);
		
	}
	
	/**
	 * 查询-我的绩效-列表
	 */
	@PostMapping(value = "/selects_my_performance")
	@ApiOperation(value = "17.查询-我的绩效-列表", httpMethod = "POST", notes = "查询-我的绩效-列表")
	@ApiOperationSupport(order = 17)
	public Result<Object> selects(@CurrentUser UserBean userBean,@RequestBody MyPerformance query){
		
		IPage<JxglPerformanceAppraisal> page = new Page<JxglPerformanceAppraisal>(query.getCurrentPage(),query.getTotalPage());
		query.setOrgCode(userBean.getOrgCode());
		query.setId(userBean.getEmpNum());
		IPage<JxglPerformanceAppraisal> pagePA = jxglPerformanceAppraisalMapper.selectMyByQuery(page, query);
		
		List<JxglPerformanceAppraisal> listPA = pagePA.getRecords();

		return ResultUtil.data(pagePA,listPA);
		
	}
	
	@Autowired
	private JxglProcessNodeMapper jxglProcessNodeMapper;
	@Autowired
	private JxglAppraisalItemMapper jxglAppraisalItemMapper;
	
	/**
	 * 目标填写-保存
	 */
	@PostMapping(value = "/save_target_fill")
	@ApiOperation(value = "17.目标填写-保存", httpMethod = "POST", notes = "目标填写-保存")
	@ApiOperationSupport(order = 17)
	public Result<Object> saveTF(@CurrentUser UserBean userBean,@RequestBody AppraisalUpdate appraisalUpdate) throws Exception{
		
		
		
		Integer id = appraisalUpdate.getId();
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核不存在");
		}
		
		List<JxglAppraisalIndicators> listAI2 = appraisalUpdate.getAppraisalIndicators();
		
		if (listAI2 == null) {
			return ResultUtil.error("考核指标不能为空");
		}
		
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.TARGET_FILL_IN.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}
			
		}else {
			return ResultUtil.error("流程状态异常");
		}
		
		// 查找 非固定 考核指标
		List<JxglAppraisalIndicators>  listAI = jxglAppraisalIndicatorsMapper.selectList(new QueryWrapper<JxglAppraisalIndicators>().lambda()
				.select(JxglAppraisalIndicators::getId)
				.eq(JxglAppraisalIndicators::getType, IndicatorsType.NOT_FIXATION.getType())
				.eq(JxglAppraisalIndicators::getAppraisalId, id));
		
		List<Integer> appraisalIndicatorIds = listAI != null ? listAI.stream().map(JxglAppraisalIndicators::getId).collect(Collectors.toList()) : null;
		
		if (appraisalIndicatorIds != null) {
			
			// 删除 考核项
			jxglAppraisalItemMapper.delete(new QueryWrapper<JxglAppraisalItem>().lambda()
					.in(JxglAppraisalItem::getAppraisalIndicatorsId, appraisalIndicatorIds));
		}
		
		// 删除 考核指标
		jxglAppraisalIndicatorsMapper.delete(new QueryWrapper<JxglAppraisalIndicators>().lambda()
				.eq(JxglAppraisalIndicators::getType, IndicatorsType.NOT_FIXATION.getType())
				.eq(JxglAppraisalIndicators::getAppraisalId, id));
		
		listAI2.forEach(aI -> {
			aI.setAppraisalId(id);
			aI.setType(IndicatorsType.NOT_FIXATION.getType());
			if (aI.insert()) {
				List<JxglAppraisalItem> listAItem = aI.getAppraisalItems();
				if (listAItem != null && listAItem.size() > 0) {
					for (JxglAppraisalItem aItem : listAItem) {
						aItem.setAppraisalIndicatorsId(aI.getId());
						aItem.insert();
					}
				}
			}else {
				throw new CustomException("保存异常");
			}
			
		});
		
		listAI = jxglAppraisalIndicatorsMapper.selectList(new QueryWrapper<JxglAppraisalIndicators>().lambda()
				.select(JxglAppraisalIndicators::getWeight)
				.eq(JxglAppraisalIndicators::getAppraisalId, id));
		
		List<Integer> listWeight = listAI.stream().map(JxglAppraisalIndicators::getWeight).collect(Collectors.toList());
		Integer weightSum = 0;
		if (listWeight != null && listWeight.size() > 0) {
			for (Integer i : listWeight) {
				weightSum += i;
				System.out.println("权重:"+ i);
			}
			if (!weightSum.equals(100))
				return ResultUtil.error("权重总和要等于 100%");
		}
		
		return ResultUtil.success();
	}
	
	/**
	 * 目标填写-提交
	 */
	@PostMapping(value = "/submit_target_fill")
	@ApiOperation(value = "17.目标填写-提交", httpMethod = "POST", notes = "目标填写-提交")
	@ApiOperationSupport(order = 17)
	public Result<Object> submitTF(@CurrentUser UserBean userBean,@RequestParam Integer id){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.TARGET_FILL_IN.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}
			
			List<JxglAppraisalIndicators> listAI = jxglAppraisalIndicatorsMapper.selectList(new QueryWrapper<JxglAppraisalIndicators>().lambda()
					.eq(JxglAppraisalIndicators::getAppraisalId, appraisal.getId()));
			
			if (listAI == null) {
				return ResultUtil.error("考核指标不能为空");
			}
			List<Integer> listWeight = listAI.stream().map(JxglAppraisalIndicators::getWeight).collect(Collectors.toList());
			Integer weightSum = 0;
			if (listWeight != null && listWeight.size() > 0) {
				for (Integer i : listWeight) {
					weightSum += i;
				}
				if (!weightSum.equals(100))
					return ResultUtil.error("权重总和要等于 100%");
			}
			// 修改 目标填写 状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.EXECUTED.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
			
			// 修改 下一个节点状态
			JxglProcessNode
			.builder()
			.sts(ProcessNodeSts.IN_EXECUTION.getType())
			.build()
			.update(new UpdateWrapper<JxglProcessNode>().lambda()
					.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
					.eq(JxglProcessNode::getProcessType, ProcessType.TARGET_CONFIRMED.getType()));
			
			jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(id).sts(AppraisalSts.TARGET_CONFIRMED.getType()).build());
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.TARGET_FILL_IN.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
		
	}
	
	/**
	 * 目标确认-同意
	 */
	@PostMapping(value = "/update_target_confirmed")
	@ApiOperation(value = "18.目标确认-同意", httpMethod = "POST", notes = "目标确认-同意")
	@ApiOperationSupport(order = 18)
	public Result<Object> updateTC(@CurrentUser UserBean userBean,@RequestParam Integer id){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.TARGET_CONFIRMED.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}


			// 修改 目标确认  状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.EXECUTED.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
			JxglPerformanceAppraisal pA = jxglPerformanceAppraisalMapper.selectById(appraisal.getPerformanceAppraisalId());
			if (pA != null && pA.getSts() > PerformanceAppraisalSts.TARGET_SETING.getType()) {
				// 修改 下一个节点状态
				JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.IN_EXECUTION.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getProcessType, ProcessType.SELF_ASSESSMENT.getType()));
				
				jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId()).sts(AppraisalSts.SELF_ASSESSMENT.getType()).build());
			}
			
			
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.TARGET_CONFIRMED.getType());
			appraisalLog.insert();
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
		
	}
	
	/**
	 * 目标确认-驳回目标
	 */
	@PostMapping(value = "/update_target_confirmed_reject")
	@ApiOperation(value = "18.目标确认-驳回目标", httpMethod = "POST", notes = "目标确认-驳回目标")
	@ApiOperationSupport(order = 18)
	public Result<Object> updateTCR(@CurrentUser UserBean userBean, @RequestBody AppraisalReject appraisalReject){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalReject.getId())
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalReject.getId())
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核 不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.TARGET_CONFIRMED.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}


			// 修改 目标确认  状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.NON_EXECUTION.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.in(JxglProcessNode::getProcessType, ProcessType.TARGET_CONFIRMED.getType())
						);
			
			JxglProcessNode
			.builder()
			.sts(ProcessNodeSts.IN_EXECUTION.getType())
			.build()
			.update(new UpdateWrapper<JxglProcessNode>().lambda()
					.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
					.eq(JxglProcessNode::getProcessType, ProcessType.TARGET_FILL_IN.getType()));
			
			jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId()).sts(AppraisalSts.TARGET_FILL_IN.getType()).build());
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setRemarks(appraisalReject.getRejectReason());
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.TARGET_DISMISS.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
		
	}
	
	/**
	 * 上级评价 -驳回目标
	 */
	@PostMapping(value = "/update_superior_score_reject")
	@ApiOperation(value = "19.上级评价 -驳回目标", httpMethod = "POST", notes = "上级评价 -驳回目标")
	@ApiOperationSupport(order = 19)
	public Result<Object> updateSSR(@CurrentUser UserBean userBean, @RequestBody AppraisalReject appraisalReject){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalReject.getId())
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalReject.getId())
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核 不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}


			// 修改 目标确认  状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.NON_EXECUTION.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.in(JxglProcessNode::getProcessType, ProcessType.TARGET_CONFIRMED.getType(),
								ProcessType.SELF_ASSESSMENT.getType())
						);
			
			JxglProcessNode
			.builder()
			.sts(ProcessNodeSts.IN_EXECUTION.getType())
			.build()
			.update(new UpdateWrapper<JxglProcessNode>().lambda()
					.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
					.eq(JxglProcessNode::getProcessType, ProcessType.TARGET_FILL_IN.getType()));
			
			// 删除 考核评定-自评
			jxglAppraisalAssessmentMapper.delete(new QueryWrapper<JxglAppraisalAssessment>().lambda()
					.eq(JxglAppraisalAssessment::getAppraisalId, appraisal.getId())
					.eq(JxglAppraisalAssessment::getType, AssessmentType.SELF_ASSESSMENT.getType()));
			
			List<JxglAppraisalIndicators> listAI = jxglAppraisalIndicatorsMapper.selectList(new QueryWrapper<JxglAppraisalIndicators>().lambda()
					.select(JxglAppraisalIndicators::getId)
					.eq(JxglAppraisalIndicators::getAppraisalId, appraisal.getId()));
			List<Integer> listAIId = listAI != null && listAI.size() > 0 ? listAI.stream().map(JxglAppraisalIndicators::getId).collect(Collectors.toList()) : null;
			// 删除 考核指标评定-自评
			jxglAppraisalIndicatorsAssessmentMapper.delete(new QueryWrapper<JxglAppraisalIndicatorsAssessment>().lambda()
					.in(JxglAppraisalIndicatorsAssessment::getAppraisalIndicatorsId, listAIId)
					.eq(JxglAppraisalIndicatorsAssessment::getType, AssessmentType.SELF_ASSESSMENT.getType()));
			
			jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId()).sts(AppraisalSts.TARGET_FILL_IN.getType()).build());
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setRemarks(appraisalReject.getRejectReason());
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.TARGET_DISMISS.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
		
	}
	
	/**
	 * 上级评价 -驳回评分
	 */
	@PostMapping(value = "/update_superior_reject_score")
	@ApiOperation(value = "20.上级评价 -驳回评分", httpMethod = "POST", notes = "上级评价 -驳回评分")
	@ApiOperationSupport(order = 20)
	public Result<Object> updateSRS(@CurrentUser UserBean userBean, @RequestBody AppraisalReject appraisalReject){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalReject.getId())
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalReject.getId())
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限操作该流程");
			}

			// 修改  状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.NON_EXECUTION.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getProcessType, ProcessType.SUPERIOR_SCORE.getType())
						);
			
			// 修改 上一个节点状态
			JxglProcessNode
			.builder()
			.sts(ProcessNodeSts.IN_EXECUTION.getType())
			.build()
			.update(new UpdateWrapper<JxglProcessNode>().lambda()
					.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
					.eq(JxglProcessNode::getProcessType, ProcessType.SELF_ASSESSMENT.getType()));
			
			// 删除 考核评定-自评
			jxglAppraisalAssessmentMapper.delete(new QueryWrapper<JxglAppraisalAssessment>().lambda()
					.eq(JxglAppraisalAssessment::getAppraisalId, appraisal.getId())
					.eq(JxglAppraisalAssessment::getType, AssessmentType.SELF_ASSESSMENT.getType()));
			
			List<JxglAppraisalIndicators> listAI = jxglAppraisalIndicatorsMapper.selectList(new QueryWrapper<JxglAppraisalIndicators>().lambda()
					.select(JxglAppraisalIndicators::getId)
					.eq(JxglAppraisalIndicators::getAppraisalId, appraisal.getId()));
			List<Integer> listAIId = listAI != null && listAI.size() > 0 ? listAI.stream().map(JxglAppraisalIndicators::getId).collect(Collectors.toList()) : null;
			// 删除 考核指标评定-自评
			jxglAppraisalIndicatorsAssessmentMapper.delete(new QueryWrapper<JxglAppraisalIndicatorsAssessment>().lambda()
					.in(JxglAppraisalIndicatorsAssessment::getAppraisalIndicatorsId, listAIId)
					.eq(JxglAppraisalIndicatorsAssessment::getType, AssessmentType.SELF_ASSESSMENT.getType()));
			
			jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId()).sts(AppraisalSts.SELF_ASSESSMENT.getType()).build());
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setRemarks(appraisalReject.getRejectReason());
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.SCORE_DISMISS.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
		
	}
	
	/**
	 * 评分提交-(缺-评分最大分数限制)
	 */
	@PostMapping(value = "/save_score")
	@ApiOperation(value = "22.评分提交", httpMethod = "POST", notes = "评分提交")
	@ApiOperationSupport(order = 22)
	public Result<Object> saveScore(@CurrentUser UserBean userBean,@Validated @RequestBody ValidList<AppraisalAssessment> appraisalAssessments){
		
		Integer appraisalId = appraisalAssessments.get(0).getAppraisalId();
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalId)
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalId)
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType() || 
				ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}

			appraisalAssessments.stream().forEach(a -> {
				Integer type = ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType() ? AssessmentType.SELF_ASSESSMENT.getType() : AssessmentType.SUPERIOR_SCORE.getType();
				
				if (a.getAppraisalIndicatorsId() != null) {
					JxglAppraisalIndicatorsAssessment.builder()
					.appraisalIndicatorsId(a.getAppraisalIndicatorsId())
					.assessorId(userBean.getEmpNum())
					.assessorName(userBean.getUserInfo().getName())
					.score(a.getScore())
					.remarks(a.getRemarks())
					.type(type)
					.build()
					.insert();
					
					jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId()).sts(AppraisalSts.SUPERIOR_SCORE.getType()).build());
					
				}else {
					JxglAppraisalAssessment.builder()
					.appraisalId(a.getAppraisalId())
					.assessorId(userBean.getEmpNum())
					.assessorName(userBean.getUserInfo().getName())
					.comprehensiveScore(a.getScore())
					.remarks(a.getRemarks())
					.type(type)
					.level(a.getLevel())
					.build()
					.insert();
					
//					jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId()).sts(AppraisalSts.RESULT_VERIFICATION.getType()).build());
				}
				
				
			});

			// 修改  状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.EXECUTED.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
			
			JxglProcessNode
			.builder()
			.sts(ProcessNodeSts.IN_EXECUTION.getType())
			.build()
			.update(new UpdateWrapper<JxglProcessNode>().lambda()
					.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
					.eq(ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType(), JxglProcessNode::getProcessType, ProcessType.RESULT_VERIFICATION.getType())
					.eq(ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType(), JxglProcessNode::getProcessType, ProcessType.SUPERIOR_SCORE.getType()));
			
			JxglPerformanceAppraisal pA = jxglPerformanceAppraisalMapper.selectById(appraisal.getPerformanceAppraisalId());
			
			if (pA != null && pA.getSts() > PerformanceAppraisalSts.PERFORMANCE_SCORE.getType()) {
				
				if (ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType()) {
					jxglAppraisalMapper.updateById(JxglAppraisal.builder()
							.id(appraisal.getId())
							.sts(AppraisalSts.RESULT_VERIFICATION.getType()).build());
				}
				
			}
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType() ? AppraisalLogType.SELF_ASSESSMENT.getType() : AppraisalLogType.SUPERIOR_SCORE.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
	}
	
	/**
	 * 结果确认-确认
	 */
	@PostMapping(value = "/result_verification")
	@ApiOperation(value = "23.结果确认-确认", httpMethod = "POST", notes = "结果确认-确认")
	@ApiOperationSupport(order = 23)
	public Result<Object> resultVerification(@CurrentUser UserBean userBean,@RequestParam Integer id){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, id)
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核 不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.RESULT_VERIFICATION.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}
				
			// 修改  状态
			JxglProcessNode
				.builder()
				.sts(ProcessNodeSts.EXECUTED.getType())
				.build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
			
			jxglAppraisalMapper.updateById(JxglAppraisal.builder()
					.id(id)
					.sts(AppraisalSts.ASSESSMENT_COMPLETE.getType()).build());
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.RESULT_VERIFICATION.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
	}
	
	/**
	 * 结果确认-改分
	 */
	@PostMapping(value = "/change_score")
	@ApiOperation(value = "24.结果确认-改分", httpMethod = "POST", notes = "结果确认-改分")
	@ApiOperationSupport(order = 24)
	public Result<Object> changeScore(@CurrentUser UserBean userBean,@Validated @RequestBody AppraisalAssessment appraisalAssessment){
		
		Integer count2 = jxglAppraisalMapper.selectCount(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalAssessment.getAppraisalId())
				.in(JxglAppraisal::getSts, AppraisalSts.ASSESSMENT_COMPLETE.getType(),
						AppraisalSts.TERMINATION_ASSESSMENT.getType(),
						AppraisalSts.PERFORMANCE_ARCHIVE.getType()));
		
		if (count2 > 0) {
			return ResultUtil.error("考核已结束");
		}
		
		JxglAppraisal appraisal = jxglAppraisalMapper.selectOne(new QueryWrapper<JxglAppraisal>().lambda()
				.eq(JxglAppraisal::getId, appraisalAssessment.getAppraisalId())
				.select(JxglAppraisal::getId));
		
		if (appraisal == null) {
			return ResultUtil.error("考核 不存在");
		}
			
		JxglProcessNode processNode = jxglProcessNodeMapper.selectOne(new QueryWrapper<JxglProcessNode>().lambda()
				.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
				.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));
		if (processNode == null) {
			return ResultUtil.error("流程不存在");
		}
		
		if (ProcessType.RESULT_VERIFICATION.getType() == processNode.getProcessType()) {
			
			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限 操作该流程");
			}
			
			JxglAppraisalAssessment.builder()
			.id(appraisalAssessment.getAppraisalAssessmentId())
			.comprehensiveScore(appraisalAssessment.getScore())
			.level(appraisalAssessment.getLevel())
			.build()
			.updateById();
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setRemarks(appraisalAssessment.getRemarks());
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.UPDATE_SCORE.getType());
			appraisalLog.insert();
			
		}else {
			return ResultUtil.error("流程状态异常");
		}

		return ResultUtil.success();
	}
	
	/**
	 * 查询-我的绩效-员工绩效
	 */
	@PostMapping(value = "/selects_my_emp_performance")
	@ApiOperation(value = "25.查询-我的绩效-员工绩效", httpMethod = "POST", notes = "查询-我的绩效-员工绩效")
	@ApiOperationSupport(order = 25)
	@Role
	public Result<Object> selectsMEP(@CurrentUser UserBean userBean,@RequestBody EmpPerformanceQuery query){
		Integer orgCode = userBean.getOrgCode();
		Integer empNum = userBean.getEmpNum();
		IPage<JxglAppraisal> page = new Page<JxglAppraisal>(query.getCurrentPage(),query.getTotalPage());
		query.setOrgCode(orgCode);
		
		List<ZzglBmgwM> listBM = zzglBmgwMMapper.selectList(new QueryWrapper<ZzglBmgwM>().lambda()
				.select(ZzglBmgwM::getId)
				.eq(ZzglBmgwM::getOrgCode, userBean.getOrgCode())
				.eq(ZzglBmgwM::getLeader, empNum));
		ZzglBmgwM ZzglBmgwM = CollUtil.getFirst(listBM);
		if (ZzglBmgwM == null) {
			return ResultUtil.success();
		}
		
		List<YgglMainEmp> users = zzglBmgwMService.selectOtherlistent(orgCode, ZzglBmgwM.getId());
		List<Integer> empNums = null;
		if (users != null ) {
			empNums = users.stream().map(YgglMainEmp::getEmpNum).collect(Collectors.toList());
		}
		query.setEmpNums(empNums);
		IPage<JxglAppraisal> pageA = jxglAppraisalMapper.selectMyEmpByQuery(page, query);
		
		List<JxglAppraisal> listA = pageA.getRecords();

		return ResultUtil.data(pageA,listA);
		
	}
	
	
	
	
}