关注电池接口，和最后一笔测试数据接口添加

whyczh

2021-12-17 2f2ed247e2f4ee6dafa7371eed62bb2ce89b0b7c

关注电池接口，和最后一笔测试数据接口添加

 src/main/java/com/whyc/controller/BattAttentionController.java

@@ -1,16 +1,39 @@
package com.whyc.controller;

import com.whyc.dto.Response;
import com.whyc.pojo.BattAttention;
import com.whyc.pojo.Battinf;
import com.whyc.pojo.UserInf;
import com.whyc.service.BattAttentionService;
import com.whyc.util.ActionUtil;
import io.swagger.annotations.Api;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

@RestController
@RequestMapping("battAttention")
@Api(tags = "数据管理-电池关注管理")
public class BattAttentionController {

    @Resource
    private BattAttentionService service;

    @PostMapping("/searByCondition")
    @ApiOperation(value = "根据电池组的筛选条件,查询单体的实际电压")
    public Response searByCondition(@RequestBody Battinf battinf){
        UserInf userInf = ActionUtil.getUser();
        return service.searchByCondition(battinf,userInf.getUId().intValue());
    }



    @PostMapping("/delete")
    @ApiOperation(value = "取消关注")
    public Response delete(@RequestBody BattAttention battAttention){
        UserInf userInf = ActionUtil.getUser();
        battAttention.setUid(userInf.getUId().intValue());
        return service.deleteByEntity(battAttention);
    }

}

 src/main/java/com/whyc/dto/BattCapFactory.java

New file
@@ -0,0 +1,162 @@
package com.whyc.dto;

public class BattCapFactory {
    public static int  CapType_Rest = 0;            //当查询剩余容量时传递
    public static int  CapType_Real = 1;            //当查询实际容量时传递
	
    public static int  CapType_type=2;       //容量
    public static int  CapType_name=1;       //次低
    public static int  CapType_method=0;     //标称
    // 获取标纯电流
    public static double GetFDCurrent(double stdcap, int hourrate)
    {
        double res = 0.055;
        switch(hourrate)
        {
            case 1: res = 0.514; break;
            case 2: res = 0.306; break;
            case 3: res = 0.250; break;
            case 4: res = 0.200; break;
            case 5: res = 0.166; break;
            case 6: res = 0.146; break;
            case 7: res = 0.131; break;
            case 8: res = 0.118; break;
            case 9: res = 0.108; break;
            case 10: res = 0.100; break;
            case 20: res = 0.055; break;
            default: res = 0.055; break;
        }
	    
        return (stdcap * res);
    }
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    // 获取放电小时率        stdah：标纯容量          current:当前电流
    public static int GetHourRate(double stdah, double current)
    {
        int index = 0;
        double value[]={5.14, 3.06, 2.50, 2.00, 1.66, 1.46, 1.31, 1.18, 1.08, 1.00, 0.55, 0.40};
        double res;
        current = Math.abs(current);
        res = current/(stdah/10);
        if(res >= 5.14) return 1;
        else if(res <= 0.55) return 20;
        else
        {
            for(index=0; index<10; index++)
            {
                if((res<=value[index]) && (res>value[index+1]))
                    break;
                else continue;
            }
            if((value[index]-res) < (res-value[index+1]))
            {
                return (index+1);
            }
            else
            {
                if(index+2 > 10) return (20);
                else return (index+2);
            }
        }  
    }
    //------------------------------------------------------------------------------
    //------------------------------------------------------------------------------
    public static double N_TO_10H(int n_H)
    {
        switch(n_H)
        {
            case  1 : return(1/0.55);
            case  2 : return(1/0.61);
            case  3 : return(1/0.75);
            case  4 : return(1/0.79);
            case  5 : return(1/0.833);
            case  6 : return(1/0.876);
            case  7 : return(1/0.917);
            case  8 : return(1/0.944);
            case  9 : return(1/0.974);
            case  10: return(1/1);
            case  20: return(1/1.1);
        }
        return 1.0;
    }
    //-------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------
    //获取剩余容量    STDAH：标称容量        HourRate：放电小时率    SumAH：测试容量        MaxMonomerVol：最大电池电压        MonomerVol：当前电池组的最低单体电压
    //MonomerVolType:电池电压类型 电池标称电压    2v,6v,12v    CapType:容量类型（定值是常量）
	
