密码验证加-

whyclxw

2025-05-28 e16302f9d475c7cc4dd18c5abf1a23cb5502e362

 src/main/java/com/whyc/service/Fbs9100StateService.java

@@ -6,11 +6,18 @@
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.constant.DeviceConstant;
import com.whyc.constant.YamlProperties;
import com.whyc.dto.BattTestData;
import com.whyc.dto.Response;
import com.whyc.dto.paramter.FbsStatePar;
import com.whyc.dto.result.DischargeState;
import com.whyc.mapper.BattInfMapper;
import com.whyc.mapper.BattRtstateMapper;
import com.whyc.mapper.Fbs9100StateMapper;
import com.whyc.pojo.Battinf;
import com.whyc.pojo.Fbs9100State;
import com.whyc.util.ActionUtil;
import com.whyc.util.DateUtil;
import com.whyc.util.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -18,6 +25,7 @@
import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class Fbs9100StateService {
@@ -25,6 +33,18 @@
    private Fbs9100StateMapper mapper;
    @Autowired
    private Fbs9100SetparamService service;

    @Autowired(required = false)
    private BattInfMapper binfMapper;

    @Autowired(required = false)
    private BattRtstateMapper rtstateMapper;
    @Autowired(required = false)

    private Fbs9600StateService fbs9600StateService;
    @Autowired(required = false)

    private Ld9StateService ld9StateService;

    //开关状态
    @Transactional
@@ -35,9 +55,12 @@
        Fbs9100State fbs9100State = mapper.selectOne(wrapper);
        if (fbs9100State != null) {
            fbs9100State.setNote(new SimpleDateFormat(ActionUtil.time_yyyyMMddHHmmss).format(new Date()));
            if((devId / 100000 == 6183)||(devId / 100000 == 6184)){
                fbs9100State.setDevLastCaptestStopTypeReason(BattTestData.getStopType_6183_4(fbs9100State.getDevLastCaptestStopType()));
            }else{
                fbs9100State.setDevLastCaptestStopTypeReason(BattTestData.getStopType_9612(fbs9100State.getDevLastCaptestStopType()));
            }
        }
        /*Random random = new Random();
        fbs9100State.setFbo4830IsOnline(random.nextInt(2));*/
        return new Response().setII(1, fbs9100State == null ? false : true, fbs9100State, "");
    }

@@ -58,7 +81,7 @@
        UpdateWrapper wrapper=new UpdateWrapper();
        wrapper.set("dev_res_test_state",0);
        wrapper.eq("dev_id",devId);
        int flag=mapper.update(null,wrapper);
        int flag=mapper.update((Fbs9100State) ActionUtil.objeNull,wrapper);
        return  new Response().set(1,flag>0?true:false);
    }
    //一体机界面弹出框确认操作
