fj-dc/.svn/pristine/ec/ec9ae245e6515aa91445cb6d0161b2e0a724b23f.svn-base

package cn.com.goldenwater.dcproj.service.impl.tac;

import cn.com.goldenwater.dcproj.constValue.SplitValue;
import cn.com.goldenwater.dcproj.dao.*;
import cn.com.goldenwater.dcproj.dto.TacCountDto;
import cn.com.goldenwater.dcproj.dto.TacInspYearBatchGroupAuditDto;
import cn.com.goldenwater.dcproj.model.*;
import cn.com.goldenwater.dcproj.param.*;
import cn.com.goldenwater.dcproj.service.TacInspYearBatchGroupService;
import cn.com.goldenwater.dcproj.service.TacInspYearBatchService;
import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.utils.AdLevelUtil;
import cn.com.goldenwater.dcproj.utils.BeanUtil;
import cn.com.goldenwater.dcproj.utils.expExcel.ExportUtil;
import cn.com.goldenwater.id.util.UuidUtil;
import cn.com.goldenwater.target.CheckException;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Row;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author lune
 * @date 2019-9-6
 */
@Service
@Transactional
public class TacInspYearBatchServiceImpl extends AbstractCrudService<TacInspYearBatch, TacInspYearBatchParam> implements TacInspYearBatchService {

    @Autowired
    private TacInspYearBatchDao tacInspYearBatchDao;

    @Autowired
    private TacWorkerBDao workerBDao;

    @Autowired
    private TacInspYearBatchGroupService groupService;

    @Autowired
    private TacInspPersAreaPrisDao prisDao;

    @Autowired
    private TacInspYearBatchGroupPersDao groupPersDao;
    @Autowired
    private TacInspYearBatchAreaDao areaDao;
    @Autowired
    private TacInspYearBatchGroupDao tacInspYearBatchGroupDao;

    @Autowired
    private AttAdXBaseDao attAdXBaseDao;

    @Autowired
    private TacInspYearBatchObjDao objDao;

    @Autowired
    private TacPawpRgstrDao pawpRgstrDao;

    @Autowired
    private TacAttPawpBaseDao pawpBaseDao;

    @Autowired
    private TacInspYearBatchObjDao tacInspYearBatchObjDao;

    public TacInspYearBatchServiceImpl(TacInspYearBatchDao tacInspYearBatchDao) {
        super(tacInspYearBatchDao);
        this.tacInspYearBatchDao = tacInspYearBatchDao;
    }

    @Override
    public int insert(TacInspYearBatch entity) {
        entity.setId(UuidUtil.uuid());
        entity.setInTm(new Date());
        entity.setUpTm(new Date());
        entity.setDataStat("0");
        entity.setIsAreaGroup("2");
        entity.setIsAppraisal("2");
        entity.setIsPersGroup("2");
        return super.insert(entity);
    }

    @Override
    public int update(TacInspYearBatch entity) {
        entity.setUpTm(new Date());
        return super.update(entity);
    }

    @Override
    public List<TacInspYearBatch> getTacInspYearBatchList(TacInspYearBatchParam tacInspYearBatchParam) {
        return this.tacInspYearBatchDao.getTacInspYearBatchList(tacInspYearBatchParam);
    }

    @Override
    public PageInfo<TacInspYearBatch> getTacInspYearBatchPage(TacInspYearBatchParam tacInspYearBatchParam) {
        PageHelper.startPage(tacInspYearBatchParam);
        List<TacInspYearBatch> list = this.tacInspYearBatchDao.getTacInspYearBatchList(tacInspYearBatchParam);
        return new PageInfo<TacInspYearBatch>(list);
    }