                                                         //小时率        已测试容量            最容量
    public static double GetMonomerCap(double STDAH, int HourRate, double SumAH, double MaxMonomerVol,
																
                                        double MonomerVol, double MonomerVolType, int CapType)
    {
        if((MaxMonomerVol - MonomerVolType*0.9) <= 0)
            return 0;

        if(SumAH < 0)
            SumAH *= (-1);

        double tmp_cap;
        tmp_cap = MonomerVol - MonomerVolType * 0.9;
        tmp_cap *= (STDAH - SumAH * N_TO_10H(HourRate));
        double dt_vol = MaxMonomerVol - MonomerVolType*0.9;
        if(dt_vol < 0.01)
            dt_vol = 0.01;
        tmp_cap = tmp_cap/dt_vol;
        if(tmp_cap < 0)
            tmp_cap = 0;

        if(CapType == CapType_Rest)
            return tmp_cap;
        else if(CapType == CapType_Real)
            return (tmp_cap + SumAH * N_TO_10H(HourRate));
        else
            return ((tmp_cap + SumAH * N_TO_10H(HourRate))*100 / STDAH);
    }
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    //获取后备时间
    public static int GetRestTimeSecond(double restcap, double curr)
    {
        double tmp_curr = Math.abs(curr);
        if(tmp_curr < 0.1)
            tmp_curr = 0.1;
			
        int rest_time = (int)((restcap / tmp_curr) * 3600);
        if(rest_time > (99*3600))
            rest_time = (99*3600);
			
        return rest_time;
    }
    //判断通过实际容量判断某次放电测试是否有效
    /*
     * STDAH:标存容量
     * param:容量有效参数*/
    public static  int Judge(double realCap,float param,double STDAH){
        int flag=0;
        if(Math.abs(realCap)>(param*STDAH)){
            flag=1;
        }else{
            flag=0;
        }
        return flag;
        }
    //判断通过实际容量判断某次放电测试是否有效
        /*
         * STDAH:标存容量
         * param:容量告警参数*/
    public static  int JudgeAlarm(double realCap,float param,float Cparam,double STDAH){
        int flag=0;
        if(realCap>(param*STDAH)){
            flag=1;
        }else{
            if(realCap<(Cparam*STDAH)){
                flag=AlarmDaoFactory.Alarm_CapChange;
            }else{
                flag=AlarmDaoFactory.Alarm_CapAlarm;
            }
			
        }
        return flag;
 }
}

 src/main/java/com/whyc/mapper/BattAttentionMapper.java

@@ -2,11 +2,12 @@

import com.whyc.pojo.BattAttention;
import com.whyc.pojo.Battinf;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BattAttentionMapper extends CustomMapper<BattAttention>{

    List<Battinf> getBattInfByGroup();
    List<Battinf> getBattInfByGroup(@Param("binf") Battinf battinf, @Param("userId") int userId);

}

 src/main/java/com/whyc/mapper/BattTestDataStopMapper.java

New file
@@ -0,0 +1,12 @@
package com.whyc.mapper;

import com.whyc.pojo.BattTestDataStop;

import java.util.List;

public interface BattTestDataStopMapper extends CustomMapper<BattTestDataStop> {

    BattTestDataStop findByMonNum(Integer battGroupId,Integer monNum);

    Float getRealCap(BattTestDataStop stop);
}

 src/main/java/com/whyc/pojo/BattTestDataStop.java

New file
@@ -0,0 +1,47 @@
package com.whyc.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.ToString;

import java.util.Date;

@Data
@ApiModel("BattTestDataStop")
@ToString
@TableName(schema = "db_batt_testdata",value = "tb_batttestdatastop")
public class BattTestDataStop {
    @TableId(type = IdType.AUTO)
    private Integer num;
    @TableField("BattGroupId")
    private Integer battGroupId;
    private Integer testRecordCount;
    private Integer testType;
    private Integer dataNew;
    private Integer dataAvailable;
    private Integer recordNum;
    private Date testStarttime;
    private Date recordTime;
    private Integer testTimelong;
    private Float onlineVol;
    private Float groupVol;
    private Float testCurr;
    private Float testCap;
    private Integer monNum;
    private Float monVol;

    @TableField(exist = false)
    private Float lowC;
    @TableField(exist = false)
    private Float lowV;
    @TableField(exist = false)
    private Float mon_avg;
    @TableField(exist = false)
    private Float mon_min;
    @TableField(exist = false)
    private Float mon_max;
}

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