@@ -72,7 +95,7 @@
            dev_alarmstat=2;
            wrapper.set("dev_alarmstate",dev_alarmstat);
            wrapper.eq("dev_id",devId);
            flag=mapper.update(null,wrapper);
            flag=mapper.update((Fbs9100State) ActionUtil.objeNull,wrapper);
            if(flag>0){
                boolean b=service.sendCmdToFBS9100Dev(35,0, devId);
                if(b){
@@ -90,7 +113,7 @@
            dev_alarmstat=3;
            wrapper.set("dev_alarmstate",dev_alarmstat);
            wrapper.eq("dev_id",devId);
            flag=mapper.update(null,wrapper);
            flag=mapper.update((Fbs9100State) ActionUtil.objeNull,wrapper);
            if(flag>0){
                bl=true;
                msg="修改成功!";
@@ -121,6 +144,12 @@
        return list;
    }

    /**
     * 这个是按照设备id来统计的,一拖二的设备有两个设备id,被看作两个设备,弃用
     * @param userId
     * @return
     */
    @Deprecated
    public Response getBTSEquipStatus(int userId){

        Response response = new Response();
@@ -156,10 +185,123 @@
            response.setCode(0);
            return response;
        }*/
            QueryWrapper<Fbs9100State> wrapper = Wrappers.query();
            /*QueryWrapper<Fbs9100State> wrapper = Wrappers.query();
            wrapper.select("record_datetime", "dev_workstate");
            List<Fbs9100State> fbs9100StateList = mapper.selectList(wrapper);
            List<Fbs9100State> fbs9100StateList = mapper.selectList(wrapper);*/
            List<Fbs9100State> fbs9100StateList = mapper.getListWithoutZJDYBTSE2(userId, 1);
            //首先查看是否通讯故障,时间大于1分钟为通讯故障
            for (int i = 0; i < fbs9100StateList.size(); i++) {
                Calendar instance = Calendar.getInstance();
                instance.add(Calendar.MINUTE, -1);
                Date time = instance.getTime();
                //if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(fbs9100StateList.get(i).getRecordDatetime())) > 0) {
                if (time.compareTo(ThreadLocalUtil.parse(fbs9100StateList.get(i).getRecordDatetime(),1)) > 0) {
                    resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                } else {
                    switch (fbs9100StateList.get(i).getDevWorkstate()) {
                        case DeviceConstant.DEV_ONLINE_CHARGE:
                            resultMap.put("在线浮充数量", resultMap.get("在线浮充数量") + 1);
                            break;
                        case DeviceConstant.DEV_PRE_CHARGE:
                            resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                            break;
                        case DeviceConstant.DEV_NUCLEAR_CAP:
                            resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                            break;
                        case DeviceConstant.DEV_RES_TEST:
                            resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                            break;
                    }
                }
            }

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    /**
     * 这个是按照设备ip来统计的.
     * 通讯故障>核容放电>充电>内阻>浮充,
     * 如果一拖二的设备,有两个不同状态,实现状态优先级覆盖
     *
     * 设备的数量统计和设备状态的统计,逻辑是不同的,数据库筛选的时候条件逻辑必定是不同的: TODO
     *  通常情况下,设备数量统计,要排除掉一个设备两个id的一拖二情况;
     *  而设备状态统计,只需要区分一个设备的字段,一个设备有多条记录也是正常合理的,通过状态优先级覆盖来定义整个设备的状态
     *
     * @param userId
     * @param type 1-太原排除蓄电池设备一拖二的第二组状态统计
     * @param type 2-统计所有设备ip的状态
     * @return
     */
    public Response getBTSEquipStatus2(int userId,int type){

        Response response = new Response();
        try {
            Map<String, Integer> resultMap = new HashMap<>();
            resultMap.put("直连充电数量", 0);
            resultMap.put("预充电数量", 0);
            resultMap.put("核容测试数量", 0);
            resultMap.put("内阻测试数量", 0);
            resultMap.put("通讯故障数量", 0);

            List<Fbs9100State> fbs9100StateList = mapper.getListWithoutZJDYBTSE2(userId,type);
            //上面的分组字段 只要能区分 不同的设备就行了. 因为如果是一拖二的情况,也可通过后面的状态优先级来覆盖,设备不会重复
            //太供可以通过ip来确定是哪台设备
            Map<String, List<Fbs9100State>> deviceMap = null;
            if(YamlProperties.systemSubType == 3){ //晋源 - 因为所有设备共用一个ip, 所以需要加上devId
                deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(state ->  String.format("%s_%s",state.getDevIp(), state.getDevId())));
            }else{ //默认通用
                deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(state -> String.valueOf(state.getDevIp())));
            }
            //Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(state ->
            //        String.format("%s_%s",state.getDevIp(), state.getDevId())));
            Set<String> deviceSet = deviceMap.keySet();
            Calendar instance = Calendar.getInstance();
            instance.add(Calendar.MINUTE, -1);
            Date time = instance.getTime();
            //这个遍历里面,是按照groupingBy(字段)来进行分组的,可以存在一个设备多个记录,即出现一拖二的情况. 这个时候按照优先级进行覆盖来定义整个设备的状态
            //上面的分组字段 只要能区分 不同的设备就行了. 因为如果是一拖二的情况,也可通过状态优先级来覆盖
            for (String deviceIp : deviceSet) {
                List<Fbs9100State> fbs9100States = deviceMap.get(deviceIp);
                //存在6186设备,这个设备的设备状态值采用的是devAlarmState,所以需要单独处理
                List<Integer> workStateList;
                if(fbs9100States.get(0).getDevId().toString().startsWith("6186")){
                    workStateList = fbs9100States.stream().map(Fbs9100State::getDevAlarmstate).collect(Collectors.toList());
                }else {
                    workStateList = fbs9100States.stream().map(Fbs9100State::getDevWorkstate).collect(Collectors.toList());
                }
                Map<Integer, List<Integer>> workStateMap = workStateList.stream().collect(Collectors.groupingBy(Integer::intValue));
                Set<Integer> workStateSet = workStateMap.keySet();
                boolean commError = false;
                for (Fbs9100State state : fbs9100States) {
                    //if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(state.getRecordDatetime())) > 0) {
                    if (time.compareTo(ThreadLocalUtil.parse(state.getRecordDatetime(),1)) > 0) {
                        resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                        commError = true;
                        break;
                    }
                }
                //不存在通讯故障,则需要再判断优先级覆盖
                if(!commError){
                    if(workStateSet.contains(DeviceConstant.DEV_NUCLEAR_CAP)) {
                        resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_PRE_CHARGE)) {
                        resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_RES_TEST)) {
                        resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_ONLINE_CHARGE)) {
                        resultMap.put("直连充电数量", resultMap.get("直连充电数量") + 1);
                    }

                }

            }
            /*//首先查看是否通讯故障,时间大于1分钟为通讯故障
            for (int i = 0; i < fbs9100StateList.size(); i++) {
                Calendar instance = Calendar.getInstance();
                instance.add(Calendar.MINUTE, -1);
@@ -175,20 +317,111 @@
                            resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                            break;
                        case DeviceConstant.DEV_NUCLEAR_CAP:
                            resultMap.put("核容数量", resultMap.get("核容测试数量") + 1);
                            resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                            break;
                        case DeviceConstant.DEV_RES_TEST:
                            resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                            break;
                    }
                }
            }
            }*/

            return response.setII(1, true, resultMap, null);
            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }

    //山西晋源特定接口
    public Response getBTSEquipStatus2JY(int type){

        Response response = new Response();
        try {
            Map<String, Integer> resultMap = new HashMap<>();
            resultMap.put("直连充电数量", 0);
            resultMap.put("预充电数量", 0);
            resultMap.put("核容测试数量", 0);
            resultMap.put("内阻测试数量", 0);
            resultMap.put("通讯故障数量", 0);

            List<Fbs9100State> fbs9100StateList = mapper.getListWithoutZJDYBTSE2JY(type);

            //Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(Fbs9100State::getDevIp));
            //JY的设备,ip都一样,所以区分不同的设备,需要通过ip+id
            Map<String, List<Fbs9100State>> deviceMap = fbs9100StateList.stream().collect(Collectors.groupingBy(state ->String.format("%s_%s",state.getDevIp(), state.getDevId())));
            Set<String> deviceSet = deviceMap.keySet();
            Calendar instance = Calendar.getInstance();
            instance.add(Calendar.MINUTE, -1);
            Date time = instance.getTime();
            for (String deviceIp : deviceSet) {
                List<Fbs9100State> fbs9100States = deviceMap.get(deviceIp);
                //存在6186设备,这个设备的设备状态值采用的是devAlarmState,所以需要单独处理
                List<Integer> workStateList;
                if(fbs9100States.get(0).getDevId().toString().startsWith("6186")){
                    workStateList = fbs9100States.stream().map(Fbs9100State::getDevAlarmstate).collect(Collectors.toList());
                }else {
                    workStateList = fbs9100States.stream().map(Fbs9100State::getDevWorkstate).collect(Collectors.toList());
                }
                Map<Integer, List<Integer>> workStateMap = workStateList.stream().collect(Collectors.groupingBy(Integer::intValue));
                Set<Integer> workStateSet = workStateMap.keySet();
                boolean commError = false;
                for (Fbs9100State state : fbs9100States) {
                    //if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(state.getRecordDatetime())) > 0) {
                    if (time.compareTo(ThreadLocalUtil.parse(state.getRecordDatetime(),1)) > 0) {
                        resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                        commError = true;
                        break;
                    }
                }
                //不存在通讯故障,则需要再判断优先级覆盖
                if(!commError){
                    if(workStateSet.contains(DeviceConstant.DEV_NUCLEAR_CAP)) {
                        resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_PRE_CHARGE)) {
                        resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_RES_TEST)) {
                        resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                    }
                    else if(workStateSet.contains(DeviceConstant.DEV_ONLINE_CHARGE)) {
                        resultMap.put("直连充电数量", resultMap.get("直连充电数量") + 1);
                    }

                }

            }
            /*//首先查看是否通讯故障,时间大于1分钟为通讯故障
            for (int i = 0; i < fbs9100StateList.size(); i++) {
                Calendar instance = Calendar.getInstance();
                instance.add(Calendar.MINUTE, -1);
                Date time = instance.getTime();
                if (time.compareTo(DateUtil.YYYY_MM_DD_HH_MM_SS.parse(fbs9100StateList.get(i).getRecordDatetime())) > 0) {
                    resultMap.put("通讯故障数量", resultMap.get("通讯故障数量") + 1);
                } else {
                    switch (fbs9100StateList.get(i).getDevWorkstate()) {
                        case DeviceConstant.DEV_ONLINE_CHARGE:
                            resultMap.put("在线浮充数量", resultMap.get("在线浮充数量") + 1);
                            break;
                        case DeviceConstant.DEV_PRE_CHARGE:
                            resultMap.put("预充电数量", resultMap.get("预充电数量") + 1);
                            break;
                        case DeviceConstant.DEV_NUCLEAR_CAP:
                            resultMap.put("核容测试数量", resultMap.get("核容测试数量") + 1);
                            break;
                        case DeviceConstant.DEV_RES_TEST:
                            resultMap.put("内阻测试数量", resultMap.get("内阻测试数量") + 1);
                            break;
                    }
                }
            }*/

            return response.setII(1, true, resultMap, "");
        } catch (Exception e) {
            return response.set(1, false, "发生异常:" + e.getCause());
        }
    }


    public List<Fbs9100State> getStateList(int userId) {
        List<Fbs9100State> list = mapper.getStateList(userId);
@@ -196,14 +429,85 @@
    }

    //首页上点击停电站
    public List<Fbs9100State> searchPowerOff(String uId) {
        List<Fbs9100State> list = mapper.searchPowerOff(uId);
    public List<Battinf> searchPowerOff(String uId) {
        List<Battinf> list = mapper.searchPowerOff(uId);
        return list;
    }

    //首页上点击核容放电站
    public List<Fbs9100State> searchCheckCapDischarge(String uId) {
        List<Fbs9100State> list = mapper.searchCheckCapDischarge(uId);
    public List<Battinf> searchCheckCapDischarge(String uId) {
        List<Battinf> list = mapper.searchCheckCapDischarge(uId);
        return list;
    }

    //今日放电站点统计
    public Response getChargeStaticToday(int userId) {
        try {
            Map<String, Object> map = new HashMap<>();
            List<DischargeState> list = mapper.getChargeStaticToday(userId);
            Map<String, Object> stateMap = new HashMap<>();
            Map<String, Object> stateNumMap = new HashMap<>();
            stateNumMap.put("state2", 0);
            stateNumMap.put("state3", 0);
            stateMap.put("state2", new ArrayList<>());
            stateMap.put("state3", new ArrayList<>());
            Map<Integer, List<DischargeState>> stateDisMap = list.stream().collect(Collectors.groupingBy(DischargeState::getDevWorkstate));
            for (Integer workState : stateDisMap.keySet()) {
                if (workState == 2 || workState == 3) {
                    stateNumMap.put("state" + workState, stateDisMap.get(workState).size());
                    List<DischargeState> worklist = stateDisMap.get(workState);
                    stateMap.put("state" + workState, worklist);
                }
            }
            map.put("stateNumMap", stateNumMap);
            map.put("stateMap", stateMap);
            //map.put("nowTime", ActionUtil.sdf.format(new Date()));
            map.put("nowTime", ThreadLocalUtil.format(new Date(),1));
            return new Response().setII(1, true, map, "今日放电站点统计");
        } catch (Exception e) {
            return new Response().set(1, false, "出现异常" + e.getMessage());
        }
    }

    //实时停电放电
    public int getJcAnalysis(int userId) {
        int jcdisNum = mapper.getJcAnalysis(userId);
        return jcdisNum;
    }

    public Response getFbsState(FbsStatePar fbsStatePar) {
        Map<String, Response> res=new HashMap<>();
        //查询fbs9100信息
        Response f9100stateRes = searchByCondition(fbsStatePar.getPageNum(),fbsStatePar.getPageSize(),fbsStatePar.getDevErrcommcount(),fbsStatePar.getUserId());
        res.put("f9100state",f9100stateRes);

        Response f9600StateRes = fbs9600StateService.searchByCondition(fbsStatePar.getPageNum(),fbsStatePar.getPageSize(),fbsStatePar.getDevErrcommcount(),fbsStatePar.getUserId());
        res.put("f9600state",f9600StateRes);

        Response ld9stateRes = ld9StateService.searchByCondition(fbsStatePar.getPageNum(),fbsStatePar.getPageSize(),fbsStatePar.getDevErrcommcount(),fbsStatePar.getUserId());
        res.put("ld9state",ld9stateRes);
        return new Response().set(1, res);
    }

    public void addOrUpdate(List<Fbs9100State> deviceStateList) {
        List<Long> devIdList = deviceStateList.stream().map(Fbs9100State::getDevId).collect(Collectors.toList());
        QueryWrapper<Fbs9100State> query = Wrappers.query();
        query.in("dev_id",devIdList);
        List<Fbs9100State> fbs9100StateListInDB = mapper.selectList(query);
        List<Long> devIdListInDB = fbs9100StateListInDB.stream().map(Fbs9100State::getDevId).collect(Collectors.toList());

        for (Fbs9100State fbs9100State : deviceStateList) {
            if(devIdListInDB.contains(fbs9100State.getDevId())){ //更新
                UpdateWrapper<Fbs9100State> update = Wrappers.update();
                update.set("dev_workstate",fbs9100State.getDevWorkstate())
                        .set("dev_last_captest_stop_type",fbs9100State.getDevLastCaptestStopType())
                        .set("record_datetime",fbs9100State.getRecordDatetime())
                        .eq("dev_id",fbs9100State.getDevId());
                mapper.update(null,update);
            }else{ //新增
                mapper.insert(fbs9100State);
            }
        }

    }
}