    @Override
    public TacInspYearBatch getTacInspYearBatchById(String id,String province) {
        TacInspYearBatch tacInspYearBatch = this.tacInspYearBatchDao.get(id);
        //获取原则id
        TacInspPersAreaPrisParam prisParam = new TacInspPersAreaPrisParam();
        prisParam.setYearBatchId(id);
        prisParam.setProvince(province);
        List<TacInspPersAreaPris> prisList = this.prisDao.findList(prisParam);
        if (prisList.size() > 0 ){
            tacInspYearBatch.setPersAreaId(prisList.get(0).getId());
        }
        //获取稽察人员列表
        TacWorkerBParam tacWorkerBParam = new TacWorkerBParam();
        tacWorkerBParam.setYearBatchId(id);
        tacWorkerBParam.setProvince(province);
        List<TacWorkerB> list = this.workerBDao.getWorkerbsListById(tacWorkerBParam);
        if (list != null && !list.isEmpty()) {
            for (TacWorkerB workerB : list) {
                TacInspYearBatchGroupPersParam groupPersParam = new TacInspYearBatchGroupPersParam();
                groupPersParam.setPersId(workerB.getId());
                groupPersParam.setYearBatchId(id);
                groupPersParam.setProvince(province);
                List<TacInspYearBatchGroupPers> groupPersList = groupPersDao.findList(groupPersParam);
                List<TacWorkerType> roleTypeList = new ArrayList<>();
                for (TacInspYearBatchGroupPers groupPers : groupPersList) {
                    TacWorkerType tacWorkerType = new TacWorkerType();
                    tacWorkerType.setValue(groupPers.getRoleType());
                    roleTypeList.add(tacWorkerType);
                }
                workerB.setRoleTypeList(roleTypeList);
            }
        }
        tacInspYearBatch.setWorkersList(list);
        //获取组列表
        TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
        groupParam.setYearBatchId(id);
        groupParam.setProvince(province);
        List<TacInspYearBatchGroup> groupList = groupService.getGroupList(groupParam);
        tacInspYearBatch.setGroupList(groupList);
        return tacInspYearBatch;
    }

    @Override
    public int cleanAllObjByYearBatchId(String yearBatchId) {
        TacInspYearBatchGroupPersParam persParam = new TacInspYearBatchGroupPersParam();
        persParam.setYearBatchId(yearBatchId);
        groupPersDao.deleteBy(persParam);
        /*TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
        groupParam.setYearBatchId(yearBatchId);
        groupService.deleteBy(groupParam);
        TacInspYearBatchAreaParam areaParam = new TacInspYearBatchAreaParam();
        areaParam.setYearBatchId(yearBatchId);
        areaDao.deleteBy(areaParam);*/
        return 0;
    }
    @Override
    public TacCountDto getAllCountPers(TacInspYearBatchParam tacInspYearBatchParam) {
        TacCountDto tacCountDto = tacInspYearBatchDao.getAllCountPers(tacInspYearBatchParam);
        return tacCountDto;
    }

    @Override
    public int updateYearBatch(TacInspYearBatch tacInspYearBatch) {
        tacInspYearBatchDao.update(tacInspYearBatch);
        if (tacInspYearBatch.getGroupList() != null && tacInspYearBatch.getGroupList().size() > 0) {
            TacInspPersAreaPris pris = prisDao.get(tacInspYearBatch.getPersAreaId());
            if (pris != null && "1".equals(pris.getIsPorc())) {
                List<TacWorkerB> allTacWorker = new ArrayList<>();
                //优生列表
                if (pris.getSiBadPersNum()!= null && pris.getSiBadPersNum().intValue() > 0) {
                    TacWorkerBParam bParam = new TacWorkerBParam();
                    bParam.setYear(pris.getYear() - 1);
                    bParam.setOrderBy("SYN_LOT");
                    bParam.setProvince(tacInspYearBatch.getProvince());
                    allTacWorker = workerBDao.getWorkerbsListByYear(bParam);
                }
                //差生列表
                if (pris.getSiGoodPersNum() != null && pris.getSiGoodPersNum().intValue() > 0) {
                    if (allTacWorker == null) {
                        TacWorkerBParam bParam = new TacWorkerBParam();
                        bParam.setYear(pris.getYear() - 1);
//                bParam.setYearBatchId(pris.getYearBatchId());
                        bParam.setOrderBy("SYN_LOT");
                        bParam.setProvince(tacInspYearBatch.getProvince());
                        allTacWorker = workerBDao.getWorkerbsListByYear(bParam);
                    }
                }
                List<TacWorkerB> persList = new ArrayList<>();
                if (pris.getAvoidSize() != null && pris.getAvoidYrSize().intValue() > 0) {
                    //得到前几年度的人员列表
                    Long styr = pris.getYear() - pris.getAvoidSize();
                    TacWorkerBParam bParam = new TacWorkerBParam();
                    bParam.setStyr(styr);
                    bParam.setEnyr(pris.getYear());
                    bParam.setProvince(tacInspYearBatch.getProvince());
                    persList.addAll(workerBDao.getWorkerList(bParam));
                }
                //处理批次
                if (pris.getAvoidSize() != null && pris.getAvoidSize().intValue() > 0) {
                    TacWorkerBParam bParam = new TacWorkerBParam();
                    if (pris.getAvoidSize() > pris.getBatch()) {
                        bParam.setStba(new Long(0));
                    } else {
                        bParam.setStba(pris.getBatch() - pris.getAvoidSize());
                    }
                    bParam.setEnba(pris.getBatch());
                    bParam.setProvince(tacInspYearBatch.getProvince());
                    persList.addAll(workerBDao.getWorkerList(bParam));
                }
                for (TacInspYearBatchGroup tacInspYearBatchGroup : tacInspYearBatch.getGroupList()) {
                    tacInspYearBatchGroup.setDataStat("0");
                    tacInspYearBatchGroup.setPris("正常");
                    if (tacInspYearBatchGroup.getWorkersList() != null || tacInspYearBatchGroup.getWorkersList().size() > 0) {
                        if (persList.size() > 0) {
                            tacInspYearBatchGroup.getWorkersList().forEach(tacWorkerB -> {
                                if (persList.contains(tacWorkerB)) {
                                    tacInspYearBatchGroup.setDataStat("1");
                                    tacInspYearBatchGroup.setPris("违反年度和批次原则");
                                }
                            });
                        }
                        if (!"1".equals(tacInspYearBatchGroup.getDataStat())) {
                            vertifiArea(pris,tacInspYearBatchGroup,allTacWorker);
                        }
                    }
                    groupService.update(tacInspYearBatchGroup);
                }
            } else {
                tacInspYearBatch.getGroupList().forEach(tacInspYearBatchGroup -> {
                    tacInspYearBatchGroup.setDataStat("0");
                    tacInspYearBatchGroup.setPris("正常");
                    groupService.update(tacInspYearBatchGroup);
                });
            }
        }
        return 0;
    }

