zd-parents-v2/zd-modules/zd-airbottle/src/main/java/com/zd/airbottle/controller/DbStockController.java

package com.zd.airbottle.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zd.airbottle.domain.DbBeacon;
import com.zd.airbottle.domain.DbInOutRecord;
import com.zd.airbottle.domain.DbStock;
import com.zd.airbottle.domain.DbUsageRecord;
import com.zd.airbottle.domain.bo.DbStockBo;
import com.zd.airbottle.domain.bo.DbStockParam;
import com.zd.airbottle.domain.vo.DbInOutRecordVo;
import com.zd.airbottle.domain.vo.DbStockVo;
import com.zd.airbottle.service.DbBeaconService;
import com.zd.airbottle.service.DbInOutRecordService;
import com.zd.airbottle.service.DbStockService;
import com.zd.airbottle.service.DbUsageRecordService;
import com.zd.airbottle.utils.PageUtil;
import com.zd.common.core.annotation.Log;
import com.zd.common.core.annotation.PreAuthorize;
import com.zd.common.core.log.BusinessType;
import com.zd.common.core.redis.RedisService;
import com.zd.common.core.security.TokenService;
import com.zd.common.core.utils.StringUtils;
import com.zd.common.core.web.controller.AbstractController;
import com.zd.laboratory.api.dto.CheckSubjectDto;
import com.zd.laboratory.api.dto.WarningNoticeLogDto;
import com.zd.laboratory.api.feign.RemoteLaboratoryService;
import com.zd.model.constant.BaseConstants;
import com.zd.model.constant.HttpStatus;
import com.zd.model.domain.ResultData;
import com.zd.model.domain.per.PerFun;
import com.zd.model.domain.per.PerPrefix;
import com.zd.model.entity.SysUser;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.text.DecimalFormat;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @Description 东北大学库存
 * @Author hzw
 * @Date 2023/10/16 17:50
 * @Version 2.0
 */
@Api(tags = "东北大学库存")
@RestController
@RequestMapping("/stock")
public class DbStockController extends AbstractController {
    @Autowired
    private DbStockService dbStockService;
    @Autowired
    private DbBeaconService dbBeaconService;
    @Autowired
    private DbInOutRecordService dbInOutRecordService;

    @Autowired
    private DbUsageRecordService dbUsageRecordService;
    @Autowired
    private RemoteLaboratoryService remoteLaboratoryService;

    @Autowired
    private TokenService tokenService;

    @Autowired
    private RedisService redisService;

