fj-dc/.svn/pristine/41/414ca6c910ea8ee28bee2004fc76eec52b754d72.svn-base

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

import cn.com.goldenwater.core.service.AbstractCrudService;
import cn.com.goldenwater.dcproj.constValue.SplitValue;
import cn.com.goldenwater.dcproj.dao.BisInspItemQuesNumDao;
import cn.com.goldenwater.dcproj.dao.ObjInspPblmsDao;
import cn.com.goldenwater.dcproj.dto.BisInspItemQuesNumDto;
import cn.com.goldenwater.dcproj.dto.DictDto;
import cn.com.goldenwater.dcproj.dto.ObjInspPblmsDto;
import cn.com.goldenwater.dcproj.model.ObjInspPblms;
import cn.com.goldenwater.dcproj.model.ObjTypeCheck;
import cn.com.goldenwater.dcproj.model.OlBisInspOrg;
import cn.com.goldenwater.dcproj.param.ObjInspPblmsParam;
import cn.com.goldenwater.dcproj.param.ObjInspPblmsParams;
import cn.com.goldenwater.dcproj.service.ObjInspPblmsService;
import cn.com.goldenwater.dcproj.service.OlBisInspOrgService;
import cn.com.goldenwater.dcproj.utils.Builder;
import cn.com.goldenwater.dcproj.utils.RedisOperator;
import cn.com.goldenwater.target.CheckException;
import com.alibaba.fastjson.JSON;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * @author lune
 * @date 2019-2-18
 */
@Service
@Transactional
public class ObjInspPblmsServiceImpl extends AbstractCrudService<ObjInspPblms, ObjInspPblmsParam> implements ObjInspPblmsService {

    @Autowired
    private ObjInspPblmsDao objInspPblmsDao;
    @Autowired
    private BisInspItemQuesNumDao bisInspItemQuesNumDao;
    @Autowired
    private OlBisInspOrgService olBisInspOrgService;
    @Autowired
    private RedisOperator redisOperator;

    private final String OBJ_INSP_PBLMS_PRE = "OBJ_INSP_PBLMS_PRE_";

    public ObjInspPblmsServiceImpl(ObjInspPblmsDao objInspPblmsDao) {
        super(objInspPblmsDao);
        this.objInspPblmsDao = objInspPblmsDao;
    }

    // 问题标准 - 全国标准
    private final static String NATIONAL_STANDARD = "0";

    // 问题标准 - 自定义标准
    private final static String CUSTOM_STANDARD = "1";

    @Override
    public List findList(ObjInspPblmsParam param) {
        List objInspPblmsList = null;
        String redisKey = OBJ_INSP_PBLMS_PRE + (param == null ? "NULL" : param.toString());
        String objInspPblmsListStr = redisOperator.get(redisKey);
        if (objInspPblmsListStr == null) {
            objInspPblmsList = super.findList(param);
            redisOperator.set(redisKey, JSON.toJSONString(objInspPblmsList), 300);
            return objInspPblmsList;
        }
        return JSON.parseArray(objInspPblmsListStr, ObjInspPblms.class);
    }

    @Override
    public List<ObjInspPblmsDto> findPblmsDTO(String type, String pblmsName, String orgId,String sort1) {
        return objInspPblmsDao.findPblmsDTO(type, pblmsName, orgId, sort1);
    }

    @Override
    public List<ObjInspPblms> getPblmType(String type, String pguid, String orgId) {
        ObjInspPblmsParam p = Builder.of(ObjInspPblmsParam::new)
                .with(ObjInspPblmsParam::setType, type)
                .with(ObjInspPblmsParam::setPguid, StringUtils.isBlank(pguid) ? "00000000000000000000000000000000" : pguid)
                .with(ObjInspPblmsParam::setOrgId, orgId)
                .build();
        return objInspPblmsDao.findList(p);
    }