    private void vertifiArea(TacInspPersAreaPris pris, TacInspYearBatchGroup tacInspYearBatchGroup, List<TacWorkerB> allTacWorker) {
        if ("1".equals(pris.getIsArea())){
            List<TacInspYearBatchArea> areaList = tacInspYearBatchGroup.getAreaList();
            for (TacWorkerB workerB : tacInspYearBatchGroup.getWorkersList()) {
                if ("1".equals(tacInspYearBatchGroup.getDataStat())) {
                    break;
                }
                for (TacInspYearBatchArea area : areaList) {
                    if (area.getAdCode().equals(workerB.getWorkAd())) {
                        tacInspYearBatchGroup.setPris("工作地原则不符合");
                        tacInspYearBatchGroup.setDataStat("1");
                        break;
                    }
                }
            }
        }
        if (!"1".equals(tacInspYearBatchGroup.getDataStat())) {
             vertifiSex(pris,tacInspYearBatchGroup,allTacWorker);
        }
    }

    private void vertifiSex(TacInspPersAreaPris pris, TacInspYearBatchGroup tacInspYearBatchGroup, List<TacWorkerB> allTacWorker) {
        if (pris.getSiNvPersNum() != null && pris.getSiNvPersNum() != 0) {
            int sexNum = (int)(tacInspYearBatchGroup.getWorkersList().size()*pris.getSiNvPersNum());
            int index = 0;
            for (TacWorkerB workerB : tacInspYearBatchGroup.getWorkersList()) {
                if (index > sexNum) {
                    tacInspYearBatchGroup.setDataStat("1");
                    tacInspYearBatchGroup.setPris("不符合女性百分比原则");
                    break;
                }
                if ("女".equals(workerB.getSex())){
                    index ++;
                }
            }

        }
        if(!"1".equals(tacInspYearBatchGroup.getDataStat())) {
            vertifiGroupPers(pris,tacInspYearBatchGroup,allTacWorker);
        }
    }

