JxglController.java

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.CollectionUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.lang.Console;
import cn.hutool.core.util.ObjectUtil;
import cn.timer.api.aspect.lang.annotation.Log;
import cn.timer.api.aspect.lang.annotation.Role;
import cn.timer.api.aspect.lang.enums.BusinessType;
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.qyzx.QyzxEmpEntAsso;
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.enums.SysRoleType;
import cn.timer.api.config.exception.CustomException;
import cn.timer.api.config.validation.ValidList;
import cn.timer.api.controller.jxgl.service.JxglService;
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 YgglService ygglService;
	
	@Autowired
	private JxglService jxglService;
	
	@Autowired
	private ZzglBmgwMService zzglBmgwMService;
	
	@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;

	@Autowired
	private JxglPerformanceAppraisalMapper jxglPerformanceAppraisalMapper;

	@Autowired
	private JxglAppraisalMapper jxglAppraisalMapper;

	@Autowired
	private JxglAppraisalIndicatorsMapper jxglAppraisalIndicatorsMapper;

	@Autowired
	private JxglAppraisalLogMapper jxglAppraisalLogMapper;

	@Autowired
	private YgglMainEmpMapper ygglMainEmpMapper;
	
	@Autowired
	private JxglProcessNodeMapper jxglProcessNodeMapper;
	
	@Autowired
	private JxglAppraisalItemMapper jxglAppraisalItemMapper;
	
	@Autowired
	private QyzxEmpEntAssoMapper qyzxEmpEntAssoMapper;

	// 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 (CollectionUtil.isNotEmpty(listPr)) {
			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 (CollectionUtil.isNotEmpty(listPr)) {
			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)
	public Result<Object> selectAT(@CurrentUser UserBean userBean) {

		JxglBasicSetting bS = jxglService.selectAT(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 = CollectionUtil.isNotEmpty(listAIT)
				? listAIT.stream().map(JxglAppraisalIndicatorsT::getId).collect(Collectors.toList())
				: null;

		// 删除 原 考核指标模板
		jxglAppraisalIndicatorsTMapper.delete(q);
		// 删除 原 考核项模板
		if (CollectionUtil.isNotEmpty(listAITId)) {
			jsxglAppraisalItemTMapper.delete(new QueryWrapper<JxglAppraisalItemT>().lambda()
					.in(JxglAppraisalItemT::getAppraisalIndicatorsTId, listAITId));
		}

		List<JxglAppraisalIndicatorsT> aITs = jxglAppraisalT.getAppraisalIndicatorsTs();
		
		if (CollectionUtil.isNotEmpty(aITs)) {
			
//			Integer weightSum = 0;
			for (JxglAppraisalIndicatorsT aIT : aITs) {
				
				if (aIT.getType() == null) {
					throw new CustomException("指标类型未设置");
				}
				Integer weightNum = aIT.getWeight() == null ? 0 : aIT.getWeight();
//				weightSum += weightNum;
				
				aIT.setWeight(weightNum);
				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();
				}

			}
			
//			if (!weightSum.equals(100))
//				throw new CustomException("权重总和要等于 100%");
			
		}
		return ResultUtil.success();
	}

	/**
	 * 查询-考核模板-列表
	 */
	@PostMapping(value = "/selects_appraisal_t")
	@ApiOperation(value = "4.查询-考核模板-列表", httpMethod = "POST", notes = "查询-考核模板-列表")
	@ApiOperationSupport(order = 4)
	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())
				.orderByDesc(JxglAppraisalT::getId)
				);

		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();

	}

	/**
	 * 新增-绩效考核
	 */
	@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");

		List<ProcessNode> listPN = performanceAppraisal.getProcessNode();
		List<BeingAppraisalPerson> listBAP = performanceAppraisal.getBeingAppraisalPerson();
		pA.setSts(PerformanceAppraisalSts.TARGET_SETING.getType());
		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 (CollectionUtil.isNotEmpty(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.setIsEdit(aT.getIsEdit());
			appraisal.setName(aT.getName());
			appraisal.setAppraisalExplain(aT.getAppraisalExplain());
			appraisal.setSts(AppraisalSts.TARGET_FILL_IN.getType());
			// 新增 考核
			appraisal.insert();
			System.out.println("新增 考核:" + appraisal);

			List<Integer> pNWeights = listPN.stream().filter(p -> p.getProcessType() == 2 || p.getProcessType() == 3 ).map(ProcessNode::getWeight).collect(Collectors.toList());
			Integer sum = 0;
			
			for (Integer w : pNWeights) {
				if (w < 0) {
					throw new CustomException("评分权重不能小于0");
				}
				sum += w;
			}
			if (sum != 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)) {

					Integer leaderId = ygglService.selectLeaderEmpNumById(userBean.getOrgCode(), bAP, pN.getLeaderTier());
					Console.log("bAP:"+bAP);
					Console.log("leaderTier:"+pN.getLeaderTier());
					Console.log("leaderId:"+leaderId);
					if (leaderId == null) {
						
						QyzxEmpEntAsso eEA = qyzxEmpEntAssoMapper.selectOne(new QueryWrapper<QyzxEmpEntAsso>().lambda()
								.select(QyzxEmpEntAsso::getEmpNum)
								.eq(QyzxEmpEntAsso::getOrgCode, orgCode)
								.eq(QyzxEmpEntAsso::getUserType, SysRoleType.U_TYPE_ADMIN.getType()));
				
						leaderId = eEA != null ? eEA.getEmpNum() : null;
						// 当 该企业无管理员时 报错
						if (leaderId == null) {
							throw new CustomException("该企业不存在管理员,请联系客服");
						}
					}
					
					processNode.setExecutorId(leaderId);
				} 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 (CollectionUtil.isEmpty(listAIT)) {
				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 (CollectionUtil.isNotEmpty(listAItemT)) {
					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(userBean.getUserInfo().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 = CollectionUtil.isNotEmpty(listA) ? listA.stream().map(JxglAppraisal::getId).collect(Collectors.toList())
				: aIds;

		// 删除 绩效考核
		jxglPerformanceAppraisalMapper.deleteById(id);

		if (CollectionUtil.isNotEmpty(aIds)) {

			// 批量删除 考核
			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 = CollectionUtil.isNotEmpty(listAI) 
					? 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 = "9.修改-绩效管理状态", httpMethod = "POST", notes = "修改-绩效管理状态")
	@ApiOperationSupport(order = 9)
	public Result<Object> updatePAS(@CurrentUser UserBean userBean,
			@Validated @RequestBody AppraisalUpdateSts appraisalUpdateSts) {
		
		//查询绩效组是否还存在可开启的绩效
//		JxglPerformanceAppraisal appisal = JxglPerformanceAppraisal.builder().id(appraisalUpdateSts.getId()).build().selectById();
//		if(appisal.getAppraisalPersonNum() == 1) {
//			
//		}
		if(appraisalUpdateSts.getSts() == 0) {//开启评分
			List<JxglAppraisal> ais = JxglAppraisal.builder().build().selectList(new QueryWrapper<JxglAppraisal>().lambda().eq(JxglAppraisal::getPerformanceAppraisalId, appraisalUpdateSts.getId())
					.lt(JxglAppraisal::getSts, 2));
			if(ais.size() == 0) {
				return ResultUtil.error("已无可开启的绩效评分");
			}
		}else if(appraisalUpdateSts.getSts() == 1) {//开启结果确认
//			List<JxglAppraisal> ais = jxglAppraisalMapper.selectListByappraisalid(appraisalUpdateSts.getId());
			List<JxglAppraisal> ais = JxglAppraisal.builder().build().selectList(new QueryWrapper<JxglAppraisal>().lambda().eq(JxglAppraisal::getPerformanceAppraisalId, appraisalUpdateSts.getId())
					.lt(JxglAppraisal::getSts, 4));
			if(ais.size() == 0) {
				return ResultUtil.error("已无可开启的绩效结果确认");
			}
		}
		
//			JxglPerformanceAppraisal performanceAppraisal = jxglPerformanceAppraisalMapper
//					.selectOne(new QueryWrapper<JxglPerformanceAppraisal>().lambda()
//							.eq(JxglPerformanceAppraisal::getId, appraisalUpdateSts.getId())
//							.eq(JxglPerformanceAppraisal::getSts, appraisalUpdateSts.getSts()));
			
		JxglPerformanceAppraisal performanceAppraisal = jxglPerformanceAppraisalMapper
				.selectOne(new QueryWrapper<JxglPerformanceAppraisal>().lambda()
						.eq(JxglPerformanceAppraisal::getId, appraisalUpdateSts.getId()));
		
			if (performanceAppraisal == null && appraisalUpdateSts.getSts() != PerformanceAppraisalSts.PERFORMANCE_ARCHIVE.getType()) {
				return ResultUtil.error("绩效考核不存在");
			}
			
			if (performanceAppraisal.getSts() == PerformanceAppraisalSts.TERMINATION_ASSESSMENT.getType()) {
				// 修改 绩效考核状态
				jxglPerformanceAppraisalMapper
						.updateById(JxglPerformanceAppraisal.builder()
								.id(appraisalUpdateSts.getId())
								.sts(PerformanceAppraisalSts.PERFORMANCE_ARCHIVE.getType())
								.build());
				return ResultUtil.success();
			}

			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 (CollectionUtil.isNotEmpty(listA)) {
					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 (CollectionUtil.isNotEmpty(listPN)) {
						aIds = listPN.stream().map(JxglProcessNode::getAppraisalId).collect(Collectors.toList());

						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 (CollectionUtil.isNotEmpty(listPN)) {
							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;
			case 1:
				sts = PerformanceAppraisalSts.RESULT_VERIFICATION.getType();

				listA = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
						.select(JxglAppraisal::getId).eq(JxglAppraisal::getPerformanceAppraisalId, id));

				if (CollectionUtil.isNotEmpty(listA)) {
					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 (CollectionUtil.isNotEmpty(listPN)) {
						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 (CollectionUtil.isNotEmpty(listPN)) {
							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 (CollectionUtil.isNotEmpty(listA)) {
					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())
									.in(JxglProcessNode::getSts, ProcessNodeSts.NON_EXECUTION.getType(),ProcessNodeSts.IN_EXECUTION.getType()));

					if (CollectionUtil.isNotEmpty(listPN)) {
						throw new CustomException("所有考核 确认结果后才能 归档");
					}
				}
				break;
			case 3:
				// 修改 考核状态
				jxglAppraisalMapper.update(
						JxglAppraisal.builder().performanceAppraisalId(id).sts(AppraisalSts.PERFORMANCE_ARCHIVE.getType()).build(),
						new UpdateWrapper<JxglAppraisal>().lambda()
								.eq(JxglAppraisal::getPerformanceAppraisalId, id)
						);
				
				List<JxglAppraisal> listAppraisal = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
						.select(JxglAppraisal::getId)
						.eq(JxglAppraisal::getPerformanceAppraisalId, performanceAppraisal.getId()));
				
				if (CollectionUtil.isNotEmpty(listAppraisal)) {
					
					List<Integer> aIds2 = listAppraisal.stream().map(JxglAppraisal::getId).collect(Collectors.toList());
					if (CollectionUtil.isNotEmpty(aIds2)) {
						JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
						aIds2.forEach(aId -> {
							appraisalLog.setId(null);
							appraisalLog.setAppraisalId(aId);
							appraisalLog.setExecutorId(userBean.getEmpNum());
							appraisalLog.setExecutorName(userBean.getUserInfo().getName());
							appraisalLog.setType(AppraisalLogType.PERFORMANCE_ARCHIVE.getType());
							appraisalLog.insert();
						});
					}
				}
				break;
			default:
				break;
			}

			// 修改 绩效考核状态
			jxglPerformanceAppraisalMapper
					.updateById(JxglPerformanceAppraisal.builder().id(appraisalUpdateSts.getId()).sts(sts).build());

			return ResultUtil.success();
			
		
	}
	
	/**
	 * 终止-绩效考核
	 */
	@PutMapping(value = "/termination_performance_appraisal")
	@ApiOperation(value = "10.终止-绩效考核", httpMethod = "PUT", notes = "终止-绩效考核")
	@ApiOperationSupport(order = 10)
	@Role
	@Log(title = "终止-绩效考核")
	public Result<Object> terminationPA(@CurrentUser UserBean userBean,@NotNull @RequestParam Integer id) {

		JxglPerformanceAppraisal performanceAppraisal = jxglPerformanceAppraisalMapper
				.selectOne(new QueryWrapper<JxglPerformanceAppraisal>().lambda()
						.eq(JxglPerformanceAppraisal::getId, id));

		if (performanceAppraisal == null) {
			return ResultUtil.error("绩效考核不存在");
		}
		if (performanceAppraisal.getSts() == PerformanceAppraisalSts.TERMINATION_ASSESSMENT.getType()) {
			return ResultUtil.error("考核已终止");
		}

		// 修改 绩效考核状态
		jxglPerformanceAppraisalMapper
				.updateById(JxglPerformanceAppraisal.builder().id(id).sts(PerformanceAppraisalSts.TERMINATION_ASSESSMENT.getType()).build());

		// 修改 考核状态
		jxglAppraisalMapper.update(
				JxglAppraisal.builder().performanceAppraisalId(id).sts(AppraisalSts.TERMINATION_ASSESSMENT.getType()).build(),
				new UpdateWrapper<JxglAppraisal>().lambda()
						.eq(JxglAppraisal::getPerformanceAppraisalId, id)
						);
		
		List<JxglAppraisal> listAppraisal = jxglAppraisalMapper.selectList(new QueryWrapper<JxglAppraisal>().lambda()
				.select(JxglAppraisal::getId)
				.eq(JxglAppraisal::getPerformanceAppraisalId, performanceAppraisal.getId()));
		
		if (CollectionUtil.isNotEmpty(listAppraisal)) {
			
			List<Integer> aIds = listAppraisal.stream().map(JxglAppraisal::getId).collect(Collectors.toList());
			if (CollectionUtil.isNotEmpty(aIds)) {
				JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
				aIds.forEach(aId -> {
					appraisalLog.setId(null);
					appraisalLog.setAppraisalId(aId);
					appraisalLog.setExecutorId(userBean.getEmpNum());
					appraisalLog.setExecutorName(userBean.getUserInfo().getName());
					appraisalLog.setType(AppraisalLogType.TERMINATION_ASSESSMENT.getType());
					appraisalLog.insert();
				});
			}
		}
		
		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 = "11.查询-绩效考核-列表-归档", httpMethod = "POST", notes = "查询-绩效考核-列表-归档")
	@ApiOperationSupport(order = 11)
	@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 = "12.查询-绩效考核-列表-非归档", httpMethod = "POST", notes = "查询-绩效考核-列表-非归档")
	@ApiOperationSupport(order = 12)
	@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 = "13.查询-考核-列表", httpMethod = "POST", notes = "查询-考核-列表")
	@ApiOperationSupport(order = 13)
	@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());
		
		List<Integer> empNums = CollUtil.toList();
		
		if (query.getBmId() != null) {
			List<YgglMainEmp> usersQuery = zzglBmgwMService.selectOtherlistent(userBean.getOrgCode(), query.getBmId());
			if (usersQuery != null) {
				empNums = usersQuery.stream().map(YgglMainEmp::getEmpNum).collect(Collectors.toList());
			}else {
				return ResultUtil.data(null);
			}
			
			if (empNums == null || empNums.size() == 0) {
				return ResultUtil.data(null);
			}
		}
		
		query.setEmpNums(empNums);

		IPage<JxglAppraisal> pageA = jxglAppraisalMapper.selectListByQuery(page, query);

		List<JxglAppraisal> listPA = pageA.getRecords();

		return ResultUtil.data(pageA, listPA);

	}

	/**
	 * 查询-考核-详情
	 */
	@GetMapping(value = "/select_appraisal/{id}")
	@ApiOperation(value = "14.查询-考核-详情", httpMethod = "GET", notes = "查询-考核-详情")
	@ApiOperationSupport(order = 14)
	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 = "15.修改-流程执行人-转派", httpMethod = "PUT", notes = "修改-流程执行人-转派")
	@ApiOperationSupport(order = 15)
	@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 = "16.终止-考核", httpMethod = "PUT", notes = "终止-考核")
	@ApiOperationSupport(order = 16)
	@Role
	@Log(title = "终止-考核")
	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();
			
			//查询所属绩效组是否为一人
			JxglPerformanceAppraisal appisal = JxglPerformanceAppraisal.builder().id(appraisal.getPerformanceAppraisalId()).build().selectById();
			if(appisal.getAppraisalPersonNum() == 1) {
				//绩效考核改为 “4, "终止考核"”
				jxglPerformanceAppraisalMapper.updateById(JxglPerformanceAppraisal.builder().id(appraisal.getPerformanceAppraisalId()).sts(PerformanceAppraisalSts.TERMINATION_ASSESSMENT.getType()).build());
			}else {
				List<JxglAppraisal> ais = JxglAppraisal.builder().build().selectList(new QueryWrapper<JxglAppraisal>().lambda().eq(JxglAppraisal::getPerformanceAppraisalId, appraisal.getPerformanceAppraisalId())
						.eq(JxglAppraisal::getSts, 0));
				if(ais.size() == 0) {
					//绩效考核改为 “4, "终止考核"”
					jxglPerformanceAppraisalMapper.updateById(JxglPerformanceAppraisal.builder().id(appraisal.getPerformanceAppraisalId()).sts(PerformanceAppraisalSts.TERMINATION_ASSESSMENT.getType()).build());
				}
				
				JxglProcessNode.builder().sts(2).build().update(new QueryWrapper<JxglProcessNode>().lambda().eq(JxglProcessNode::getAppraisalId, id));
			}
			
			JxglAppraisalLog appraisalLog = JxglAppraisalLog.builder().build();
			appraisalLog.setAppraisalId(appraisal.getId());
			appraisalLog.setExecutorId(userBean.getEmpNum());
			appraisalLog.setExecutorName(userBean.getUserInfo().getName());
			appraisalLog.setType(AppraisalLogType.TERMINATION_ASSESSMENT.getType());
			appraisalLog.insert();
		} 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();
	}

	/**
	 * 查询-绩效管理-员工绩效-汇总
	 */
	@PostMapping(value = "/selects_emp_performance")
	@ApiOperation(value = "17.查询-绩效管理-员工绩效-汇总", httpMethod = "POST", notes = " 查询-绩效管理-员工绩效-汇总")
	@ApiOperationSupport(order = 17)
	@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());
		
		List<Integer> empNums = CollUtil.toList();
		
		if (query.getBmId() != null) {
			List<YgglMainEmp> usersQuery = zzglBmgwMService.selectOtherlistent(userBean.getOrgCode(), query.getBmId());
			if (CollectionUtil.isNotEmpty(usersQuery)) {
				empNums = usersQuery.stream().map(YgglMainEmp::getEmpNum).collect(Collectors.toList());
			}else {
				return ResultUtil.data(null);
			}
			
			if (CollectionUtil.isEmpty(empNums)) {
				return ResultUtil.data(null);
			}
		}
		
		query.setEmpNums(empNums);

		IPage<JxglAppraisal> pageA = jxglAppraisalMapper.selectListEmpByQuery(page, query);

		List<JxglAppraisal> listA = pageA.getRecords();

		return ResultUtil.data(pageA, listA);

	}

	/**
	 * 查询-某员工考核-列表
	 */
	@PostMapping(value = "/selects_emp_appraisal")
	@ApiOperation(value = "18.查询-某员工考核-列表", httpMethod = "POST", notes = "查询-某员工考核-列表")
	@ApiOperationSupport(order = 18)
