water-iot/meter-reading-tianjin/src/main/java/com/huaxu/zoniot/service/impl/TianJinMeterReadingServiceImpl.java

package com.huaxu.zoniot.service.impl;

import cn.hutool.core.date.DateUtil;
import com.huaxu.zoniot.common.Constants;
import com.huaxu.zoniot.common.ErrorConstants;
import com.huaxu.zoniot.common.ResultStatus;
import com.huaxu.zoniot.common.ServiceException;
import com.huaxu.zoniot.dao.CustomerMapper;
import com.huaxu.zoniot.dao.WaterMeterMapper;
import com.huaxu.zoniot.dto.RegistIMEIRequest;
import com.huaxu.zoniot.dto.RespData;
import com.huaxu.zoniot.dto.RtnData;
import com.huaxu.zoniot.entity.*;
import com.huaxu.zoniot.repository.MeterReadRecordRepository;
import com.huaxu.zoniot.service.BuildingService;
import com.huaxu.zoniot.service.CommunityService;
import com.huaxu.zoniot.service.TianJinMeterReadingService;
import com.huaxu.zoniot.service.WaterMeterService;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * <p></p>
 *
 * @Author wilian.peng
 * @Date 2021/1/8 14:42
 * @Version 1.0
 */
@Slf4j
@Service
public class TianJinMeterReadingServiceImpl implements TianJinMeterReadingService {
    @Autowired
    WaterMeterMapper  waterMeterMapper ;

    @Autowired
    CustomerMapper  customerMapper ;

    @Value("${province.code}")
    Integer provinceCode ;

    @Value("${city.code}")
    Integer cityCode ;

    @Value("${region.code}")
    Integer regionCode ;

    @Value("${customer.code}")
    Integer customerCode ;

    @Value("${device.type.code}")
    Integer deviceTypeCode ;


    @Autowired
    MeterReadRecordRepository  meterReadRecordRepository ;

    @Autowired
    CommunityService  communityService ;

    @Autowired
    BuildingService  buildingService ;

    @Autowired
    WaterMeterService  waterMeterService ;

    @Autowired
    MongoTemplate mongoTemplate ; 


    @Override
    public RespData registImei(RegistIMEIRequest request) {
        RespData respData = new RespData() ;
        try {
            // 1,保存小区信息
            String smallZone = request.getSmallZone();
            Community community = saveCommunity(smallZone);
            // 2,保存建筑信息
            Building building = saveBuilding(smallZone, community);
            // 3,保存设备
            WaterMeter waterMeter = new WaterMeter();
            waterMeter.setBuildingId(building.getId());
            waterMeter.setDeviceNo(request.getImei());
            waterMeter.setMeterNo(request.getRegistNo());
            waterMeter.setMeterFileNo(request.getCustomerNo());
            waterMeter.setLocation(request.getLocation());
            waterMeter.setDeviceTypeId(deviceTypeCode);
            waterMeter.setSiteId(community.getSiteId());
            waterMeter.setCustomerId(community.getCustomerId());
            waterMeter.setProvince(community.getProvince());
            waterMeter.setCity(community.getCity());
            waterMeter.setRegion(community.getRegion());
            waterMeter.setCommunity(community.getId());
            waterMeter.setCreateBy("system");
            saveWaterMeter(waterMeter) ;
            respData.setRtnId(RespData.SUCCESS);
            respData.setMsg(ErrorConstants.SUCCESS_REGIST);
        }catch (Exception e){
            e.printStackTrace();
            log.error("设备注册失败",e);
            respData.setRtnId(RespData.FAIL);
            if(e instanceof ServiceException){
                respData.setMsg(e.getMessage());
            }
            else{
                respData.setMsg(ResultStatus.SERVICE_ERROR.getMessage());
            }
        }
        return respData;
    }

    protected Community saveCommunity(String smallZone){
        Community param = new Community();
        param.setName(smallZone);
        param.setSiteId(1);
        param.setCustomerId(customerCode);
        param.setProvince(provinceCode);
        param.setCity(cityCode);
        param.setRegion(regionCode);
        return communityService.saveCommunity(param);
    }