    /**
     * 确认同组人数
     * @param pris
     * @param tacInspYearBatchGroup
     * @param allTacWorker
     */
    private void vertifiGroupPers(TacInspPersAreaPris pris, TacInspYearBatchGroup tacInspYearBatchGroup, List<TacWorkerB> allTacWorker) {
        if (pris.getSiSaPersNum() != null && pris.getSiSaPersNum().intValue() > 0) {
            Map<String,List<TacWorkerB>> map = new HashedMap();
            tacInspYearBatchGroup.getWorkersList().forEach(tacWorkerB -> {
                if (map.keySet().contains(tacWorkerB.getWorkAd())) {
                    map.get(tacWorkerB.getWorkAd()).add(tacWorkerB);
                } else {
                    List<TacWorkerB> list = new ArrayList<>();
                    list.add(tacWorkerB);
                    map.put(tacWorkerB.getWorkAd(),list);
                }
            });
            for (List<TacWorkerB> bs : map.values()) {
                if (bs.size() > pris.getSiSaPersNum().intValue()) {
                    tacInspYearBatchGroup.setDataStat("1");
                    tacInspYearBatchGroup.setPris("不符合同组工作地原则");
                    break;
                }
            }
        }
        if (!"1".equals(tacInspYearBatchGroup.getDataStat())) {
            vertifiGold(pris,tacInspYearBatchGroup,allTacWorker);
        }
    }

    /**
     * 确认分数
     * @param pris
     * @param tacInspYearBatchGroup
     * @param allTacWorker
     */
    private void vertifiGold(TacInspPersAreaPris pris, TacInspYearBatchGroup tacInspYearBatchGroup, List<TacWorkerB> allTacWorker) {
        List<TacWorkerB> list = tacInspYearBatchGroup.getWorkersList();
        if (allTacWorker == null ||  allTacWorker.size() == 0) {
            return;
        }
        if (pris.getSiBadPersNum() != null && pris.getSiBadPersNum().intValue() > 0) {
            int badIndex = 0;
            for (TacWorkerB tacWorkerB : list) {
                if (allTacWorker.indexOf(tacWorkerB) > 0 && allTacWorker.indexOf(tacWorkerB) < allTacWorker.size() * 0.2) {
                    badIndex++;
                }
            }
            if (badIndex > pris.getSiBadPersNum().intValue()) {
                tacInspYearBatchGroup.setPris("不符合差生原则");
                tacInspYearBatchGroup.setDataStat("1");
            }
        }
        if (!"1".equals(tacInspYearBatchGroup.getDataStat())) {

            if (pris.getSiGoodPersNum() != null && pris.getSiGoodPersNum().intValue() > 0) {
                int goodIndex = 0;
                for (TacWorkerB tacWorkerB : list) {
                    if (allTacWorker.indexOf(tacWorkerB) > 0 && allTacWorker.indexOf(tacWorkerB) > allTacWorker.size() * 0.8) {
                        goodIndex++;
                    }
                }
                if (goodIndex > pris.getSiGoodPersNum().intValue()) {
                    tacInspYearBatchGroup.setPris("不符合优秀生原则");
                    tacInspYearBatchGroup.setDataStat("1");
                }
            }
        }
    }

    @Override
    public int deleteYearBatchAllObj(String yearBatchId,String province) {
        // 判断批次是否分配项目
        TacInspYearBatchObjParam tacInspYearBatchObjParam = new TacInspYearBatchObjParam();
        tacInspYearBatchObjParam.setYearBatchId(yearBatchId);
        tacInspYearBatchObjParam.setProvince(province);
        List<TacInspYearBatchObj> batchObjList = tacInspYearBatchObjDao.findList(tacInspYearBatchObjParam);
        if(null != batchObjList && batchObjList.size()>0){
            throw  new CheckException("批次组中已分配项目，请先删除批次中的项目！！！");
        }
        TacInspYearBatchGroupPersParam persParam = new TacInspYearBatchGroupPersParam();
        persParam.setYearBatchId(yearBatchId);
        groupPersDao.deleteBy(persParam);
        TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
        groupParam.setYearBatchId(yearBatchId);
        groupService.deleteBy(groupParam);
        TacInspYearBatchAreaParam areaParam = new TacInspYearBatchAreaParam();
        areaParam.setYearBatchId(yearBatchId);
        areaParam.setProvince(province);
        areaDao.deleteBy(areaParam);
        this.tacInspYearBatchDao.delete(yearBatchId);
//        this.cleanAllObjByYearBatchId(yearBatchId);
        return 0;
    }