    /**
     * 库存入库
     *
     * @param dbStockBo
     * @return
     */
    @ApiOperation(value = "库存入库", notes = "参数说明：gasName 气体名称，level 级别，size 规格，gasComposition 气体成分,bottleColour 气瓶颜色,handwheel 手轮（0否 1是）,fixed 固定（0否 1是）,statusLabel 状态标牌（0否 1是），electronicTag 电子标签（0否 1是）,gasPressure 气体压力,validPeriod 有效期限,beaconTag 信标标签,subjectId 实验室id,subjectName 实验室名称,remark 备注 ")
    @PostMapping(value = "/enter")
    public ResultData in(@RequestBody DbStockBo dbStockBo) {
        //参数检查
        paramCheck.notNull(dbStockBo).strNotEmpty(dbStockBo.getGasName()).notNull(dbStockBo.getBeaconTag()).notNull(dbStockBo.getSubjectId());
        long count = dbBeaconService.count(new LambdaQueryWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbStockBo.getBeaconTag()));
        if (count == 0) {
            return ResultData.fail("信标库中不存在此标签！");
        }
        //验证信标
        long count1 = dbStockService.count(new LambdaQueryWrapper<DbStock>().eq(DbStock::getBeaconTag, dbStockBo.getBeaconTag()));
        if (count1 > 0) {
            return ResultData.fail("当前信标已绑定！");
        }
        SysUser sysUser = tokenService.getLoginUser().getSysUser();
        //查询实验室所在学院
        ResultData<List<CheckSubjectDto>> resultData = remoteLaboratoryService.findSubjectInfoList(String.valueOf(dbStockBo.getSubjectId()));
        if (resultData != null && HttpStatus.SUCCESS == resultData.getCode()) {
            List<CheckSubjectDto> data = resultData.getData();
            dbStockBo.setCollegeId(data.get(0).getDeptId());
            dbStockBo.setCollegeName(data.get(0).getCollegeName());
            dbStockBo.setRoomNum(data.get(0).getRoomNumber());
        }
        DbStock dbStock = new DbStock();
        BeanUtils.copyProperties(dbStockBo, dbStock);
        dbStock.setCreateBy(getCurrentUserId());
        dbStock.setCreateName(getCurrentUserName());
        if (dbStockService.save(dbStock)) {
            DbInOutRecord dbInOutRecord = new DbInOutRecord();
            BeanUtils.copyProperties(dbStockBo, dbInOutRecord);
            if(sysUser != null){
                dbInOutRecord.setOperator(sysUser.getNickName());
                dbInOutRecord.setOperatorId(sysUser.getUserId());
                dbInOutRecord.setPhone(sysUser.getPhonenumber());
                dbInOutRecord.setCreateBy(sysUser.getUserId());
                dbInOutRecord.setCreateName(sysUser.getUserName());
            }
            dbInOutRecord.setType(1);
            dbInOutRecordService.save(dbInOutRecord);
            dbBeaconService.update(new LambdaUpdateWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbInOutRecord.getBeaconTag()).set(DbBeacon::getState, Boolean.TRUE).set(DbBeacon::getBindingTime, LocalDateTime.now()));
            // 重新加载入库的信标到redis  chai
            new Thread(() -> loadBeaconDate(dbStock)).start();
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 库存出库
     *
     * @param dbStockBo
     * @return
     */
    @ApiOperation(value = "库存出库", notes = "参数说明：id 必填 ")
    @PostMapping(value = "/out")
    public ResultData out(@RequestBody DbStockBo dbStockBo) {
        //参数检查
        paramCheck.notNull(dbStockBo).notNull(dbStockBo.getId());
        DbStock stock = dbStockService.getById(dbStockBo.getId());
        if(dbStockBo.getGasPressure() != null){
            dbStockService.update(new LambdaUpdateWrapper<DbStock>().set(DbStock::getGasPressure, dbStockBo.getGasPressure()).eq(DbStock::getGasPressure, dbStockBo.getGasPressure()));
        }
        SysUser sysUser = tokenService.getLoginUser().getSysUser();
        if (dbStockService.removeById(stock.getId())) {
            DbInOutRecord dbInOutRecord = new DbInOutRecord();
            BeanUtils.copyProperties(stock, dbInOutRecord,new String[] {"createBy","createTime","updateName","updateBy","updateTime","createName"});
            if(sysUser != null){
                dbInOutRecord.setOperator(sysUser.getNickName());
                dbInOutRecord.setOperatorId(sysUser.getUserId());
                dbInOutRecord.setPhone(sysUser.getPhonenumber());
                dbInOutRecord.setCreateBy(sysUser.getUserId());
                dbInOutRecord.setCreateName(sysUser.getUserName());
            }
            dbInOutRecord.setType(2);
            dbInOutRecordService.save(dbInOutRecord);
            //解除信标
            dbBeaconService.update(new LambdaUpdateWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbInOutRecord.getBeaconTag()).set(DbBeacon::getState, 0));
            // 重新加载入库的信标到redis  chai
            new Thread(() -> remBeaconDate(stock)).start();
            return ResultData.success("出库成功");
        }
        return ResultData.fail("出库失败");
    }


    /**
     * 更新库存信息
     *
     * @Param [dbStockBo]
     * @Return com.zd.model.domain.ResultData
     **/
    @ApiOperation(value = "更新库存信息", notes = "参数说明：id 必填，gasName 气体名称，level 级别，size 规格，gasComposition 气体成分,bottleColour 气瓶颜色,handwheel 手轮（0否 1是）,fixed 固定（0否 1是）,statusLabel 状态标牌（0否 1是），electronicTag 电子标签（0否 1是）,gasPressure 气体压力,validPeriod 有效期限,beaconTag 信标标签,subjectId 实验室id,subjectName 实验室名称,remark 备注 ")
    @Log(title = "更新库存信息", businessType = BusinessType.UPDATE)
    @PostMapping(value = "/update")
    public ResultData update(@RequestBody DbStockBo dbStockBo) {
        //参数检查
        paramCheck.notNull(dbStockBo).notNull(dbStockBo.getId()).notNull(dbStockBo.getBeaconTag());
        long count1 = dbBeaconService.count(new LambdaQueryWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbStockBo.getBeaconTag()));
        if (count1 == 0) {
            return ResultData.fail("信标库中不存在此标签！");
        }
        long count = dbStockService.count(new LambdaQueryWrapper<DbStock>().ne(DbStock::getBeaconTag, dbStockBo.getBeaconTag()).eq(DbStock::getBeaconTag, dbStockBo.getBeaconTag()));
        if (count > 0) {
            return ResultData.fail("信标标签已绑定！");
        }
        dbBeaconService.update(new LambdaUpdateWrapper<DbBeacon>().eq(DbBeacon::getBeaconTag, dbStockBo.getBeaconTag()).set(DbBeacon::getState, Boolean.TRUE).set(DbBeacon::getBindingTime, LocalDateTime.now()));
        //将旧的信标从redis中移除 chai
        DbStock oldDbStock = dbStockService.getById(dbStockBo.getId());
        if (dbStockService.update(new LambdaUpdateWrapper<DbStock>().eq(DbStock::getId, dbStockBo.getId()).set(DbStock::getBeaconTag, dbStockBo.getBeaconTag()))) {
            redisService.deleteObject(BaseConstants.BEACON_MATE_DET + "~" + oldDbStock.getBeaconTag() + "~" + oldDbStock.getSubjectId() + "~" + oldDbStock.getGasName());
            //先把对应的信标提示语撤销
            List <Map<String,Object>> beaconNoticeList = redisService.getCacheObject(BaseConstants.BEACON_MATE_NOTICE+"~"+oldDbStock.getSubjectId());
            List <Map<String,Object>> newNoticeList = new ArrayList <>();
            if(beaconNoticeList!=null){
                newNoticeList.addAll(beaconNoticeList);
            }
            // 循环信标通知，修改的信标提示语移除。
            if(beaconNoticeList != null){
                for(Map notice:beaconNoticeList){
                    if(notice.get("beaconTag").equals(oldDbStock.getBeaconTag())){
                        log.info("=====================================》移除返回来的信标提示语："+notice);
                        newNoticeList.remove(notice);
                    }
                }
            }
            //下发通知，告诉前端页面，查询redis获取相关信息
            if(beaconNoticeList!=null && beaconNoticeList.size()!=newNoticeList.size()){
                //判断通知消息集合有数据，说明信标有变动，需要重新变更加通知
                redisService.setCacheObject(BaseConstants.BEACON_MATE_NOTICE+"~"+ oldDbStock.getSubjectId(),newNoticeList, 30L, TimeUnit.MINUTES);
            }
            // 重新加载入库的信标到redis  chai
            DbStock newDbStock = dbStockService.getById(dbStockBo.getId());
            new Thread(() -> loadBeaconDate(newDbStock)).start();
            return ResultData.success("操作成功");
        }
        return ResultData.fail("操作失败");
    }

    /**
     * 通过ID获取库存详情
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "通过ID获取库存详情", notes = "参数说明：库存id 必填")
    @GetMapping(value = "/findById")
    public ResultData find(@RequestParam("id") Long id) {
        paramCheck.notNull(id);
        DbStock dbStock = dbStockService.getById(id);
        DbUsageRecord dbUsageRecord = dbUsageRecordService.getOne(new LambdaQueryWrapper<DbUsageRecord>().eq(DbUsageRecord::getStcokId, dbStock.getId()).orderByDesc(DbUsageRecord::getId).last("limit 1"));
        DbStockVo dbStockVo = new DbStockVo();
        BeanUtils.copyProperties(dbStock, dbStockVo);
        if (dbUsageRecord != null) {
            dbStockVo.setUser(dbUsageRecord.getOperator());
            dbStockVo.setLastUseTime(dbUsageRecord.getCreateTime());
        }
        List<DbUsageRecord> list = dbUsageRecordService.list(new LambdaQueryWrapper<DbUsageRecord>().eq(DbUsageRecord::getStcokId, dbStock.getId()).orderByDesc(DbUsageRecord::getId));
        dbStockVo.setDbUsageRecordList(list);
        return ResultData.success(dbStockVo);
    }

    /**
     * 获取库存list
     *
     * @param dbStockParam
     * @return
     */
    @ApiOperation(value = "获取库存list", notes = "参数说明：searchValue 关键字,collegeId 学院id，startTime 开始时间，endTime 结束时间")
    @PreAuthorize(hasPermi = PerPrefix.DB_STOCK + PerFun.LIST)
    @PostMapping(value = "/list")
    public ResultData list(@RequestBody DbStockParam dbStockParam) {
        //查询条件
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper<>();
        //气瓶名称 实验室名称
        if (StringUtils.isNotBlank(dbStockParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(DbStock::getGasName, dbStockParam.getSearchValue()).or().like(DbStock::getSubjectName, dbStockParam.getSearchValue()).or().like(DbStock::getRoomNum, dbStockParam.getSearchValue());
            });
        }
        if (Objects.nonNull(dbStockParam.getCollegeId())) {
            queryWrapper.eq(DbStock::getCollegeId, dbStockParam.getCollegeId());
        }
        if (Objects.nonNull(dbStockParam.getStartTime()) && Objects.nonNull(dbStockParam.getEndTime())) {
            queryWrapper.between(DbStock::getCreateTime, dbStockParam.getStartTime().atStartOfDay(), dbStockParam.getEndTime().atTime(LocalTime.MAX));
        }
        //倒叙
        queryWrapper.orderByDesc(DbStock::getId);
        IPage<DbStock> result = dbStockService.page(PageUtil.getQuery(dbStockParam.getPageNum(), dbStockParam.getPageSize()), queryWrapper);
        return ResultData.success(result);
    }

    /**
     * app-获取库存list
     *
     * @param dbStockParam
     * @return
     */
    @ApiOperation(value = "app-获取库存list", notes = "参数说明：searchValue 关键字,collegeId 学院id，startTime 开始时间，endTime 结束时间")
    @PostMapping(value = "/appList")
    public ResultData appList(@RequestBody DbStockParam dbStockParam) {
        //查询条件
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper<>();
        //气瓶名称 实验室名称
        if (StringUtils.isNotBlank(dbStockParam.getSearchValue())) {
            queryWrapper.and(wrapper -> {
                wrapper.like(DbStock::getGasName, dbStockParam.getSearchValue()).or().like(DbStock::getSubjectName, dbStockParam.getSearchValue()).or().like(DbStock::getRoomNum, dbStockParam.getSearchValue());
            });
        }
        if (Objects.nonNull(dbStockParam.getCollegeId())) {
            queryWrapper.eq(DbStock::getCollegeId, dbStockParam.getCollegeId());
        }
        if (Objects.nonNull(dbStockParam.getStartTime()) && Objects.nonNull(dbStockParam.getEndTime())) {
            queryWrapper.between(DbStock::getCreateTime, dbStockParam.getStartTime().atStartOfDay(), dbStockParam.getEndTime().atTime(LocalTime.MAX));
        }
        //倒叙
        queryWrapper.orderByDesc(DbStock::getId);
        IPage<DbStock> result = dbStockService.page(PageUtil.getQuery(dbStockParam.getPageNum(), dbStockParam.getPageSize()), queryWrapper);
        return ResultData.success(result);
    }

    /**
     * 通过信标查询库信息
     *
     * @param BeaconTag
     * @return
     */
    @ApiOperation(value = "通过信标查询库信息", notes = "参数说明：subId 必填")
    @GetMapping(value = "/findByBeaconTag")
    public ResultData findByBancon(@RequestParam("BeaconTag") String BeaconTag) {
        paramCheck.strNotEmpty(BeaconTag);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getBeaconTag, BeaconTag);
        DbStock dbStock = dbStockService.getOne(queryWrapper);
        if (dbStock != null) {
            return ResultData.success(dbStock);
        }
        return ResultData.fail("信标未绑定库存信息！");
    }

    /**
     * 通过subId查询库存分类
     *
     * @param subId
     * @return
     */
    @ApiOperation(value = "通过subId查询库存分类", notes = "参数说明：subId 必填")
    @GetMapping(value = "/findClassifyBySubId")
    public ResultData findClassifyBySubId(@RequestParam("subId") Long subId) {
        paramCheck.notNull(subId);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, subId);
        List<DbStock> list = dbStockService.list(queryWrapper);
        Map<String, List<DbStock>> dbStockMap = Optional.ofNullable(list).orElseGet(Collections::emptyList).stream().collect(Collectors.groupingBy(DbStock::getGasName));
        Map<String, Object> allMap = new HashMap<>();
        allMap.put("total", list.size());
        List<Map<String, Object>> classifyList = new ArrayList<>();
        dbStockMap.forEach((key, value) -> {
            Map<String, Object> classifyMap = new HashMap<>();
            classifyMap.put("name", key);
            classifyMap.put("bottleSize", value.size());
            classifyList.add(classifyMap);
        });
        allMap.put("classifyList", classifyList);
        return ResultData.success(allMap);
    }

    /**
     * 通过subId查询库存列表
     *
     * @param subId
     * @return
     */
    @ApiOperation(value = "通过subId查询库存列表", notes = "参数说明：subId 必填")
    @GetMapping(value = "/findBySubId")
    public ResultData findBySubId(@RequestParam("subId") Long subId) {
        paramCheck.notNull(subId);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, subId);
        List<DbStock> list = dbStockService.list(queryWrapper);
        return ResultData.success(list);
    }



    /**
     * 通过subId载入库存列表
     *
     * @param subId
     * @return
     */
    @ApiOperation(value = "通过subId载入库存列表", notes = "参数说明：subId 必填")
    @GetMapping(value = "/setBeaconBySubId")
    public ResultData setBeaconBySubId(@RequestParam("subId") Long subId) {
        paramCheck.notNull(subId);
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, subId);
        List<DbStock> list = dbStockService.list(queryWrapper);
        redisService.setCacheObject(BaseConstants.BEACON_MATE_INFO + "~" + subId, list, 7L, TimeUnit.DAYS);
        for(DbStock stock : list){
            redisService.setCacheObject(BaseConstants.BEACON_MATE_DET + "~" + stock.getBeaconTag() + "~" + stock.getSubjectId() + "~" + stock.getGasName(), stock.getBeaconTag(), 120L, TimeUnit.SECONDS);
        }
        return ResultData.success(list);
    }


    /**
     * 每次入库，修改，需要重新加载对应的实验室信标列表和对应的信标
     *
     * @param dbStock
     * @return
     */
    public void loadBeaconDate(DbStock dbStock) {
        //查询库存信标列表，存入redis
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, dbStock.getSubjectId());
        List<DbStock> list = dbStockService.list(queryWrapper);
        redisService.setCacheObject(BaseConstants.BEACON_MATE_INFO + "~" + dbStock.getSubjectId(), list, 7L, TimeUnit.DAYS);
        //将提交的库存数据，存入redis
        redisService.setCacheObject(BaseConstants.BEACON_MATE_DET + "~" + dbStock.getBeaconTag() + "~" + dbStock.getSubjectId() + "~" + dbStock.getGasName(), dbStock.getBeaconTag(), 120L, TimeUnit.SECONDS);
    }

    /**
     * 每次出库需要重新加载对应的实验室信标列表和移除对应信标
     *
     * @param dbStock
     * @return
     */
    public void remBeaconDate(DbStock dbStock) {
        //查询库存信标列表，存入redis
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.eq(DbStock::getSubjectId, dbStock.getSubjectId());
        List<DbStock> list = dbStockService.list(queryWrapper);
        redisService.setCacheObject(BaseConstants.BEACON_MATE_INFO + "~" + dbStock.getSubjectId(), list, 7L, TimeUnit.DAYS);
        //将信标从redis中移除
        redisService.deleteObject(BaseConstants.BEACON_MATE_DET + "~" + dbStock.getBeaconTag() + "~" + dbStock.getSubjectId() + "~" + dbStock.getGasName());
        //先把对应的信标提示语撤销
        List <Map<String,Object>> beaconNoticeList = redisService.getCacheObject(BaseConstants.BEACON_MATE_NOTICE+"~"+dbStock.getSubjectId());
        List <Map<String,Object>> newNoticeList = new ArrayList <>();
        if(beaconNoticeList!=null){
            newNoticeList.addAll(beaconNoticeList);
        }
        // 循环信标通知，修改的信标提示语移除。
        if(beaconNoticeList != null){
            for(Map notice:beaconNoticeList){
                if(notice.get("beaconTag").equals(dbStock.getBeaconTag())){
                    log.info("=====================================》移除返回来的信标提示语："+notice);
                    newNoticeList.remove(notice);
                }
            }
        }
        //下发通知，告诉前端页面，查询redis获取相关信息
        if(beaconNoticeList!=null && beaconNoticeList.size()!=newNoticeList.size()){
            //判断通知消息集合有数据，说明信标有变动，需要重新变更加通知
            redisService.setCacheObject(BaseConstants.BEACON_MATE_NOTICE+"~"+ dbStock.getSubjectId(),newNoticeList, 30L, TimeUnit.MINUTES);
        }
    }

    /**
     * 根据实验室ids查询库存列表
     */
    @ApiOperation(value = "根据实验室ids查询库存列表")
    @GetMapping("/{ids}")
    public ResultData getStockBySubIds(@PathVariable Long[] ids)
    {
        //查询库存信标列表，存入redis
        LambdaQueryWrapper<DbStock> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.in(DbStock::getSubjectId, ids);
        List<DbStock> list = dbStockService.list(queryWrapper);
        return ResultData.success(list);
    }

    /***
     *
     * @param
     * @return
     */
    @ApiOperation(value = "查询气体按名称分组")
    @GetMapping(value = "/groupBottleName")
    public ResultData findBySubId(DbStockBo bo) {
        return ResultData.success(dbStockService.selectStockListGroupBy(bo));
    }

    /**
     * 按气体名称分组（电子信息牌使用）
     * @param bo
     * @return
     */
    @ApiOperation(value = "按气体名称分组")
    @GetMapping(value = "/groupName")
    public ResultData groupName(DbStockBo bo) {
        if(bo.getSubjectId()==null){
            ResultData.success(new ArrayList<>());
        }
        //气瓶分类后显示的长度
        int num=4;
        List<DbStockVo> backList = new ArrayList<>();
        paramCheck.notNull(bo.getSubjectId());
        List<DbStockVo> list= dbStockService.selectStockListGroupBy(bo);
        if(list!=null && !list.isEmpty()){
            Integer totalNum =  list.stream().mapToInt(DbStockVo::getTotalNum).sum();
            int p=0;
            String gasNameStr="";
            for (int i=0;i<list.size();i++){
                DbStockVo backVo = new DbStockVo();
                if(i<num){
                    backVo.setGasName(list.get(i).getGasName());
                    backVo.setTotalNum(list.get(i).getTotalNum());
                    backVo.setRatio(myPercent(list.get(i).getTotalNum(),totalNum,"##.##"));
                    backList.add(backVo);
                }else{
                    p=p+list.get(i).getTotalNum();
                    gasNameStr = gasNameStr+list.get(i).getGasName()+",";
                }
            }

            if(list.size()>num){
                DbStockVo backVo2 = new DbStockVo();
                backVo2.setGasName("更多");
                backVo2.setTotalNum(p);
                backVo2.setRemark(gasNameStr);
                backVo2.setFlg(1);
                backVo2.setRatio(myPercent(p,totalNum,"##.##"));
                backList.add(backVo2);
            }
        }
        return ResultData.success(backList);
    }

    /***
     * 查询实验室下气体列表（信息牌使用）
     * @param bo
     * @return
     */
    @ApiOperation(value = "查询实验室下气体列表（信息牌使用）")
    @GetMapping(value = "/getListByName")
    public ResultData getListByName(DbStockBo bo) {
        if(bo.getSubjectId()==null || bo.getGasName()==null){
            return ResultData.success(new ArrayList<>());
        }
        List<DbInOutRecordVo> backList = new ArrayList<>();
        //实验室下根据气体名称查询未出库的气瓶集合
        paramCheck.notNull(bo.getSubjectId()).notNull(bo.getGasName());
        QueryWrapper<DbStock> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(DbStock::getSubjectId,bo.getSubjectId());
        if(bo.getFlg()!=null && 1==bo.getFlg() && bo.getRemark()!=null && bo.getRemark()!=""){
            if(bo.getRemark()!=null && bo.getRemark()!=""){
                queryWrapper.lambda().in(DbStock::getGasName,bo.getRemark().split(","));
            }else {
                log.error(" 查询实验室下气体列表,气体集合为空："+bo.getRemark());
            }
        }else{
            queryWrapper.lambda().eq(DbStock::getGasName,bo.getGasName());
        }

        List<DbStock> list = dbStockService.list(queryWrapper);
        if(list!=null && !list.isEmpty()){
            for (DbStock r:list) {
                DbInOutRecordVo vo = new DbInOutRecordVo();
                BeanUtils.copyProperties(r,vo);
                if(r.getBeaconTag()!=null){
                    //查看redis是否有值
                    String redisStr =redisService.getCacheObject(BaseConstants.BEACON_MATE_DET+"~"+ r.getBeaconTag()+"~"+r.getSubjectId()+"~"+r.getGasName());
                    if(redisStr!=null && redisStr!=""){
                        //在位
                        vo.setLocationState(1);
                    }else {
                        //离位
                        vo.setLocationState(0);
                    }
                }
                backList.add(vo);
            }
        }
        return ResultData.success(backList);
    }



    /**
     * 百分比计算
     *
     * @param y
     * @param z
     * @return
     */
    public String myPercent(Integer y, Integer z, String format) {
        if (0 == y || 0 == z) {
            return "0";
        }
        // 接受百分比的值
        String baifenbi = "";
        double baiy = y * 1.0;
        double baiz = z * 1.0;
        double fen = baiy / baiz;
        DecimalFormat df1 = new DecimalFormat(format);
        // 百分比格式，后面不足2位的用0补齐
        baifenbi = df1.format(fen);
        return baifenbi;
    }
}