@@ -1,16 +1,78 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.api.R;
import com.whyc.dto.BattCapFactory;
import com.whyc.dto.BattTestData;
import com.whyc.dto.Response;
import com.whyc.mapper.BattAttentionMapper;
import com.whyc.mapper.BattInfMapper;
import com.whyc.mapper.BattTestDataStopMapper;
import com.whyc.pojo.BattAttention;
import com.whyc.pojo.BattTestDataStop;
import com.whyc.pojo.Battinf;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class BattAttentionService {

    @Resource
    private BattAttentionMapper mapper;
    @Resource
    private BattTestDataStopMapper stopMapper;


    public Response searchByCondition(Battinf battinf,int userId){
        List<Battinf> list = mapper.getBattInfByGroup(battinf,userId);
        for (int i = 0; i < list.size(); i++) {
            Battinf binf = list.get(i);
            //最近一笔的实际容量
            double realcap = getRealCapByMonNum(binf);
            binf.setMonSerStd((float) realcap);//实际容量
        }
        return new Response().set(1,list,"查询成功");
    }

    public double getRealCapByMonNum(Battinf binf){
        BattTestDataStop battTestDataStop = stopMapper.findByMonNum(binf.getBattGroupId(),binf.getMonNum());
        double realCap=0f;//实际容量
        double STDAH=0;//标存容量
        int hourRate=0;//小时率
        double current=0;//当前电流
        double SumAH=0;//测试容量
        double MaxMonomerVol=0;//最大电压
        double MonomerVol=0; //最小电压
        double MonomerVolType=0;//电池电压类型(标存电压)
        int flag=1;//电池单体告警标识
        STDAH=binf.getMonCapStd();
        MonomerVolType=binf.getMonVolStd();
        current=battTestDataStop.getTestCurr();
        SumAH=battTestDataStop.getTestCap();
        MaxMonomerVol=battTestDataStop.getGroupVol();
        MonomerVol=battTestDataStop.getMonVol();
        hourRate= BattCapFactory.GetHourRate(STDAH, current);
        if(battTestDataStop.getMonVol()>binf.getMonVolStd()* BattTestData.test_stop){
            realCap=BattCapFactory.GetMonomerCap(STDAH, hourRate, SumAH, MaxMonomerVol, MonomerVol, MonomerVolType, BattCapFactory.CapType_Real);
        }else{
            battTestDataStop.setMonVol(binf.getMonVolStd()*BattTestData.test_stop);
            realCap=stopMapper.getRealCap(battTestDataStop);
        }
        return realCap;
    }

    public Response deleteByEntity(BattAttention batt){
        QueryWrapper<BattAttention> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("battgroupid",batt.getBattGroupId());
        queryWrapper.eq("monnum",batt.getMonNum());
        queryWrapper.eq("uid",batt.getUid());
        mapper.delete(queryWrapper);
        return new Response().set(1,true,"删除成功");
    }

}

 src/main/resources/mapper/BattAttentionMapper.xml

@@ -12,8 +12,19 @@
        and web_site.tb_batt_attention.battgroupid=db_ram_db.tb_batt_rtdata.battgroupid
        and web_site.tb_batt_attention.monnum=db_ram_db.tb_batt_rtdata.mon_num
        and web_site.tb_batt_attention.uid=#{userId}
        <if test="station"></if>

        <if test="binf.stationname1!=null and binf.stationname1!='' ">
            and db_battinf.tb_battinf.stationname1 = #{binf.stationName1}
        </if>
        <if test="binf.stationname!=null and binf.stationname!='' ">
            and db_battinf.tb_battinf.stationname = #{binf.stationName}
        </if>
        <if test="binf.battGroupId!=null and binf.battGroupId!='' ">
            and db_battinf.tb_battinf.BattGroupId = #{binf.battGroupId}
        </if>
        <if test="binf.monNum!=null and binf.monNum!='' ">
            and web_site.tb_batt_attention.monnum = #{binf.monNum}
        </if>
        order by web_site.tb_batt_attention.battgroupid

    </select>
</mapper>

 src/main/resources/mapper/BattTestDataStopMapper.xml

New file
@@ -0,0 +1,21 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.whyc.mapper.BattTestDataStopMapper" >


    <select id="findByMonNum" resultType="com.whyc.pojo.BattTestDataStop">
        select stop.battgroupid,stop.test_curr,stop.test_cap,stop.mon_vol,stop.test_record_count,stop.mon_num,inf.max_monvol
        from db_batt_testdata.tb_batttestdatastop_${battGroupId} stop,db_batt_testdata.tb_batttestdata_inf inf
        where stop.battGroupId = inf.battGroupId and stop.test_starttime = inf.test_starttime and stop.mon_num = #{monNum}
        and stop.data_available=1 and inf.test_type=3
        order by stop.test_starttime desc limit 1
    </select>
    <select id="getRealCap" resultType="java.lang.Float">
        select test_cap from db_batt_testdata.tb_batttestdata_${stop.battGroupId}
        where test_record_count=?  and mon_vol>? and mon_num=? and data_available=1
        order by record_time desc limit 1

    </select>


</mapper>