    @Override
    public TacInspYearBatch getCurrTacInspBatch(TacInspYearBatchParam tacInspYearBatchParam) {
        tacInspYearBatchParam.setDataStat("0");
        List<TacInspYearBatch> list = tacInspYearBatchDao.getTacInspYearBatchList(tacInspYearBatchParam);
        if (list.size() > 0) {
            TacInspYearBatch tacInspYearBatch = list.get(0);
            TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
            groupParam.setYearBatchId(tacInspYearBatch.getId());
            groupParam.setProvince(tacInspYearBatchParam.getProvince());
            tacInspYearBatch.setGroupList(groupService.getGroupListAndObj(groupParam));
            return tacInspYearBatch;
        }
        return null;
    }

    @Override
    public List<TacInspYearBatch> getTacInspBatchByPersId(TacInspYearBatchParam tacInspYearBatchParam) {
        List<TacInspYearBatch> list = tacInspYearBatchDao.getTacInspBatchByPersId(tacInspYearBatchParam);
        if (list.size() > 0) {
            for (TacInspYearBatch batch : list) {
                batch.setFlag("batch");
                TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
                groupParam.setYearBatchId(batch.getId());
                groupParam.setPersId(tacInspYearBatchParam.getPersId());
                List<TacInspYearBatchGroup> groupList = groupService.getGroupListByPersId(groupParam);
                batch.setGroupList(groupList);
            }

        }
        return list;
    }

    @Override
    public List<TacInspYearBatch> getBatchList(TacInspYearBatchParam tacInspYearBatchParam) {
        List<TacInspYearBatch> list = tacInspYearBatchDao.getBatchList(tacInspYearBatchParam);
//        if (list.size() > 0) {
//            list.forEach(tacInspYearBatch -> {
//                //获取稽察人员列表
//                TacWorkerBParam tacWorkerBParam = new TacWorkerBParam();
//                tacWorkerBParam.setYearBatchId(tacInspYearBatch.getId());
//                List<TacWorkerB> workerBList = this.workerBDao.getWorkerbsListById(tacWorkerBParam);
//                tacInspYearBatch.setWorkersList(workerBList);
//                //获取组列表
//                TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
//                groupParam.setYearBatchId(tacInspYearBatch.getId());
//                List<TacInspYearBatchGroup> groupList = groupService.getGroupList(groupParam);
//                tacInspYearBatch.setGroupList(groupList);
//            });
//        }
        return list;
    }