    @Override
    public List<ObjInspPblms> getPblmTypeInAttach(ObjInspPblmsParams objInspPblms) {
        List<ObjInspPblms> list = new ArrayList<>();
        ObjInspPblmsParam p = new ObjInspPblmsParam();
        p.setType(objInspPblms.getType());
        p.setAttach(objInspPblms.getAttach());
        if (StringUtils.isBlank(objInspPblms.getPguid())) {
            p.setPguid("00000000000000000000000000000000");
        } else {
            p.setPguid(objInspPblms.getPguid());
        }
        p.setSort1(objInspPblms.getSort1());
        p.setSn(objInspPblms.getSn());
        list = objInspPblmsDao.findList(p);
        return list;
    }

    @Override
    public List<ObjInspPblms> getPblmTypeInAttach(String attach, String type, String sn) {
        ObjInspPblmsParam p = new ObjInspPblmsParam();
        p.setSn(sn);
        p.setAttach(attach);
        p.setType(type);
        p.setSnClass("1");
        List<ObjInspPblms> pblmsParam = objInspPblmsDao.findList(p);
        if (pblmsParam == null) {
            return new ArrayList<>();
        }
        return pblmsParam;
    }

    @Override
    public ObjInspPblms getPblmTypeInAttach(String attach, String type, String sn, String snClass) {
        ObjInspPblmsParam p = new ObjInspPblmsParam();
        p.setSn(sn);
        p.setAttach(attach);
        p.setType(type);
        p.setSnClass(snClass);
        ObjInspPblms pblmsParam = objInspPblmsDao.getBy(p);
        if (pblmsParam == null) {
            return new ObjInspPblms();
        }
        return pblmsParam;
    }

    @Override
    public List<String> findPblmsName(String orgId) {
        return objInspPblmsDao.findPblmsName(orgId);
    }

    @Override
    public List<String> findPblmsCheckPoints(ObjInspPblmsParam objInspPblmsParam, String orgId) {
        OlBisInspOrg olBisInspOrg = olBisInspOrgService.get(orgId);
        if (olBisInspOrg == null) {
            throw new CheckException("当前机构不存在!!");
        }
        if ("1".equals(olBisInspOrg.getPblmLogo()) && "1".equals(objInspPblmsParam.getType())) {
            orgId = olBisInspOrg.getQuoteOrgId();
        } else {
            orgId = "";
        }
        return objInspPblmsDao.findPblmsCheckPoints(objInspPblmsParam.getInspPblmsName(), orgId, objInspPblmsParam.getType());
    }

    @Override
    public List<String> findPblmsDesc(Map<String, String> params) {

        return objInspPblmsDao.findPblmsDesc(params);
    }

    @Override
    public ObjInspPblms getByPblms(Map<String, String> params) {
        // Questions ??? 为啥要默认为小水库问题清单
        String type = params.get("type");
        if (StringUtils.isBlank(type)) {
            type = "1";
            params.put("type", type);
        }

        List<ObjInspPblms> inspPblms = objInspPblmsDao.getByPblms(params);
        if (inspPblms.size() > 0) {
            return inspPblms.get(0);
        }
        return new ObjInspPblms();
    }