//	@Role
	public Result<Object> selectsEA(@CurrentUser UserBean userBean,@Validated @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);

	}
	
	/**
	 * 查询-我的绩效-考核我的-列表
	 */
	@PostMapping(value = "/selects_my_appraisal")
	@ApiOperation(value = "19.查询-我的绩效-考核我的-列表", httpMethod = "POST", notes = "查询-我的绩效-考核我的-列表")
	@ApiOperationSupport(order = 19)
	public Result<Object> selectsMA(@CurrentUser UserBean userBean,@Validated @RequestBody EmpAppraisalQuery query) {
		
		IPage<JxglPerformanceAppraisal> page = new Page<JxglPerformanceAppraisal>(query.getCurrentPage(),
				query.getTotalPage());
		query.setOrgCode(userBean.getOrgCode());
		query.setId(userBean.getEmpNum());
		
		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 = "20.查询-绩效考核-方案", httpMethod = "GET", notes = "查询-绩效考核-方案")
	@ApiOperationSupport(order = 20)
	@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())
				.appraisalTId(pA.getAppraisalTId())
				.processNode(ObjectUtil.deserialize(pA.getProcessNode()))
				.beingAppraisalPerson(ObjectUtil.deserialize(pA.getBeingAppraisalPerson()))
				.build();

		return ResultUtil.data(paDto);
	}

	/**
	 * 查询-目标待填写/目标待确认/评分/结果待确认-列表
	 */
	@PostMapping(value = "/selects_my_performance")
	@ApiOperation(value = "21.查询-目标待填写/目标待确认/评分/结果待确认-列表", httpMethod = "POST", notes = "查询")
	@ApiOperationSupport(order = 21)
	public Result<Object> selects(@CurrentUser UserBean userBean,@Validated @RequestBody MyPerformance query) {

		IPage<JxglPerformanceAppraisal> page = new Page<JxglPerformanceAppraisal>(query.getCurrentPage(),query.getTotalPage());
		query.setOrgCode(userBean.getOrgCode());
		query.setId(userBean.getEmpNum());
		
		// 当查询的数据不为  2评分,清空 节点状态
		if (query.getSts() != 2) {
			query.setNoteSts(null);
		}
		
		IPage<JxglPerformanceAppraisal> pagePA = jxglPerformanceAppraisalMapper.selectMyByQuery(page, query);

		List<JxglPerformanceAppraisal> listPA = pagePA.getRecords();

		return ResultUtil.data(pagePA, listPA);

	}
	
	/**
	 * 查询-我的绩效-已处理-列表
	 */
	@PostMapping(value = "/selects_my_performance_processed")
	@ApiOperation(value = "22.查询-我的绩效-已处理-列表", httpMethod = "POST", notes = "查询")
	@ApiOperationSupport(order = 22)
	public Result<Object> selectsP(@CurrentUser UserBean userBean, @Validated @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.selectMyProcessedByQuery(page, query);

		List<JxglPerformanceAppraisal> listPA = pagePA.getRecords();

		return ResultUtil.data(pagePA, listPA);

	}

	/**
	 * 目标填写-保存
	 */
	@PostMapping(value = "/save_target_fill")
	@ApiOperation(value = "23.目标填写-保存", httpMethod = "POST", notes = "目标填写-保存")
	@ApiOperationSupport(order = 23)
	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("考核不存在");
		}

		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,
						JxglAppraisalIndicators::getWeight,
						JxglAppraisalIndicators::getIsEditWeight)
						.eq(JxglAppraisalIndicators::getType, IndicatorsType.NOT_FIXATION.getType())
						.eq(JxglAppraisalIndicators::getAppraisalId, id));

		List<Integer> appraisalIndicatorIds = listAI != null && listAI.size() > 0
				? 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));

		List<JxglAppraisalIndicators> listAI2 = appraisalUpdate.getAppraisalIndicators();
		
		if (listAI2 != null && listAI2.size() > 0) {
			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("保存异常");
				}

			});
		}
		

		return ResultUtil.success();
	}

	/**
	 * 目标填写-提交
	 */
	@PostMapping(value = "/submit_target_fill")
	@ApiOperation(value = "24.目标填写-提交", httpMethod = "POST", notes = "目标填写-提交")
	@ApiOperationSupport(order = 24)
	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 (CollectionUtil.isEmpty(listAI)) {
				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) {
					i = i == null ? 0 : i;
					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 = "25.目标确认-同意", httpMethod = "POST", notes = "目标确认-同意")
	@ApiOperationSupport(order = 25)
	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, JxglAppraisal::getPerformanceAppraisalId));

		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 = "26.目标确认-驳回目标", httpMethod = "POST", notes = "目标确认-驳回目标")
	@ApiOperationSupport(order = 26)
	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 = "27.评价 -驳回目标", httpMethod = "POST", notes = "评价 -驳回目标")
	@ApiOperationSupport(order = 27)
	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 (!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(),
								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.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 = CollectionUtil.isNotEmpty(listAI)
				? 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();

		return ResultUtil.success();

	}

	/**
	 * 上级评价 -驳回评分
	 */
	@PostMapping(value = "/update_superior_reject_score")
	@ApiOperation(value = "28.上级评价 -驳回评分", httpMethod = "POST", notes = "上级评价 -驳回评分")
	@ApiOperationSupport(order = 28)
	public Result<Object> updateSRS(@CurrentUser UserBean userBean,@Validated @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 = "29.评分提交", httpMethod = "POST", notes = "评分提交")
	@ApiOperationSupport(order = 29)
	@Log(title = "评分提交")
	public Result<Object> saveScore(@CurrentUser UserBean userBean,
			@Validated @RequestBody ValidList<AppraisalAssessment> appraisalAssessments) throws Exception{

		Integer appraisalId = appraisalAssessments.get(0).getAppraisalId();

		Integer count = 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 (count > 0) {
			return ResultUtil.error("考核已结束");
		}

		JxglAppraisal appraisal = jxglAppraisalMapper
				.selectOne(new QueryWrapper<JxglAppraisal>().lambda().eq(JxglAppraisal::getId, appraisalId)
						.select(JxglAppraisal::getId, JxglAppraisal::getPerformanceAppraisalId));

		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("流程不存在");
		}
		
		JxglBasicSetting bS = jxglService.selectAT(userBean.getOrgCode());

		Integer maxScore = bS.getMaxScore();
		if (ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType()
				|| ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType()) {

			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限操作该流程");
			}

			boolean hasAppraisalAssessment = false;
			
			for (AppraisalAssessment a : appraisalAssessments) {

				Integer type =  processNode.getProcessType();

						
				if (Double.valueOf(a.getScore()) > maxScore) {
					throw new CustomException("评分值不能大于最高分");
				}
						
				if (a.getAppraisalIndicatorsId() != null) {
					JxglAppraisalIndicatorsAssessment.builder().appraisalIndicatorsId(a.getAppraisalIndicatorsId())
							.assessorId(userBean.getEmpNum()).assessorName(userBean.getUserInfo().getName())
							.score(a.getScore()).remarks(a.getRemarks())
							.type(ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType() ? AssessmentType.SELF_ASSESSMENT.getType() : AssessmentType.SUPERIOR_SCORE.getType())
							.build().insert();

				} else {
					JxglAppraisalAssessment.builder().appraisalId(a.getAppraisalId()).assessorId(userBean.getEmpNum())
							.assessorName(userBean.getUserInfo().getName()).comprehensiveScore(Double.valueOf(a.getScore()))
							.remarks(a.getRemarks())
							.type(ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType() ? AssessmentType.SELF_ASSESSMENT.getType() : AssessmentType.SUPERIOR_SCORE.getType())
							.level(a.getLevel())
							.build().insert();

					hasAppraisalAssessment = true;
				}

			};
			
			if (!hasAppraisalAssessment) {
				throw new CustomException("必须填写综合评分");
			}

			// 修改 状态
			JxglProcessNode.builder().sts(ProcessNodeSts.EXECUTED.getType()).build()
					.update(new UpdateWrapper<JxglProcessNode>().lambda()
							.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
							.eq(JxglProcessNode::getSts, ProcessNodeSts.IN_EXECUTION.getType()));

			if (ProcessType.SELF_ASSESSMENT.getType() == processNode.getProcessType()) {
				JxglProcessNode.builder().sts(ProcessNodeSts.IN_EXECUTION.getType()).build()
				.update(new UpdateWrapper<JxglProcessNode>().lambda()
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.eq(JxglProcessNode::getProcessType, ProcessType.SUPERIOR_SCORE.getType()));
				
				jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId())
							.sts(AppraisalSts.SUPERIOR_SCORE.getType()).build());
				
			}else if(ProcessType.SUPERIOR_SCORE.getType() == processNode.getProcessType()) {
				
				JxglPerformanceAppraisal pA = jxglPerformanceAppraisalMapper
						.selectById(appraisal.getPerformanceAppraisalId());

				if (pA != null && pA.getSts() > PerformanceAppraisalSts.PERFORMANCE_SCORE.getType()) {

					JxglProcessNode.builder().sts(ProcessNodeSts.IN_EXECUTION.getType()).build()
					.update(new UpdateWrapper<JxglProcessNode>().lambda()
							.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
							.eq(JxglProcessNode::getProcessType, ProcessType.RESULT_VERIFICATION.getType()));
					
					jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId())
								.sts(AppraisalSts.RESULT_VERIFICATION.getType()).build());
					
				}
				
				// 算 总评分 ---- 自评权重*自评综合分 + 上级评分权重*上级综合评分 = 总评分
				List<JxglProcessNode> listProcessNode = jxglProcessNodeMapper.selectList(new QueryWrapper<JxglProcessNode>().lambda()
						.select(JxglProcessNode::getWeight,JxglProcessNode::getProcessType)
						.orderByAsc(JxglProcessNode::getProcessType)
						.eq(JxglProcessNode::getAppraisalId, appraisal.getId())
						.in(JxglProcessNode::getProcessType, 
								ProcessType.SELF_ASSESSMENT.getType()
								,ProcessType.SUPERIOR_SCORE.getType()));
			
				List<JxglAppraisalAssessment> listAppraisalAssessment = jxglAppraisalAssessmentMapper.selectList(new QueryWrapper<JxglAppraisalAssessment>().lambda()
						.select(JxglAppraisalAssessment::getType,JxglAppraisalAssessment::getComprehensiveScore)
						.eq(JxglAppraisalAssessment::getAppraisalId, appraisal.getId())
						.orderByAsc(JxglAppraisalAssessment::getType)
						);
				Double selfAssessment = 0D;
				Double superiorAssessment = 0D;
				
				Integer aWeights = 0;
				Integer bWeights = 0;
				Double total = 0D;
				String level = null;
				
				if (CollectionUtil.isNotEmpty(listProcessNode)) {
					aWeights = listProcessNode.stream().filter(p -> p.getProcessType() == ProcessType.SELF_ASSESSMENT.getType()).map(JxglProcessNode::getWeight).findFirst().orElse(null);
					bWeights = listProcessNode.stream().filter(p -> p.getProcessType() == ProcessType.SUPERIOR_SCORE.getType()).map(JxglProcessNode::getWeight).findFirst().orElse(null);
					
				}
				
				if (CollectionUtil.isNotEmpty(listAppraisalAssessment)) {
					selfAssessment = listAppraisalAssessment.stream().filter(a -> a.getType() == AssessmentType.SELF_ASSESSMENT.getType()).map(JxglAppraisalAssessment::getComprehensiveScore).findFirst().orElse(null) ;
					superiorAssessment = listAppraisalAssessment.stream().filter(a -> a.getType() == AssessmentType.SUPERIOR_SCORE.getType()).map(JxglAppraisalAssessment::getComprehensiveScore).findFirst().orElse(null);
				
				}
				
				if (selfAssessment != null && superiorAssessment != null) {
					Integer min = 0;
					Integer max = 0;
					
					total = aWeights*0.01*selfAssessment + bWeights*0.01*superiorAssessment;
					System.out.println(total);
					System.out.println(aWeights);
					System.out.println(selfAssessment);
					System.out.println(bWeights);
					System.out.println(superiorAssessment);
					
					List<JxglPerformanceRating> listPR = bS.getPerformanceRatings();
					for (JxglPerformanceRating pR : listPR) {
						min = min <= pR.getSectionMinScore() ? pR.getSectionMinScore() : min;
						max = max >= pR.getSectionMaxScore() ? pR.getSectionMaxScore() : max;
						level = pR.getSectionMinScore() < total && total <= pR.getSectionMaxScore()   ? pR.getName() : null;
					}
					
					System.out.println(min);
					System.out.println(max);
					System.out.println(level);
					if (level == null) {
						for (JxglPerformanceRating pR : listPR) {
							if (total < min && pR.getSectionMinScore().equals(min)) {
								level = pR.getName();
								break;
							}
							if (total > max && pR.getSectionMaxScore().equals(max)) {
								level = pR.getName();
								break;
							}
						}
					}
					System.out.println(level);
					
					// 更新 考核-总分 等级
					jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId())
							.total(total).level(level).build());
				}else {
					throw new CustomException("评分数据存在异常");
				}
				
			}
			
			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 = "30.结果确认-确认", httpMethod = "POST", notes = "结果确认-确认")
	@ApiOperationSupport(order = 30)
	public Result<Object> resultVerification(@CurrentUser UserBean userBean, @RequestParam Integer id) {

		Integer count = 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 (count > 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 = "31.结果确认-改分", httpMethod = "POST", notes = "结果确认-改分")
	@ApiOperationSupport(order = 31)
	@Log(title = "绩效管理-结果确认-改分", businessType = BusinessType.UPDATE)
	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("流程不存在");
		}
		
		JxglBasicSetting bS = jxglService.selectAT(userBean.getOrgCode());

		Integer maxScore = bS.getMaxScore();
		if (Double.valueOf(appraisalAssessment.getScore()) > maxScore) {
			throw new CustomException("评分值不能大于最高分");
		}

		if (ProcessType.RESULT_VERIFICATION.getType() == processNode.getProcessType()) {

			if (!userBean.getEmpNum().equals(processNode.getExecutorId())) {
				return ResultUtil.error("无权限操作该流程");
			}
			
			// 更新 考核-总分 等级
			jxglAppraisalMapper.updateById(JxglAppraisal.builder().id(appraisal.getId())
					.total(Double.valueOf(appraisalAssessment.getScore())).level(appraisalAssessment.getLevel()).build());

			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 = "32.查询-我的绩效-员工绩效", httpMethod = "POST", notes = "查询-我的绩效-员工绩效")
	@ApiOperationSupport(order = 32)
	@Log(title = "绩效管理-查询-我的绩效-员工绩效")
	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));
		System.out.println("listBM-----"+ listBM);
		ZzglBmgwM ZzglBmgwM = CollUtil.getFirst(listBM);
		if (ZzglBmgwM == null) {
			return ResultUtil.success();
		}

		List<YgglMainEmp> users = zzglBmgwMService.selectOtherlistent(orgCode, ZzglBmgwM.getId());
		List<Integer> empNums = CollUtil.toList();
		if (CollectionUtil.isNotEmpty(empNums)) {
			empNums = users.stream().map(YgglMainEmp::getEmpNum).collect(Collectors.toList());
		}
		
		if (query.getBmId() != null) {
			List<YgglMainEmp> usersQuery = zzglBmgwMService.selectOtherlistent(orgCode, query.getBmId());
			if (CollectionUtil.isNotEmpty(empNums)) {
				List<Integer> empNumsQuery = usersQuery.stream().map(YgglMainEmp::getEmpNum).collect(Collectors.toList());
				empNums = empNums.stream().filter(e -> empNumsQuery.contains(e)).collect(Collectors.toList());
			}else {
				return ResultUtil.data(null);
			}
		}
		
		if (CollectionUtil.isNotEmpty(empNums)) {
			return ResultUtil.data(null);
		}
		
		query.setEmpNums(empNums);
		
		String deptid = jxglAppraisalMapper.CurrentdepartmentID(orgCode, empNum);
		query.setDeptid(deptid);
		
		IPage<JxglAppraisal> pageA = jxglAppraisalMapper.selectMyEmpByQuery(page, query);

		List<JxglAppraisal> listA = pageA.getRecords();

		return ResultUtil.data(pageA, listA);

	}
}