    protected Building saveBuilding(String smallZone,Community community){
        Building param = new Building() ;
        param.setName(smallZone);
        param.setCommunity(community.getId());
        param.setProvince(community.getProvince());
        param.setCity(community.getCity());
        param.setRegion(community.getRegion());
        param.setSiteId(community.getSiteId());
        return buildingService.saveBuilding(param);
    }

    protected  WaterMeter saveWaterMeter(WaterMeter waterMeter){
        return waterMeterService.saveWaterWaterMeter(waterMeter) ;
    }
    @Override
    public RespData queryReadRecordData(String[] imeiArray,Integer readDay){
        if(readDay == null){
            // 默认查询今天的
            readDay = Integer.parseInt(DateUtil.format(DateUtil.date(),
                    Constants.DEFAULT_METER_READ_DATE_FORMAT));
        }
        RespData  respData = new RespData();
        List<String> deviceNoList = Arrays.asList(imeiArray);
        List<Integer> customerIds = findCustomerIdsWithChildren(customerCode);
        List<WaterMeter> waterMeterList = waterMeterService.findWaterMeterListWithChildrenCustomer(deviceNoList,
                customerCode);
        Criteria criteria = Criteria.where("readDate").is(readDay)
                .and("status").is(1)
                .and("readStatus").is("2")
                .and("deviceNo").in(deviceNoList);
        Query query = new Query();
        query.addCriteria(criteria);
        List<MeterReadRecord> meterReadRecords = mongoTemplate.find(query, MeterReadRecord.class);
        List<RtnData>  rtnDataList = new ArrayList<>();
        Map<String, WaterMeter> waterMeterMap =  transformWaterMeterList(waterMeterList);
        Map<String, MeterReadRecord> meterReadRecordMap = transformMeterReadRecordList(meterReadRecords);

        for(String imei : imeiArray){
            RtnData rtnData = new RtnData();
            rtnData.setECUID(imei);
            // 获取水表信息
            WaterMeter waterMeter = waterMeterMap.get(imei);
            if(waterMeter != null){
                MeterReadRecord meterReadRecord = meterReadRecordMap.get(imei);
                rtnData.setECURegDate(DateUtil.format(waterMeter.getDateCreate(), "yyyy-MM-dd HH:mm:ss"));
                if(meterReadRecord != null){
                    buildRtnData(meterReadRecord,rtnData);
                }
                else {
                    rtnData.setECUState(RtnData.STATE_NO_DATA);
                    rtnData.setMessage(ErrorConstants.NO_DATA_ERROR);
                }
            }
            else{
                rtnData.setECUState(RtnData.STATE_NO_DEVICE);
                rtnData.setMessage(ErrorConstants.NO_DEVICE_ERROR);
            }
            rtnDataList.add(rtnData);
        }
        respData.setRtnId(RespData.SUCCESS);
        respData.setRtnData(rtnDataList);

        return respData;
    }