    @Override
    public List<ObjTypeCheck> getPblmsByQuesNum(String id, String type, OlBisInspOrg olBisInspOrg) {
        List<ObjTypeCheck> list = new ArrayList<>();

        // 2. 获取问题
        List<BisInspItemQuesNumDto> bisInspItemQuesNumDtoList = new ArrayList<>();
        if (id == null || "0".equals(id)) {
            list = getAllPblmsByType(type, olBisInspOrg.getOrgId());
        } else {
            if (CUSTOM_STANDARD.equals(olBisInspOrg.getPblmLogo()) && "1".equals(type)) {
                // 自定义标准 - 要传 orgId
                bisInspItemQuesNumDtoList = bisInspItemQuesNumDao.getById(id, olBisInspOrg.getQuoteOrgId());
            } else {
                // 全国标准
                bisInspItemQuesNumDtoList = bisInspItemQuesNumDao.getById(id, null);
            }
        }

        // 3. 根据规则取出对应的附件 填入对象里
        if (bisInspItemQuesNumDtoList != null && bisInspItemQuesNumDtoList.size() > 0) {
            // 拼接
            for (BisInspItemQuesNumDto bisInspItemQuesNumDto : bisInspItemQuesNumDtoList) {
                //根据规则取出对应的附件 填入对象里
                String sn = bisInspItemQuesNumDto.getQuesSn();
                List<String> snList = new ArrayList<>();
                if (StringUtils.isBlank(sn)) {
                    continue;
                }
                String[] snSplitList = sn.split(SplitValue.DOUHAO_SPLIT);
                if (snSplitList.length > 0) {
                    for (String s : snSplitList) {
                        if (s.contains(SplitValue.HENG_SPLIT)) {
                            Integer startIndex = Integer.parseInt(s.split(SplitValue.HENG_SPLIT)[0]);
                            Integer endIndex = Integer.parseInt(s.split(SplitValue.HENG_SPLIT)[1]);
                            while (startIndex <= endIndex) {
                                snList.add(startIndex.toString());
                                startIndex++;
                            }
                        } else {
                            snList.add(s);
                        }
                    }
                } else {
                    snList.add(sn);
                }
                Map<String, Object> param = new HashMap<>();
                //获取标准库中问题类别
                param.put("orgId", "");
                if ("1".equals(olBisInspOrg.getPblmLogo()) && "1".equals(type)) {
                    param.put("orgId", olBisInspOrg.getQuoteOrgId());
                }
                param.put("type", type);
                param.put("fileNum", bisInspItemQuesNumDto.getFileNum());
                param.put("sheetNum", bisInspItemQuesNumDto.getSheetNum());
                param.put("snList", snList);
                List<Map<String, String>> pblmTypeList = objInspPblmsDao.getPblmsTypeBySnAttType(param);
                for (Map<String, String> pblmType : pblmTypeList) {
                    String sort1 = pblmType.get("SORT1");
                    String name = pblmType.get("INSP_PBLMS_NAME");
                    List<ObjTypeCheck> checkList = new ArrayList<>();
                    //获取每个问题类别下的检查项
                    param.put("sort1", sort1);
                    List<Map<String, String>> pblmCheckList = objInspPblmsDao.getPblmsCheckBySnAttType(param);
                    for (Map<String, String> pblmCheck : pblmCheckList) {
                        String sort2 = pblmCheck.get("SORT2");
                        String check = pblmCheck.get("CHECK_POINT");
                        //获取检查项下的所有问题描述列表（问题序号）
                        param.put("SORT2", sort2);
                        List<ObjInspPblms> pblmList = objInspPblmsDao.getPblmsBySnAttTypeSort(param);
                        ObjTypeCheck objTypeCheck = new ObjTypeCheck();
                        objTypeCheck.setSort(sort2);
                        objTypeCheck.setName(check);
                        objTypeCheck.setItems(pblmList);
                        checkList.add(objTypeCheck);
                    }
                    ObjTypeCheck objTypeCheck = new ObjTypeCheck();
                    objTypeCheck.setSort(sort1);
                    objTypeCheck.setName(name);
                    objTypeCheck.setItems(checkList);
                    list.add(objTypeCheck);
                }
            }
        }
        return list;
    }