    @Override
    public PageInfo<TacInspYearBatch> getBatchPage(TacInspYearBatchParam tacInspYearBatchParam) {
        PageHelper.startPage(tacInspYearBatchParam);
        List<TacInspYearBatch> list = tacInspYearBatchDao.getBatchList(tacInspYearBatchParam);
        PageInfo<TacInspYearBatch> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public List<TacCountDto> countGroupAndPers(TacInspYearBatchParam tacInspYearBatchParam) {
        if (StringUtils.isNotBlank(tacInspYearBatchParam.getAdCode())) {
            tacInspYearBatchParam.setAdCode(String.valueOf(AdLevelUtil.SubAd(tacInspYearBatchParam.getAdCode()).get(SplitValue.SUBAD)));
        }
        List<TacCountDto> list = tacInspYearBatchDao.countGroupAndPers(tacInspYearBatchParam);
        return list;
    }

    @Override
    public List<TacCountDto> countRoleTypeAndPers(TacInspYearBatchParam tacInspYearBatchParam) {
        if (StringUtils.isNotBlank(tacInspYearBatchParam.getAdCode())) {
            tacInspYearBatchParam.setAdCode(String.valueOf(AdLevelUtil.SubAd(tacInspYearBatchParam.getAdCode()).get(SplitValue.SUBAD)));
        }
        List<TacCountDto> list = tacInspYearBatchDao.countRoleTypeAndPers(tacInspYearBatchParam);
        return list;
    }

    @Override
    public List<TacCountDto> countArea(TacInspYearBatchParam tacInspYearBatchParam) {
        if (StringUtils.isNotBlank(tacInspYearBatchParam.getAdCode())) {
            tacInspYearBatchParam.setAdCode(String.valueOf(AdLevelUtil.SubAd(tacInspYearBatchParam.getAdCode()).get(SplitValue.SUBAD)));
        }
        List<TacCountDto> list = tacInspYearBatchDao.countArea(tacInspYearBatchParam);
        return list;
    }

    @Override
    public Map<String,Object> uploadAuditExcel(MultipartFile file, TacInspYearBatchParam tacInspYearBatchParam) {
        int success = 0;
        int fail = 0;
        List<Row> rowList = ExportUtil.getRowListByFile(file);
        List<Object> list  = new ArrayList<>();
        if (rowList.size() > 2) {
            List<Map<String,Object>> mapList = ExportUtil.rowToMap(rowList, 1);
            if (mapList.size() > 0) {
                list = ExportUtil.mapToObj(mapList, TacInspYearBatchGroupAuditDto.class);
            }
        }
        if (list.size() > 0) {
            for (Object obj : list) {
                if (obj instanceof TacInspYearBatchGroupAuditDto) {
                    TacInspYearBatchGroupAuditDto dto = (TacInspYearBatchGroupAuditDto) obj;
                    if (StringUtils.isBlank(dto.getYear()) && StringUtils.isBlank(dto.getBatch())) {
                        continue;
                    }
                    if (StringUtils.isBlank(dto.getYear()) || StringUtils.isBlank(dto.getBatch())) {
                        fail++;
                        continue;
                    }
                    TacInspYearBatchParam param = new TacInspYearBatchParam();
                    param.setYear(Long.valueOf(dto.getYear()));
                    param.setBatch(Long.valueOf(dto.getBatch()));
                    param.setProvince(tacInspYearBatchParam.getProvince());
                    TacInspYearBatch batch = tacInspYearBatchDao.getBy(param);
                    if (batch == null) {
                        batch = new TacInspYearBatch();
                        batch.setId(UuidUtil.uuid());
                        batch.setYear(Long.valueOf(dto.getYear()));
                        batch.setBatch(Long.valueOf(dto.getBatch()));
                        batch.setIsAreaGroup("2");
                        batch.setIsPersGroup("2");
                        batch.setIsAppraisal("2");
                        batch.setInTm(new Date());
                        batch.setUpTm(new Date());
                        batch.setDataStat("0");
                        batch.setProvince(tacInspYearBatchParam.getProvince());
                        batch.setPersId(tacInspYearBatchParam.getPersId());
                        tacInspYearBatchDao.insert(batch);
                    } else {
                        batch.setUpTm(new Date());
                        tacInspYearBatchDao.update(batch);
                    }
                    batch.setProvince(tacInspYearBatchParam.getProvince());
                    TacInspYearBatchGroup group = null;
                    if (StringUtils.isNotBlank(dto.getGroupNm())){
                        TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
                        groupParam.setGroupNm(Long.valueOf(dto.getGroupNm()));
                        groupParam.setYearBatchId(batch.getId());
                        group = groupService.getBy(groupParam);
                        if (group == null) {
                            //新增
                            group = addGroup(batch, dto.getGroupNm(), dto.getRemark(), dto.getAudUnits(), dto.getAudCategory());
                            group.setProvince(tacInspYearBatchParam.getProvince());
                            tacInspYearBatchGroupDao.insert(group);
                        } else {
                            group.setUpTm(new Date());
                            group.setRemark(dto.getRemark());
                            group.setAudUnits(dto.getAudUnits());
                            group.setAudCategory(dto.getAudCategory());
                            group.setProvince(tacInspYearBatchParam.getProvince());
                            tacInspYearBatchGroupDao.update(group);
                        }
                    } else {
                        TacInspYearBatchGroupParam groupParam = new TacInspYearBatchGroupParam();
                        groupParam.setYearBatchId(batch.getId());
                        String groupNum = tacInspYearBatchGroupDao.getMaxGourpNum(groupParam);
                        if(StringUtils.isBlank(groupNum)){
                            groupNum="1";
                        }
                        //新增
                        group = addGroup(batch, groupNum, dto.getRemark(), dto.getAudUnits(), dto.getAudCategory());
                        group.setProvince(tacInspYearBatchParam.getProvince());
                        tacInspYearBatchGroupDao.insert(group);
                    }
                    if (StringUtils.isNotBlank(dto.getAreaList())) {
                        addAreaList(group,dto.getAreaList());
                    }
                    if (StringUtils.isNotBlank(dto.getRgstrList())) {
                        addRgstrList(group, dto.getRgstrList());
                    }
                    group.setProvince(tacInspYearBatchParam.getProvince());
                    addWorkerList("20",dto.getSpecial(),group);
                    addWorkerList("19",dto.getAssistant(),group);
                    addWorkerList("11",dto.getEarlyTis(),group);
                    addWorkerList("12",dto.getDevemanageTis(),group);
                    addWorkerList("13",dto.getPlanTis(),group);
                    addWorkerList("14",dto.getFinanceTis(),group);
                    addWorkerList("15",dto.getQualityTis(),group);
                    addWorkerList("16",dto.getSafetyTis(),group);
                    success++;
                }
            }
        }
        Map<String, Object> map = new HashedMap();
        map.put("success", success);
        map.put("fail", fail);
        return map;
    }

    private void addWorkerList(String roleType, String names, TacInspYearBatchGroup group) {
        if (StringUtils.isBlank(names)) {
            return;
        }
        TacInspYearBatchGroupPersParam bParam = new TacInspYearBatchGroupPersParam();
        bParam.setYearBatchId(group.getId());
        bParam.setRoleType(roleType);
        bParam.setProvince(group.getProvince());
        List<TacInspYearBatchGroupPers> list = groupPersDao.getGroupPersList(bParam);
        Map<String, TacInspYearBatchGroupPers> map = list.stream().collect(Collectors.toMap(TacInspYearBatchGroupPers::getPersName, Function.identity()));
        if (names.contains(",")) {
            for (String name : names.split(",")) {
                addGroupPers(roleType, name, group, map);
            }
        } else {
            addGroupPers(roleType, names, group, map);
        }
    }

    /**
     * add a groupPers
     * @param roleType
     * @param name
     * @param group
     * @param map
     */
    private void addGroupPers(String roleType, String name, TacInspYearBatchGroup group, Map<String, TacInspYearBatchGroupPers> map) {
        name = name.trim();
        if (!map.containsKey(name)) {
            TacWorkerBParam bParam = new TacWorkerBParam();
            bParam.setRoleType(roleType);
            bParam.setName(name);
            bParam.setProvince(group.getProvince());
            TacWorkerB b = workerBDao.getBy(bParam);
            if (b != null) {
                TacInspYearBatchGroupPers groupPers = new TacInspYearBatchGroupPers();
                groupPers.setId(UuidUtil.uuid());
                groupPers.setYearBatchId(group.getYearBatchId());
                groupPers.setYear(group.getYear());
                groupPers.setBatch(group.getBatch());
                groupPers.setGroupId(group.getId());
                groupPers.setGroupNm(group.getGroupNm());
                groupPers.setPersId(b.getId());
                groupPers.setCtPersId(group.getPersId());
                groupPers.setInTm(new Date());
                groupPers.setUpTm(new Date());
                groupPers.setRoleType(roleType);
                groupPersDao.insert(groupPers);
                map.put(name, groupPers);
            }
        } else {
            TacInspYearBatchGroupPers groupPers = map.get(name);
            groupPers.setUpTm(new Date());
            if (!groupPers.getGroupId().equals(group.getId())) {
                groupPers.setGroupNm(group.getGroupNm());
                groupPers.setGroupId(group.getId());
            }
            groupPersDao.update(groupPers);
        }
    }

    private void addRgstrList(TacInspYearBatchGroup group, String rgstrList) {
        TacInspYearBatchObjParam param = new TacInspYearBatchObjParam();
        param.setGroupId(group.getId());
        List<TacInspYearBatchObj> list = objDao.findList(param);
        Map<String, TacInspYearBatchObj> map = list.stream().collect(Collectors.toMap(TacInspYearBatchObj::getOjbNm, Function.identity()));
        if (rgstrList.contains(",")){
            for (String name : rgstrList.split(",")) {
                addRgstr(name, group, map);
            }
        } else {
            addRgstr(rgstrList, group, map);
        }
    }

    /**
     * add a obj
     * @param name
     * @param group
     * @param map
     */
    private void addRgstr(String name, TacInspYearBatchGroup group, Map<String, TacInspYearBatchObj> map) {
        if (StringUtils.isBlank(name)) {
            return;
        }
        name = name.trim();
        if (!map.containsKey(name)) {
            TacAttPawpBaseParam baseParam = new TacAttPawpBaseParam();
            baseParam.setName(name);
            List<TacAttPawpBase> baseList = pawpBaseDao.findList(baseParam);
            if (baseList.size() == 0) {
                return;
            }
            TacAttPawpBase base = baseList.get(0);
            TacInspYearBatchObj obj = new TacInspYearBatchObj();
            obj.setId(UuidUtil.uuid());
            obj.setYearBatchId(group.getYearBatchId());
            obj.setYear(group.getYear());
            obj.setBatch(group.getBatch());
            obj.setGroupId(group.getId());
            obj.setGroupNm(group.getGroupNm());
            obj.setOjbId(base.getId());
            obj.setOjbNm(name);
            obj.setInTm(new Date());
            obj.setUpTm(new Date());
            obj.setPersId(group.getPersId());
            obj.setDataStat("0");
            objDao.insert(obj);
            TacPawpRgstr rgstr = new TacPawpRgstr();
            BeanUtil.copyObject1(base,rgstr);
            rgstr.setGroupId(group.getId());
            rgstr.setId(UuidUtil.uuid());
            rgstr.setObjId(obj.getId());
            rgstr.setDataStat("0");
            rgstr.setIntm(new Date());
            rgstr.setUptm(new Date());
            pawpRgstrDao.insert(rgstr);
            map.put(name, obj);
        } else {
            TacInspYearBatchObj obj = map.get(name);
            obj.setUpTm(new Date());
            objDao.update(obj);
            TacPawpRgstrParam rgstrParam = new TacPawpRgstrParam();
            rgstrParam.setObjId(obj.getId());
            List<TacPawpRgstr> rgstrList = pawpRgstrDao.findList(rgstrParam);
            if (rgstrList.size() > 0) {
                TacPawpRgstr rgstr = rgstrList.get(0);
                rgstr.setUptm(new Date());
                pawpRgstrDao.update(rgstr);
            }
        }
    }

    private void addAreaList(TacInspYearBatchGroup group, String areaList) {
        TacInspYearBatchAreaParam areaParam = new TacInspYearBatchAreaParam();
        areaParam.setGroupId(group.getId());
        List<TacInspYearBatchArea> list = areaDao.findList(areaParam);
        Map<String, TacInspYearBatchArea> map = list.stream().collect(Collectors.toMap(TacInspYearBatchArea::getAdName, Function.identity()));
        if (areaList.contains(",")){
            for (String area : areaList.split(",")) {
                addArea(group, area, map);
            }
        } else {
            addArea(group, areaList, map);
        }
    }

    /**
     * add a area
     * @param group
     * @param area
     * @param map
     */
    private void addArea(TacInspYearBatchGroup group, String area, Map<String,TacInspYearBatchArea> map) {
        area = area.trim();
        if (!map.containsKey(area)) {
            AttAdXBaseParam baseParam = new AttAdXBaseParam();
            baseParam.setAdName(area);
            AttAdXBase base = attAdXBaseDao.getBy(baseParam);
            if (base != null) {
                TacInspYearBatchArea batchArea = new TacInspYearBatchArea();
                batchArea.setId(UuidUtil.uuid());
                batchArea.setYear(group.getYear());
                batchArea.setBatch(group.getBatch());
                batchArea.setYearBatchId(group.getYearBatchId());
                batchArea.setGroupId(group.getId());
                batchArea.setGroupNm(group.getGroupNm());
                batchArea.setAdCode(base.getAdCode());
                batchArea.setAdName(area);
                batchArea.setInTm(new Date());
                batchArea.setUpTm(new Date());
                batchArea.setDataStat("0");
                batchArea.setPersId(group.getPersId());
                map.put(area, batchArea);
                areaDao.insert(batchArea);
            }
        } else {
            TacInspYearBatchArea batchArea = map.get(area);
            batchArea.setUpTm(new Date());
            areaDao.update(batchArea);
        }
    }

    private TacInspYearBatchGroup addGroup(TacInspYearBatch batch, String groupNm, String remark, String audUnits, String audCategory) {
        TacInspYearBatchGroup group = new TacInspYearBatchGroup();
        group.setId(UuidUtil.uuid());
        group.setYear(batch.getYear());
        group.setBatch(batch.getBatch());
        group.setYearBatchId(batch.getId());
        group.setGroupNm(Long.valueOf(groupNm));
        group.setRemark(remark);
        group.setAudUnits(audUnits);
        group.setAudCategory(audCategory);
        group.setInTm(new Date());
        group.setUpTm(new Date());
        group.setPersId(batch.getPersId());
        group.setProvince(batch.getProvince());
        group.setConfirmer("0");
        tacInspYearBatchGroupDao.insert(group);
        return group;
    }
}