    protected void buildRtnData(MeterReadRecord meterReadRecord,RtnData rtnData){
        // 获取如下信息：基站ID-->cellID,电池电量,信号强度-->CSQ,阀门状态,水表状态,水表状态信息
        Map<String, String> lastSendData = meterReadRecord.getLastSendData();

        String valveState = lastSendData.get("valveState");
        rtnData.setValve(valveState);

        String batteryQuantity = lastSendData.get("batteryQuantity");
        rtnData.setBatteryVotage(batteryQuantity);

        String cellId = lastSendData.get("cellId");
        rtnData.setBaseStationID(cellId);

        String rspr = lastSendData.get("RSPR");
        rtnData.setSignalIntensity(rspr);

        List<String> stateList = processWaterMeterState(lastSendData);
        String state = stateList.get(0);
        rtnData.setECUState(state);

        if(!RtnData.STATE_NORMAL.equals(state)){
            String warnMessage = stateList.get(1);
            rtnData.setMessage(warnMessage);
        }

        // 获取抄表时间,格式：yyyy-MM-dd
        Date readTime = meterReadRecord.getReadTime();
        rtnData.setRXDDate(DateUtil.format(readTime, "yyyy-MM-dd HH:mm:ss"));
        // 表盘读数,原数据
        rtnData.setRXDReading(meterReadRecord.getReadData());
        // 抄表止度，向下取整
        rtnData.setReading(String.valueOf(
                ((Double)Math.floor(
                        Double.parseDouble(meterReadRecord.getReadData()))).intValue()));
        rtnData.setMessage("正常");
    }
    /**
     * 返回数据格式第一位为是否告警,0：正常，1：有告警
     * 第二位告警信息,多个告警信息拼接一起
     * @param data
     * @return
     */
    protected  List<String> processWaterMeterState(Map<String, String> data){
        List<String> result = new ArrayList<>();
        // 以下报警信息均,0:正常,1:报警
        String meterState = "0";
        StringBuffer waringMessage =  new StringBuffer();
        // 低电告警
        String lowVoltageWarning = data.get("lowVoltageWarning");
        if(RtnData.ALARM_STATE_ERROR.equals(lowVoltageWarning)){
            waringMessage.append("低电告警,");
            meterState = "1";
        }
        // 磁干扰告警
        String magneticInterWarning = data.get("magneticInterWarning");
        if(RtnData.ALARM_STATE_ERROR.equals(magneticInterWarning)){
            waringMessage.append("磁干扰告警,");
            meterState = "1";
        }
        // 电子模块分离告警
        String eleModuleWarning = data.get("eleModuleWarning");
        if(RtnData.ALARM_STATE_ERROR.equals(eleModuleWarning)){
            waringMessage.append("电子模块分离告警,");
            meterState = "1";
        }
        // 过流告警
        String overCurrentWarning = data.get("overCurrentWarning");
        if(RtnData.ALARM_STATE_ERROR.equals(overCurrentWarning)){
            waringMessage.append("过流告警,");
            meterState = "1";
        }
        // 反流告警
        String refluxWarningQuantity = data.get("refluxWarningQuantity");
        if(RtnData.ALARM_STATE_ERROR.equals(refluxWarningQuantity)){
            waringMessage.append("反流告警,");
            meterState = "1";
        }
        // 阀门异常告警
        String valveWaring = data.get("valveWaring");
        if(RtnData.ALARM_STATE_ERROR.equals(valveWaring)){
            waringMessage.append("阀门异常告警,");
            meterState = "1";
        }
        result.add(meterState);
        String waringString = waringMessage.toString();
        if(StringUtils.isNotBlank(waringString)){
            result.add(waringString.substring(0,waringString.length()-1));
        }
        return result ;
    }
    protected Map<String, WaterMeter> transformWaterMeterList(List<WaterMeter> waterMeterList){
        Map<String , WaterMeter> waterMeterMap = new HashMap<>(waterMeterList.size());
        for(WaterMeter waterMeter : waterMeterList ){
            waterMeterMap.put(waterMeter.getDeviceNo(), waterMeter);
        }
        return waterMeterMap ;
    }

    protected Map<String, MeterReadRecord> transformMeterReadRecordList(List<MeterReadRecord> meterReadRecordList){
        Map<String , MeterReadRecord> meterReadRecordMap = new HashMap<>(meterReadRecordList.size());
        for(MeterReadRecord meterReadRecord : meterReadRecordList){
            meterReadRecordMap.put(meterReadRecord.getDeviceNo(),meterReadRecord);
        }
        return meterReadRecordMap;
    }
    @Override
    public RespData queryImei(String imei) {
        RespData respData = new RespData();
        List<Integer> customerIds = findCustomerIdsWithChildren(customerCode);
        WaterMeter waterMeter = waterMeterMapper.findWaterMeterByDeviceNoAndCustomerList(imei,customerIds);
        if(waterMeter == null){
            // 设备未注册
            respData.setRtnId(RespData.SUCCESS);
            respData.setMsg(RespData.UN_REGIST);
        }
        else{
            respData.setRtnId(RespData.FAIL);
            respData.setMsg(RespData.REGISTED);
        }
        return respData;
    }

    /**
     * 查询公司及其分公司的ID
     * @param customerCode
     * @return
     */
    protected  List<Integer> findCustomerIdsWithChildren(Integer customerCode){
        List<Integer> customerIds = new ArrayList<>();
        customerIds.add(customerCode);
        List<Customer> customers = customerMapper.selectByParentId(customerCode);
        customers.forEach(customer -> {
            customerIds.add(customer.getId());
        });
        return customerIds ;
    }
}