    @Override
    public List<ObjTypeCheck> getAllPblmsByType(String type, String orgId) {
        List<ObjTypeCheck> list = new ArrayList<>();
        Map<String, Object> param = new HashMap<>(2);
        // 获取标准库中问题类别
        OlBisInspOrg olBisInspOrg = olBisInspOrgService.get(orgId);
        Optional.ofNullable(olBisInspOrg).orElseThrow(() -> new CheckException("当前机构不存在!!"));

        param.put("type", type);
        if ("1".equals(olBisInspOrg.getPblmLogo()) && "1".equals(type)) {
            param.put("orgId", olBisInspOrg.getQuoteOrgId());
        }

        List<Map<String, String>> pblmTypeList = objInspPblmsDao.getPblmsTypeBySnAttType(param);
        for (Map<String, String> pblmType : pblmTypeList) {
            pblmType.put("CHECK_POINT", null);
            pblmType.put("PBLM_DESC", null);
        }
        pblmTypeList.stream()
                .sorted(Comparator.comparing(a -> MapUtils.getInteger(a, "SORT1")))
                .distinct().forEach(one -> {
            List<ObjTypeCheck> checkList = new ArrayList<>();
            String name = one.get("INSP_PBLMS_NAME");
            param.put("fileNum", one.get("ATTACH"));
            param.put("sort1", one.get("SORT1"));
            List<Map<String, String>> pblmCheckList = objInspPblmsDao.getPblmsCheckBySnAttType(param);
            for (Map<String, String> pblmCheck : pblmCheckList) {
                String sort2 = pblmCheck.get("SORT2");
                String check = pblmCheck.get("CHECK_POINT");
                //获取检查项下的所有问题描述列表（问题序号）
                param.put("sort2", sort2);
                List<ObjInspPblms> pblmList = objInspPblmsDao.getPblmsBySnAttTypeSort(param);
                ObjTypeCheck objTypeCheck = new ObjTypeCheck();
                objTypeCheck.setOrgId(orgId);
                objTypeCheck.setSort(sort2);
                objTypeCheck.setName(check);
                objTypeCheck.setItems(pblmList);
                checkList.add(objTypeCheck);
            }

            ObjTypeCheck objTypeCheck = new ObjTypeCheck();
            objTypeCheck.setSort(one.get("SORT1"));
            objTypeCheck.setName(one.get("INSP_PBLMS_NAME"));
            objTypeCheck.setItems(checkList);
            list.add(objTypeCheck);
        });

//        for (Map<String, String> pblmType : pblmTypeList) {
//            String attach = pblmType.get("ATTACH");
//            String sort1 = pblmType.get("SORT1");
//            String name = pblmType.get("INSP_PBLMS_NAME");
//            List<ObjTypeCheck> checkList = new ArrayList<>();
//            //获取每个问题类别下的检查项
//            param.put("fileNum", attach);
//            param.put("sort1", sort1);
//            List<Map<String, String>> pblmCheckList = objInspPblmsDao.getPblmsCheckBySnAttType(param);
//            for (Map<String, String> pblmCheck : pblmCheckList) {
//                String sort2 = pblmCheck.get("SORT2");
//                String check = pblmCheck.get("CHECK_POINT");
//                //获取检查项下的所有问题描述列表（问题序号）
//                param.put("sort2", sort2);
//                List<ObjInspPblms> pblmList = objInspPblmsDao.getPblmsBySnAttTypeSort(param);
//                ObjTypeCheck objTypeCheck = new ObjTypeCheck();
//                objTypeCheck.setOrgId(orgId);
//                objTypeCheck.setSort(sort2);
//                objTypeCheck.setName(check);
//                objTypeCheck.setItems(pblmList);
//                checkList.add(objTypeCheck);
//            }
//            ObjTypeCheck objTypeCheck = new ObjTypeCheck();
//            objTypeCheck.setSort(sort1);
//            objTypeCheck.setName(name);
//            objTypeCheck.setItems(checkList);
//            list.add(objTypeCheck);
//        }
        return list;
    }

    @Override
    public ObjInspPblms getPblmsByType(ObjInspPblmsParam objInspPblmsParam) {
        List<ObjInspPblms> inspPblms = objInspPblmsDao.getPblmsByType(objInspPblmsParam);
        if (inspPblms.size() > 0) {
            return inspPblms.get(0);
        }
        return new ObjInspPblms();
    }

    @Override
    public List<String> getPblmNames(ObjInspPblmsParam objInspPblmsParam) {

        return this.objInspPblmsDao.getPblmNames(objInspPblmsParam);
    }

    @Override
    public List<ObjInspPblmsDto> findPblmsDtoName(String type, String pblmsName, String orgId,String sort1) {
        return objInspPblmsDao.findPblmsDtoName(type, pblmsName, orgId,sort1);
    }

    @Override
    public DictDto findLastVersion(String name) {
        return objInspPblmsDao.findLastVersion(name);
    }


}