fj-dc/.svn/pristine/f8/f8aa12fba70754f18c00ade5bff9a036d28cdb26.svn-base

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

import cn.com.goldenwater.dcproj.dao.AttInspTypeDao;
import cn.com.goldenwater.dcproj.dao.IndexTotalQhDao;
import cn.com.goldenwater.dcproj.dto.DcIndexTotalQhDto;
import cn.com.goldenwater.dcproj.model.AttAdBase;
import cn.com.goldenwater.dcproj.model.AttInspType;
import cn.com.goldenwater.dcproj.model.RelOrgInspType;
import cn.com.goldenwater.dcproj.param.RelOrgInspTypeParam;
import cn.com.goldenwater.dcproj.service.AttAdBaseService;
import cn.com.goldenwater.dcproj.service.IndexTotalQhService;
import cn.com.goldenwater.dcproj.service.OlBisInspOrgService;
import cn.com.goldenwater.dcproj.service.RelOrgInspTypeService;
import cn.com.goldenwater.dcproj.utils.AdLevelUtil;
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 com.alibaba.fastjson.TypeReference;
import oracle.sql.TIMESTAMP;
import org.apache.commons.collections.CollectionUtils;
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 java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class IndexTotalQhServiceImpl implements IndexTotalQhService {

    @Autowired
    private IndexTotalQhDao indexTotalQhDao;

    @Autowired
    private OlBisInspOrgService olBisInspOrgService;

    @Autowired
    private AttAdBaseService attAdBaseService;

    @Autowired
    private RedisOperator redisOperator;

    @Autowired
    private RelOrgInspTypeService relOrgInspTypeService;

    @Autowired
    private AttInspTypeDao attInspTypeDao;

    private static final String DC_INDEX_TOTAL_OBJ_PBLM_REDIS_KEY_PREFIX = "DITOP_";

    /**
     * PERSIZE    PBLMSIZE    GROUPSIZE    MENDSIZE    OBJSIZE  PDSIZE
     *
     * @param dcIndexTotalQhDto
     * @return
     */
    @Override
    public List<Map<String, Object>> totalByType(DcIndexTotalQhDto dcIndexTotalQhDto) {
        getAdCode(dcIndexTotalQhDto);

        List<Map<String, Object>> objPblmData = getObjPblmData(dcIndexTotalQhDto);
        List<Map<String, Object>> persData = indexTotalQhDao.getPersData(dcIndexTotalQhDto);
        List<Map<String, Object>> zgData = indexTotalQhDao.getZgData(dcIndexTotalQhDto);

        List<RelOrgInspType> relOrgInspTypeList = relOrgInspTypeService.findList(Builder
                .of(RelOrgInspTypeParam::new)
                .with(RelOrgInspTypeParam::setOrgId, dcIndexTotalQhDto.getOrgId())
                .build());

        if (CollectionUtils.isEmpty(relOrgInspTypeList)) {
            throw new CheckException("未找到机构下的的督查类别！");
        }

        List<String> objTypeList = relOrgInspTypeList.stream()
                .map(RelOrgInspType::getInspType)
                .filter(StringUtils::isNotBlank)
                .distinct()
                .collect(Collectors.toList());

        List<Map<String, Object>> ret = new ArrayList<>();

        Map<String, Object> all = new HashMap<>(8);
        all.put("inspName", "全部");
        all.put("PERSIZE", persData.stream()
                .map(o -> MapUtils.getString(o, "PERSID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("GROUPSIZE", objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "STTM", o))
                .map(o -> MapUtils.getString(o, "ID"))
                .filter(StringUtils::isNotBlank)
                .filter(o -> o.length() == 12)
                .distinct()
                .count()
        );
        all.put("OBJSIZE", objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "OBJ_INTM", o))
                .map(o -> MapUtils.getString(o, "OBJ_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("PBLMSIZE", objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                .map(o -> MapUtils.getString(o, "PBLM_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("MENDSIZE", zgData.stream()
                .map(o -> MapUtils.getString(o, "ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("PDSIZE", zgData.stream()
                .filter(o -> "1".equals(MapUtils.getString(o, "PBLM_OUT")))
                .map(o -> MapUtils.getString(o, "ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        ret.add(all);

        for (String objType : objTypeList) {
            Map<String, Object> map = new HashMap<>(8);
            map.put("CODE", objType);
            map.put("inspName", objPblmData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .map(o -> MapUtils.getString(o, "INSP_NAME"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .findFirst().orElseGet(() -> {
                        AttInspType attInspType = attInspTypeDao.get(objType);
                        return Optional.ofNullable(attInspType).map(AttInspType::getName).orElse("");
                    }));
            map.put("PERSIZE", persData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .map(o -> MapUtils.getString(o, "PERSID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("GROUPSIZE", objPblmData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "STTM", o))
                    .map(o -> MapUtils.getString(o, "ID"))
                    .filter(StringUtils::isNotBlank)
                    .filter(o -> o.length() == 12)
                    .distinct()
                    .count()
            );
            map.put("OBJSIZE", objPblmData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "OBJ_INTM", o))
                    .map(o -> MapUtils.getString(o, "OBJ_ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("PBLMSIZE", objPblmData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                    .map(o -> MapUtils.getString(o, "PBLM_ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("MENDSIZE", zgData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .map(o -> MapUtils.getString(o, "ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("PDSIZE", zgData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .filter(o -> "1".equals(MapUtils.getString(o, "PBLM_OUT")))
                    .map(o -> MapUtils.getString(o, "ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );

            ret.add(map);
        }

        return ret;
    }

    /**
     * PERSIZE    PBLMSIZE    GROUPSIZE    MENDSIZE    OBJSIZE  PDSIZE
     *
     * @param dcIndexTotalQhDto
     * @return
     */
    @Override
    public List<Map<String, Object>> totalPblmByPtype(DcIndexTotalQhDto dcIndexTotalQhDto) {
        getAdCode(dcIndexTotalQhDto);

        List<Map<String, Object>> objPblmData = getObjPblmData(dcIndexTotalQhDto);

        List<String> objTypeList = objPblmData.stream()
                .map(o -> MapUtils.getString(o, "CODE"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .collect(Collectors.toList());

        List<Map<String, Object>> ret = new ArrayList<>();
        for (String objType : objTypeList) {
            Map<String, Object> map = new HashMap<>(3);
            map.put("CODE", objType);
            map.put("inspName", objPblmData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .map(o -> MapUtils.getString(o, "INSP_NAME"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .findFirst());

            map.put("PBLMSIZE", objPblmData.stream()
                    .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                    .map(o -> MapUtils.getString(o, "PBLM_ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            ret.add(map);
        }

        ret = ret.stream()
                .sorted(Comparator.comparingInt(o -> MapUtils.getIntValue((Map) o, "PBLMSIZE")).reversed())
                .limit(10)
                .collect(Collectors.toList());

        return ret;
    }


    /**
     * PERSIZE    PBLMSIZE    GROUPSIZE    MENDSIZE    OBJSIZE  PDSIZE
     *
     * @param dcIndexTotalQhDto
     * @return
     */
    @Override
    public List<Map<String, Object>> totalByAdCode(DcIndexTotalQhDto dcIndexTotalQhDto) {
        getAdCode(dcIndexTotalQhDto);
        List<Map<String, Object>> objPblmData = getObjPblmData(dcIndexTotalQhDto);
        List<Map<String, Object>> persData = indexTotalQhDao.getPersData(dcIndexTotalQhDto);
        List<Map<String, Object>> zgData = indexTotalQhDao.getZgData(dcIndexTotalQhDto);

        String upAdCode = dcIndexTotalQhDto.getAdCode();
        switch (upAdCode.length()) {
            case 2:
                upAdCode += "0000000000";
                break;
            case 4:
                upAdCode += "00000000";
                break;
            default:
        }
        List<AttAdBase> adBaseList = attAdBaseService.getAdData(upAdCode);
        AttAdBase adBase = attAdBaseService.get(upAdCode);

        List<Map<String, Object>> ret = new ArrayList<>();

        Map<String, Object> all = new HashMap<>(8);
        all.put("CODE", adBase.getAdCode());
        all.put("inspName", adBase.getAdName());
        all.put("LAT", adBase.getLttd());
        all.put("LONG", adBase.getLgtd());
        all.put("PERSIZE", persData.stream()
                .map(o -> MapUtils.getString(o, "PERSID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("GROUPSIZE", objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "STTM", o))
                .map(o -> MapUtils.getString(o, "ID"))
                .filter(StringUtils::isNotBlank)
                .filter(o -> o.length() == 12)
                .distinct()
                .count()
        );
        all.put("OBJSIZE", objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "OBJ_INTM", o))
                .map(o -> MapUtils.getString(o, "OBJ_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("PBLMSIZE", objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                .map(o -> MapUtils.getString(o, "PBLM_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("MENDSIZE", zgData.stream()
                .map(o -> MapUtils.getString(o, "ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        all.put("PDSIZE", zgData.stream()
                .filter(o -> "1".equals(MapUtils.getString(o, "PBLM_OUT")))
                .map(o -> MapUtils.getString(o, "ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );

        ret.add(all);

        for (AttAdBase attAdBase : adBaseList) {
            String adCode = AdLevelUtil.getAddvcd(attAdBase.getAdCode());
            Map<String, Object> map = new HashMap<>(10);
            map.put("CODE", attAdBase.getAdCode());
            map.put("inspName", attAdBase.getAdName());
            map.put("LAT", attAdBase.getLttd());
            map.put("LONG", attAdBase.getLgtd());
            map.put("PERSIZE", persData.stream()
                    .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                    .map(o -> MapUtils.getString(o, "PERSID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("GROUPSIZE", objPblmData.stream()
                    .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "STTM", o))
                    .map(o -> MapUtils.getString(o, "ID"))
                    .filter(StringUtils::isNotBlank)
                    .filter(o -> o.length() == 12)
                    .distinct()
                    .count()
            );
            map.put("OBJSIZE", objPblmData.stream()
                    .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "OBJ_INTM", o))
                    .map(o -> MapUtils.getString(o, "OBJ_ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("PBLMSIZE", objPblmData.stream()
                    .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                    .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                    .map(o -> MapUtils.getString(o, "PBLM_ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("MENDSIZE", zgData.stream()
                    .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                    .map(o -> MapUtils.getString(o, "ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );
            map.put("PDSIZE", zgData.stream()
                    .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                    .filter(o -> "1".equals(MapUtils.getString(o, "PBLM_OUT")))
                    .map(o -> MapUtils.getString(o, "ID"))
                    .filter(StringUtils::isNotBlank)
                    .distinct()
                    .count()
            );

            ret.add(map);
        }

        return ret;
    }

    /**
     * PERSIZE    PBLMSIZE    GROUPSIZE    MENDSIZE    OBJSIZE  PDSIZE
     *
     * @param dcIndexTotalQhDto
     * @return
     */
    @Override
    public List<Map<String, Object>> pblmByAdCode(DcIndexTotalQhDto dcIndexTotalQhDto) {
        getAdCode(dcIndexTotalQhDto);
        String upAdCode = dcIndexTotalQhDto.getAdCode();
        switch (upAdCode.length()) {
            case 2:
                upAdCode += "0000000000";
                break;
            case 4:
                upAdCode += "00000000";
                break;
            default:
        }
        List<Map<String, Object>> objPblmData = getObjPblmData(dcIndexTotalQhDto);

        List<AttAdBase> adBaseList = attAdBaseService.getAdData(upAdCode);
        List<String> objTypeList = objPblmData.stream()
                .map(o -> MapUtils.getString(o, "CODE"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .sorted(
                        Comparator.comparing(o -> objPblmData.stream()
                                .filter(a -> o.equals(MapUtils.getString(a, "CODE")))
                                .map(a -> MapUtils.getString(a, "PBLM_ID"))
                                .filter(StringUtils::isNotBlank)
                                .distinct()
                                .count()).reversed()
                )
                .limit(10)
                .collect(Collectors.toList());

        List<Map<String, Object>> ret = new ArrayList<>();
        for (AttAdBase attAdBase : adBaseList) {
            String adCode = AdLevelUtil.getAddvcd(attAdBase.getAdCode());
            Map<String, Object> map = new HashMap<>(3);
            map.put("CODE", attAdBase.getAdCode());
            map.put("inspName", attAdBase.getAdName());
            List<Map<String, Object>> value = new ArrayList<>();
            for (String objType : objTypeList) {
                Map<String, Object> valueMap = new HashMap<>(3);
                valueMap.put("CODE", objType);
                valueMap.put("inspName", objPblmData.stream()
                        .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                        .map(o -> MapUtils.getString(o, "INSP_NAME"))
                        .filter(StringUtils::isNotBlank)
                        .distinct()
                        .findFirst());
                valueMap.put("PBLMSIZE", objPblmData.stream()
                        .filter(o -> objType.equals(MapUtils.getString(o, "CODE")))
                        .filter(o -> MapUtils.getString(o, "OBJ_AD_CODE", "AAA").contains(adCode))
                        .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                        .map(o -> MapUtils.getString(o, "PBLM_ID"))
                        .filter(StringUtils::isNotBlank)
                        .distinct()
                        .count()
                );
                value.add(valueMap);
            }
            map.put("PBLMSIZE", value);
            ret.add(map);
        }

        return ret;
    }

    /**
     * PERSIZE    PBLMSIZE    GROUPSIZE    MENDSIZE    OBJSIZE  PDSIZE
     *
     * @param dcIndexTotalQhDto
     * @return
     */
    @Override
    public Map<String, Object> pblmByCate(DcIndexTotalQhDto dcIndexTotalQhDto) {
        getAdCode(dcIndexTotalQhDto);
        List<Map<String, Object>> objPblmData = getObjPblmData(dcIndexTotalQhDto);
        objPblmData = objPblmData.stream()
                .filter(o -> checkInTime(dcIndexTotalQhDto, "COLL_TIME", o))
                .collect(Collectors.toList());


        Map<String, Object> ret = new HashMap<>(4);
        ret.put("INFOPBLMSIZE", objPblmData.stream()
                .filter(o -> "0".equals(MapUtils.getString(o, "INSP_PBLM_CATE")))
                .map(o -> MapUtils.getString(o, "PBLM_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        ret.put("WARMPBLMSIZE", objPblmData.stream()
                .filter(o -> "1".equals(MapUtils.getString(o, "INSP_PBLM_CATE")))
                .map(o -> MapUtils.getString(o, "PBLM_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        ret.put("ERRORPBLMSIZE", objPblmData.stream()
                .filter(o -> "2".equals(MapUtils.getString(o, "INSP_PBLM_CATE")))
                .map(o -> MapUtils.getString(o, "PBLM_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );
        ret.put("ERRORSPBLMSIZE", objPblmData.stream()
                .filter(o -> "3".equals(MapUtils.getString(o, "INSP_PBLM_CATE")))
                .map(o -> MapUtils.getString(o, "PBLM_ID"))
                .filter(StringUtils::isNotBlank)
                .distinct()
                .count()
        );

        return ret;
    }

    private void getAdCode(DcIndexTotalQhDto dcIndexTotalQhDto) {
        if (StringUtils.isBlank(dcIndexTotalQhDto.getAdCode())) {
            dcIndexTotalQhDto.setAdCode(AdLevelUtil.getAddvcd(olBisInspOrgService.getProvince(dcIndexTotalQhDto.getOrgId())));
        } else {
            dcIndexTotalQhDto.setAdCode(AdLevelUtil.getAddvcd(dcIndexTotalQhDto.getAdCode()));
        }
    }

    private List<Map<String, Object>> getObjPblmData(DcIndexTotalQhDto dcIndexTotalQhDto) {
        String redisKey = DC_INDEX_TOTAL_OBJ_PBLM_REDIS_KEY_PREFIX + dcIndexTotalQhDto.toString();
        String ret = redisOperator.get(redisKey);
        if (ret == null) {
            List<Map<String, Object>> objPblmData = indexTotalQhDao.getObjPblmData(dcIndexTotalQhDto);
            redisOperator.set(redisKey, JSON.toJSONString(objPblmData), 300);
            return objPblmData;
        }

        return JSON.parseObject(ret, new TypeReference<List<Map<String, Object>>>() {
        });
    }

    private boolean checkInTime(DcIndexTotalQhDto dcIndexTotalQhDto, String param, Map<String, Object> map) {
        boolean ret = false;
        if (dcIndexTotalQhDto.getSttm() == null && dcIndexTotalQhDto.getEntm() == null) {
            return true;
        }
        Object timeObj = map.get(param);
        Date time = null;

        if (timeObj instanceof oracle.sql.TIMESTAMP) {
            oracle.sql.TIMESTAMP t = (TIMESTAMP) timeObj;
            try {
                time = new Date(t.dateValue().getTime());
            } catch (SQLException e) {
                e.printStackTrace();
            }
        } else if (timeObj instanceof Long) {
            time = new Date((Long) timeObj);
        } else {
            time = (Date) timeObj;
        }

        if (time == null) {
            return ret;
        }

        if (dcIndexTotalQhDto.getSttm() != null) {
            if (dcIndexTotalQhDto.getSttm().before(time)) {
                ret = true;
            } else {
                return false;
            }
        }

        if (dcIndexTotalQhDto.getEntm() != null) {
            if (dcIndexTotalQhDto.getEntm().after(time)) {
                ret = true;
            }
        }
        return ret;
    }
}