安全物资和设备管理调整v2

zhangfeng

2022-12-23 f7d2f20365467a834188edd35c464d9fb9349214

 equipment/equipment-service/src/main/java/com/gkhy/safePlatform/equipment/service/impl/SafeMaterialDetailServiceImpl.java

@@ -4,32 +4,28 @@
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gkhy.safePlatform.account.rpc.apimodel.AccountUserService;
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserInfoRPCRespDTO;
import com.gkhy.safePlatform.commons.co.ContextCacheUser;
import com.gkhy.safePlatform.commons.enums.ResultCodes;
import com.gkhy.safePlatform.commons.exception.BusinessException;
import com.gkhy.safePlatform.commons.query.PageQuery;
import com.gkhy.safePlatform.commons.utils.StringUtils;
import com.gkhy.safePlatform.commons.vo.ResultVO;
import com.gkhy.safePlatform.commons.vo.SearchResultVO;
import com.gkhy.safePlatform.equipment.common.RocketMQTemplateHelper;
import com.gkhy.safePlatform.equipment.entity.*;
import com.gkhy.safePlatform.equipment.enums.*;
import com.gkhy.safePlatform.equipment.excepiton.EquipmentException;
import com.gkhy.safePlatform.equipment.model.dto.req.*;
import com.gkhy.safePlatform.equipment.model.dto.req.db.SafeMaterialDetailDBQuery;
import com.gkhy.safePlatform.equipment.model.dto.resp.SafeMaterialClassifyStockDto;
import com.gkhy.safePlatform.equipment.model.dto.resp.SafeMaterialDetailDto;
import com.gkhy.safePlatform.equipment.model.dto.resp.SafeRfidMaterialDetailDto;
import com.gkhy.safePlatform.equipment.mq.msg.SafeMaterialMsg;
import com.gkhy.safePlatform.equipment.service.SafeMaterialDetailService;
import com.gkhy.safePlatform.equipment.service.baseService.SafeMaterialClassifyInfoService;
import com.gkhy.safePlatform.equipment.service.baseService.SafeMaterialDetailInfoService;
import com.gkhy.safePlatform.equipment.service.baseService.SafeMaterialInfoService;
import com.gkhy.safePlatform.equipment.service.baseService.*;
import org.apache.dubbo.config.annotation.DubboReference;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
@@ -51,22 +47,25 @@
    @Autowired
    private SafeMaterialClassifyInfoService safeMaterialClassifyInfoService;

    @Value("${rocketmq.topic.safeMaterialTopic}")
    private String safeMaterialTopic;

    @DubboReference(check = false)
    private AccountUserService accountUserService;

    @Autowired
    private RocketMQTemplateHelper rocketMQTemplateHelper;
    private RedissonClient redissonClient;

    @Autowired
    private RedissonClient redissonClient;
    private MaterialReceiveRecordsBaseInfoService materialReceiveRecordsBaseInfoService;

    @Autowired
    private MaterialReceiveRecordsInfoService materialReceiveRecordsInfoService;


    @Override
    @Transactional
    public ResultVO save(SafeMaterialDetailAddReq req) {
        //判断物资是否存在
        SafeMaterialInfo materialInfo = safeMaterialInfoService.queryById(req.getSmId());
        if(null == materialInfo){
        SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(req.getSmId());
        if(null == safeMaterialDO){
            throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"该种物资不存在！");
        }
        if(null == ValidTypeEnum.getByCode(req.getValidType())){
@@ -99,11 +98,13 @@
                String rfid = "0000000".substring(0,(8 - countStr.length()))+countStr;
                SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
                materialDetailInfo.setId(IdUtil.getSnowflake(0,0).nextId());
                materialDetailInfo.setBigClassifyId(materialInfo.getBigClassifyId());
                materialDetailInfo.setSmallClassifyId(materialInfo.getSmallClassifyId());
                materialDetailInfo.setName(materialInfo.getMaterialName());
                materialDetailInfo.setBigClassifyId(safeMaterialDO.getBigClassifyId());
                materialDetailInfo.setSmallClassifyId(safeMaterialDO.getSmallClassifyId());
                materialDetailInfo.setName(safeMaterialDO.getMaterialName());
                materialDetailInfo.setSmId(req.getSmId());
                materialDetailInfo.setConsumable(materialInfo.getConsumable());
                materialDetailInfo.setConsumable(safeMaterialDO.getConsumable());
                materialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
                materialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                materialDetailInfo.setValidType(req.getValidType());
                if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode())){
                    materialDetailInfo.setValidTime(req.getValidTime());
@@ -120,11 +121,13 @@
            for(int i = 0;i < req.getWareHousingCount();i++){
                SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
                materialDetailInfo.setId(IdUtil.getSnowflake(0,0).nextId());
                materialDetailInfo.setBigClassifyId(materialInfo.getBigClassifyId());
                materialDetailInfo.setSmallClassifyId(materialInfo.getSmallClassifyId());
                materialDetailInfo.setName(materialInfo.getMaterialName());
                materialDetailInfo.setBigClassifyId(safeMaterialDO.getBigClassifyId());
                materialDetailInfo.setSmallClassifyId(safeMaterialDO.getSmallClassifyId());
                materialDetailInfo.setName(safeMaterialDO.getMaterialName());
                materialDetailInfo.setSmId(req.getSmId());
                materialDetailInfo.setConsumable(materialInfo.getConsumable());
                materialDetailInfo.setConsumable(safeMaterialDO.getConsumable());
                materialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
                materialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                materialDetailInfo.setValidType(req.getValidType());
                if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode())){
                    materialDetailInfo.setValidTime(req.getValidTime());
@@ -136,6 +139,11 @@
                list.add(materialDetailInfo);
            }
        }
        //填充物资管理数据
        SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
        safeMaterialBO.setId(req.getSmId());
        safeMaterialBO.setStockCount(req.getWareHousingCount());
        safeMaterialBO.setTotalCount(req.getWareHousingCount());

        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_SAVE");
@@ -143,16 +151,18 @@
            lock.lock(10, TimeUnit.SECONDS);
            //批量入库
            safeMaterialDetailInfoService.saveBatch(list);
            //修改数量
            safeMaterialInfoService.updateCountById(safeMaterialBO);

            //发送消息
            if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null != req.getValidTime()){
            /*if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null != req.getValidTime()){
                for(SafeMaterialDetailInfo materialDetailInfo:list){
                    SafeMaterialMsg safeMaterialMsg = new SafeMaterialMsg();
                    safeMaterialMsg.setId(materialDetailInfo.getId());
                    safeMaterialMsg.setValidTime(conversionTimeType(materialDetailInfo.getValidTime()));
                    rocketMQTemplateHelper.syncSend(safeMaterialTopic,safeMaterialMsg);
                }
            }
            }*/
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
@@ -176,10 +186,11 @@
     * @return
     */
    @Override
    @Transactional
    public ResultVO saveBatch(SafeMaterialDetailAddReq req) {
        //判断物资是否存在
        SafeMaterialInfo materialInfo = safeMaterialInfoService.queryById(req.getSmId());
        if(null == materialInfo){
        SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(req.getSmId());
        if(null == safeMaterialDO){
            throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"该种物资不存在！");
        }
        if(null == ValidTypeEnum.getByCode(req.getValidType())){
@@ -195,11 +206,13 @@
        for(int i = 0;i < req.getWareHousingCount();i++){
            SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
            materialDetailInfo.setId(IdUtil.getSnowflake(0,0).nextId());
            materialDetailInfo.setBigClassifyId(materialInfo.getBigClassifyId());
            materialDetailInfo.setSmallClassifyId(materialInfo.getSmallClassifyId());
            materialDetailInfo.setName(materialInfo.getMaterialName());
            materialDetailInfo.setBigClassifyId(safeMaterialDO.getBigClassifyId());
            materialDetailInfo.setSmallClassifyId(safeMaterialDO.getSmallClassifyId());
            materialDetailInfo.setName(safeMaterialDO.getMaterialName());
            materialDetailInfo.setSmId(req.getSmId());
            materialDetailInfo.setConsumable(materialInfo.getConsumable());
            materialDetailInfo.setConsumable(safeMaterialDO.getConsumable());
            materialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
            materialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
            materialDetailInfo.setValidType(req.getValidType());
            if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode())){
                materialDetailInfo.setValidTime(req.getValidTime());
@@ -211,22 +224,22 @@
            materialDetailInfo.setMaterialNo(generateMaterialNo(totalCount+i));
            list.add(materialDetailInfo);
        }
        //填充物资管理数据
        SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
        safeMaterialBO.setId(req.getSmId());
        safeMaterialBO.setStockCount(req.getWareHousingCount());
        safeMaterialBO.setTotalCount(req.getWareHousingCount());

        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_SAVEBATCH");
        try {
            lock.lock(10, TimeUnit.SECONDS);
            //批量入库
            safeMaterialDetailInfoService.saveBatch(list);
            //发送消息
            if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null != req.getValidTime()){
                for(SafeMaterialDetailInfo materialDetailInfo:list){
                    //发送消息
                    SafeMaterialMsg safeMaterialMsg = new SafeMaterialMsg();
                    safeMaterialMsg.setId(materialInfo.getId());
                    safeMaterialMsg.setValidTime(conversionTimeType(materialDetailInfo.getValidTime()));
                    rocketMQTemplateHelper.syncSend(safeMaterialTopic,safeMaterialMsg);
                }
            }
            //修改数量
            safeMaterialInfoService.updateCountById(safeMaterialBO);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
@@ -261,9 +274,17 @@
            }else{
                if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null == req.getValidTime()){
                    throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"有效期时间不可为空！");
                }else{
                    if(req.getValidTime().before(new Date())){
                        throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"有效期时间小于当前时间！");
                    }
                }
            }
        }
        //填充物资管理数据
        SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
        safeMaterialBO.setId(vo.getSmId());
        safeMaterialBO.setStockCount(0);
        //填充数据
        SafeMaterialDetailInfo safeMaterialDetailInfo = new SafeMaterialDetailInfo();
        safeMaterialDetailInfo.setId(req.getId());
@@ -271,20 +292,29 @@
        safeMaterialDetailInfo.setSmId(req.getSmId());
        safeMaterialDetailInfo.setValidType(req.getValidType());
        safeMaterialDetailInfo.setValidTime(req.getValidTime());
        if(ValidStatusEnum.NO.getCode().equals(vo.getValidStatus())){
            //无效情况
            if(vo.getStatus().equals(MaterialStatusEnum.OVERDUE.getCode())){
                //过期
                safeMaterialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
                safeMaterialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
                safeMaterialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                safeMaterialBO.setStockCount(1);
            }
        }


        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_UPDATE");
        try {
            lock.lock(10, TimeUnit.SECONDS);
            //修改
            safeMaterialDetailInfoService.updateById(safeMaterialDetailInfo);
            //如果是非常期
            if(req.getValidType().equals(ValidTypeEnum.SHORT_TERM.getCode()) && null != req.getValidTime()){
                //发送消息
                SafeMaterialMsg safeMaterialMsg = new SafeMaterialMsg();
                safeMaterialMsg.setId(req.getId());
                safeMaterialMsg.setValidTime(conversionTimeType(req.getValidTime()));
                rocketMQTemplateHelper.syncSend(safeMaterialTopic,safeMaterialMsg);
            if(null != safeMaterialBO){
                safeMaterialInfoService.updateCountById(safeMaterialBO);
            }
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
@@ -301,7 +331,7 @@

    /**
     * 批量-重新入库
     * @param ids
     * @param
     * @return
     */
    @Override
@@ -314,13 +344,15 @@
            List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(paramForm.getIds());
            List<SafeMaterialDetailInfo> selectList = list
                    .stream()
                    .filter(item -> item.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode()) && item.getConsumable().equals(ConsumableEnum.YES.getCode()))
                    .filter(item -> item.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode()) && item.getConsumable().equals(ConsumableEnum.NO.getCode()))
                    .collect(Collectors.toList());
            if(selectList.size() != paramForm.getIds().size()){
                throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"已入库或耗材物资不可重复入库！");
            }
            //修改为入库状态
            safeMaterialDetailInfoService.updateReceiptStatusByIds(paramForm.getIds(),IssueReceiptEnum.IN_THE_LIBRARY.getCode());
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
@@ -340,66 +372,39 @@
     * @param
     * @return
     */
    @Transactional
    @Override
    public ResultVO deleteBatch(ParamForm paramForm) {
        safeMaterialDetailInfoService.deleteBatch(paramForm.getIds());
        return new ResultVO(ResultCodes.OK);
    }

    /**
     * 批量出库 - 根据ids
     * @param req
     * @return
     */
    @Override
    public ResultVO deliveryBatchByIds(MterialDeliveryReq req) {
        //获取认领人信息
        UserInfoRPCRespDTO userInfo = getUserInfo(req.getClaimantId());
        //验证
        List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(req.getIds());
        List<SafeMaterialDetailInfo> selectList = list
                .stream()
                .filter(item -> item.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode()) && item.getValidStatus().equals(ValidStatusEnum.YES.getCode()))
                .collect(Collectors.toList());
        if(selectList.size() != req.getIds().size()){
            throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"已出库物资或无效物资，不可出库！");
        }
        SafeMaterialDetailBO detailBO = new SafeMaterialDetailBO();
        detailBO.setIds(req.getIds());
        detailBO.setClaimantName(userInfo.getUsername());
        detailBO.setClaimantId(req.getClaimantId());
        safeMaterialDetailInfoService.updateDeliveryStatusByIds(detailBO);
        return new ResultVO(ResultCodes.OK);
    }

    @Override
    public ResultVO deliveryBatchRandom(MterialRandomDeliveryReq req) {
        UserInfoRPCRespDTO userInfo = getUserInfo(req.getClaimantId());
        List<Long> idList = new ArrayList<>();
    public ResultVO deleteBatch(ContextCacheUser currentUser,ParamForm paramForm) {
        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_DELIVERYBATCHRANDOM");
        RLock lock = redissonClient.getLock("LOCK_SMD_DELETEBATCH");
        try {
            lock.lock(10, TimeUnit.SECONDS);
            if(StringUtils.isNotBlank(req.getRfid())){
                idList = safeMaterialDetailInfoService.getIdListByRfid(req.getCount(),req.getSmId(),req.getRfid());

            }else{
                idList = safeMaterialDetailInfoService.getRfidNullList(req.getCount(), req.getSmId());

            //获取所有物资管理
            List<SafeMaterialInfo> safeMaterialInfoList = safeMaterialInfoService.listByDepId(currentUser.getDepId());
            List<Long> idList = paramForm.getIds();
            List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(idList);
            List<SafeMaterialDetailInfo> collect = list.stream().filter(item -> item.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode())).collect(Collectors.toList());
            if(collect.size()>0){
                throw new EquipmentException(ResultCodes.SERVER_DEL_ERROR,"出库物资不可删除！");
            }
            if(idList.size()< req.getCount()){
                throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"有效库存数量不足！");
            List<SafeMaterialBO> safeMaterialBOList = new ArrayList<>();
            for(SafeMaterialInfo materialInfo:safeMaterialInfoList){
                List<SafeMaterialDetailInfo> selectList = list.stream().filter(item -> item.getSmId().equals(materialInfo.getId())).collect(Collectors.toList());
                if(selectList.size()>0){
                    //物资管理
                    SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
                    safeMaterialBO.setId(materialInfo.getId());
                    safeMaterialBO.setStockCount(-selectList.size());
                    safeMaterialBO.setTotalCount(-selectList.size());
                    safeMaterialBOList.add(safeMaterialBO);
                }
            }
            //获取有效数量
            Integer validStockCount = safeMaterialDetailInfoService.getValidStockCount(req.getSmId());
            if(req.getCount() > validStockCount){
                throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"出库数量不可大于有效库存数量！");
            }
            SafeMaterialDetailBO detailBO = new SafeMaterialDetailBO();
            detailBO.setClaimantName(userInfo.getUsername());
            detailBO.setClaimantId(req.getClaimantId());
            detailBO.setIds(idList);
            safeMaterialDetailInfoService.updateDeliveryStatusByIds(detailBO);
            //删除
            safeMaterialDetailInfoService.deleteBatch(paramForm.getIds());
            //修改库存
            safeMaterialInfoService.updateStockCount(safeMaterialBOList);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
@@ -412,6 +417,246 @@
            }
        }
        return new ResultVO(ResultCodes.OK);
    }

    /**
     * 批量出库 - 根据ids
     * @param req
     * @return
     */
    @Transactional
    @Override
    public void deliveryBatchByIds(MterialDeliveryReq req,ContextCacheUser currentUser) {
        //获取认领人信息
        UserInfoRPCRespDTO userInfo = getUserInfo(req.getReceiveUid());
        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_DELIVERYBATCHBYIDS");
        try {
            lock.lock(10, TimeUnit.SECONDS);
            //验证
            List<SafeMaterialDetailInfo> list = safeMaterialDetailInfoService.getListByIds(req.getIds());
            List<SafeMaterialDetailInfo> selectList = list
                    .stream()
                    .filter(item -> item.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode()) && item.getValidStatus().equals(ValidStatusEnum.YES.getCode()))
                    .collect(Collectors.toList());
            if(selectList.size() != req.getIds().size()){
                throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"已出库物资或无效物资，不可出库！");
            }
            //获取该部门的所管理物资
            List<SafeMaterialInfo> safeMaterialInfoList = safeMaterialInfoService.listByDepId(currentUser.getDepId());
            List<MaterialReceiveRecordsBaseInfo> receiveRecordsBaseInfoList = new ArrayList<>();
            List<MaterialReceiveRecordsInfo> receiveRecordsInfoList = new ArrayList<>();
            List<SafeMaterialBO> safeMaterialBOList = new ArrayList<>();
            List<SafeMaterialDetailInfo> safeMaterialDetailInfoList = new ArrayList<>();
            //循环
            for(SafeMaterialInfo safeMaterialInfo:safeMaterialInfoList){
                List<SafeMaterialDetailInfo> collectList = list.stream().filter(item -> safeMaterialInfo.getId().equals(item.getSmId())).collect(Collectors.toList());
                if(collectList.size()>0){
                    //物资管理
                    SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
                    safeMaterialBO.setId(safeMaterialInfo.getId());
                    safeMaterialBO.setStockCount(-collectList.size());
                    safeMaterialBOList.add(safeMaterialBO);

                    //总记录
                    MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
                    receiveRecordsBaseInfo.setId(IdUtil.getSnowflake(0,0).nextId());
                    receiveRecordsBaseInfo.setMaterialName(safeMaterialInfo.getMaterialName());
                    receiveRecordsBaseInfo.setReceiveUid(userInfo.getUid());
                    receiveRecordsBaseInfo.setReceiveUname(userInfo.getUsername());
                    receiveRecordsBaseInfo.setReceiveCount(collectList.size());
                    receiveRecordsBaseInfo.setRevertCount(0);
                    receiveRecordsBaseInfo.setConsumeCount(0);
                    if(ConsumableEnum.YES.getCode().equals(safeMaterialInfo.getConsumable())){
                        receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.CONSUMABLE_RETURN_NO.getCode());
                        receiveRecordsBaseInfo.setConsumeCount(0);
                    }else{
                        receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_NO.getCode());
                        receiveRecordsBaseInfo.setConsumeCount(collectList.size());
                    }
                    receiveRecordsBaseInfo.setSmId(safeMaterialInfo.getId());
                    receiveRecordsBaseInfoList.add(receiveRecordsBaseInfo);
                    //循环详细物资
                    for(SafeMaterialDetailInfo safeMaterialDetailInfo:collectList){
                        //领取物资清单记录
                        MaterialReceiveRecordsInfo materialReceiveRecordsInfo = new MaterialReceiveRecordsInfo();
                        materialReceiveRecordsInfo.setId(IdUtil.getSnowflake(0,0).nextId());
                        materialReceiveRecordsInfo.setMaterialName(safeMaterialDetailInfo.getName());
                        materialReceiveRecordsInfo.setMaterialNo(safeMaterialDetailInfo.getMaterialNo());
                        materialReceiveRecordsInfo.setReceiveBaseId(receiveRecordsBaseInfo.getId());
                        if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
                            materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.DEPLETION.getCode());
                            materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.OTHER.getCode());
                            materialReceiveRecordsInfo.setRemark("耗材");
                        }else{
                            materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_NO.getCode());
                            materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
                            materialReceiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                        }
                        materialReceiveRecordsInfo.setReceiveTime(LocalDateTime.now());
                        materialReceiveRecordsInfo.setReceiveUid(userInfo.getUid());
                        materialReceiveRecordsInfo.setReceiveUname(userInfo.getUsername());
                        materialReceiveRecordsInfo.setSmdId(safeMaterialDetailInfo.getId());
                        materialReceiveRecordsInfo.setRfid(safeMaterialDetailInfo.getRfid());
                        receiveRecordsInfoList.add(materialReceiveRecordsInfo);
                        //物资清单
                        SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
                        materialDetailInfo.setId(safeMaterialDetailInfo.getId());
                        materialDetailInfo.setReceiveUid(userInfo.getUid());
                        materialDetailInfo.setReceiveUname(userInfo.getRealName());
                        materialDetailInfo.setIrStatus(IssueReceiptEnum.OUT_OF_LIBRARY.getCode());
                        materialDetailInfo.setDeliveryTime(LocalDateTime.now());
                        if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
                            materialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
                            materialDetailInfo.setStatus(MaterialStatusEnum.OTHER.getCode());
                            materialDetailInfo.setRemark("耗材");
                        }
                        safeMaterialDetailInfoList.add(materialDetailInfo);
                    }

                }

            }
            //修改物资管理数量
            safeMaterialInfoService.updateStockCount(safeMaterialBOList);
            //修改物资清单的状态
            safeMaterialDetailInfoService.updateBatchById(safeMaterialDetailInfoList);
            //插入领取总记录
            materialReceiveRecordsBaseInfoService.saveBatch(receiveRecordsBaseInfoList);
            //插入领取清单
            materialReceiveRecordsInfoService.saveBatch(receiveRecordsInfoList);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(ResultCodes.SERVER_ERROR);
        }finally {
            if(lock.isLocked()){
                lock.unlock();
            }
        }
    }



    @Transactional
    @Override
    public void deliveryBatchBySmId(MterialRandomDeliveryReq req,ContextCacheUser currentUser) {
        SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(req.getSmId());
        if(null == safeMaterialDO){
            throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"物资不存在，无法出库！");
        }
        SafeMaterialDetailDBQuery query = new SafeMaterialDetailDBQuery();
        query.setSmId(safeMaterialDO.getId());
        query.setCount(req.getCount());
        query.setRfid(req.getRfid());
        query.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
        query.setValidStatus(ValidStatusEnum.YES.getCode());
        UserInfoRPCRespDTO userInfo = getUserInfo(req.getReceiveUid());
        List<SafeMaterialDetailInfo> safeMaterialDetailInfoList = new ArrayList<>();
        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_DELIVERYBATCHRANDOM");
        try {
            lock.lock(10, TimeUnit.SECONDS);
            //获取有效数量
            Integer validStockCount = safeMaterialDetailInfoService.getValidStockCount(req.getSmId());
            if(req.getCount() > validStockCount){
                    throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"出库数量不可大于有效库存数量！");
            }
            if(StringUtils.isNotBlank(req.getRfid())){
                safeMaterialDetailInfoList = safeMaterialDetailInfoService.getListBySmIdAndRfid(query);
            }else{
                safeMaterialDetailInfoList = safeMaterialDetailInfoService.getListBySmId(query);
            }
            if(safeMaterialDetailInfoList.size()< req.getCount()){
                throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"库存数量不足！");
            }
            //物资管理
            SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
            safeMaterialBO.setId(req.getSmId());
            safeMaterialBO.setStockCount(-req.getCount());
            //领取记录
            MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
            receiveRecordsBaseInfo.setId(IdUtil.getSnowflake(0,0).nextId());
            receiveRecordsBaseInfo.setMaterialName(safeMaterialDO.getMaterialName());
            receiveRecordsBaseInfo.setReceiveUid(userInfo.getUid());
            receiveRecordsBaseInfo.setReceiveUname(userInfo.getUsername());
            receiveRecordsBaseInfo.setReceiveCount(req.getCount());
            receiveRecordsBaseInfo.setRevertCount(0);
            receiveRecordsBaseInfo.setConsumeCount(0);
            if(ConsumableEnum.YES.getCode().equals(safeMaterialDO.getConsumable())){
                receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.CONSUMABLE_RETURN_NO.getCode());
                receiveRecordsBaseInfo.setConsumeCount(req.getCount());
            }else{
                receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_NO.getCode());
                receiveRecordsBaseInfo.setConsumeCount(0);

            }
            receiveRecordsBaseInfo.setSmId(safeMaterialDO.getId());
            //物资领取清单
            List<MaterialReceiveRecordsInfo> receiveRecordsInfoList = new ArrayList<>();
            //物资清单
            List<SafeMaterialDetailInfo> updateDetailList = new ArrayList<>();
            for(SafeMaterialDetailInfo safeMaterialDetailInfo:safeMaterialDetailInfoList){
                //领取物资清单记录
                MaterialReceiveRecordsInfo materialReceiveRecordsInfo = new MaterialReceiveRecordsInfo();
                materialReceiveRecordsInfo.setId(IdUtil.getSnowflake(0,0).nextId());
                materialReceiveRecordsInfo.setMaterialName(safeMaterialDetailInfo.getName());
                materialReceiveRecordsInfo.setMaterialNo(safeMaterialDetailInfo.getMaterialNo());
                materialReceiveRecordsInfo.setReceiveBaseId(receiveRecordsBaseInfo.getId());
                if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
                    materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.DEPLETION.getCode());
                    materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.OTHER.getCode());
                    materialReceiveRecordsInfo.setRemark("耗材");
                }else{
                    materialReceiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_NO.getCode());
                    materialReceiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
                    materialReceiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                }
                materialReceiveRecordsInfo.setReceiveTime(LocalDateTime.now());
                materialReceiveRecordsInfo.setReceiveUid(userInfo.getUid());
                materialReceiveRecordsInfo.setReceiveUname(userInfo.getUsername());
                materialReceiveRecordsInfo.setSmdId(safeMaterialDetailInfo.getId());
                materialReceiveRecordsInfo.setRfid(safeMaterialDetailInfo.getRfid());
                receiveRecordsInfoList.add(materialReceiveRecordsInfo);
                //物资清单
                SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
                materialDetailInfo.setId(safeMaterialDetailInfo.getId());
                materialDetailInfo.setReceiveUid(userInfo.getUid());
                materialDetailInfo.setReceiveUname(userInfo.getRealName());
                materialDetailInfo.setIrStatus(IssueReceiptEnum.OUT_OF_LIBRARY.getCode());
                materialDetailInfo.setDeliveryTime(LocalDateTime.now());
                if(ConsumableEnum.YES.getCode().equals(safeMaterialDetailInfo.getConsumable())){
                    materialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
                    materialDetailInfo.setStatus(MaterialStatusEnum.OTHER.getCode());
                    materialDetailInfo.setRemark("耗材");
                }
                updateDetailList.add(materialDetailInfo);
            }
            //修改物资清单状态
            safeMaterialDetailInfoService.updateBatchById(updateDetailList);
            //修改物资管理库存
            safeMaterialInfoService.updateCountById(safeMaterialBO);
            //插入领取总记录
            materialReceiveRecordsBaseInfoService.save(receiveRecordsBaseInfo);
            //插入领取清单
            materialReceiveRecordsInfoService.saveBatch(receiveRecordsInfoList);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(ResultCodes.SERVER_ERROR);
        }finally {
            if(lock.isLocked()){
                lock.unlock();
            }
        }
    }

    /**
@@ -494,9 +739,9 @@
                ids.addAll(collect);
            }
        }
        SafeMaterialDetailBO detailBO = new SafeMaterialDetailBO();
        detailBO.setClaimantName(userInfo.getUsername());
        detailBO.setClaimantId(req.getClaimantId());
        SafeMaterialBatchDeliveryBO detailBO = new SafeMaterialBatchDeliveryBO();
        detailBO.setReceiveUname(userInfo.getUsername());
        detailBO.setReceiveUid(req.getClaimantId());
        detailBO.setIds(ids);
        safeMaterialDetailInfoService.updateDeliveryStatusByIds(detailBO);

@@ -528,9 +773,32 @@
    }

    @Override
    public SearchResultVO<List<SafeMaterialDetailDto>> listByPage(PageQuery<SafeMatetrialDetailQuery> pageQuery) {
    @Transactional
    public SearchResultVO<List<SafeMaterialDetailDto>> listByPage(ContextCacheUser currentUser,PageQuery<SafeMatetrialDetailQuery> pageQuery) {
        SafeMaterialDetailDBQuery dbQuery = new SafeMaterialDetailDBQuery();
        if(null != pageQuery.getSearchParams()){
            BeanUtils.copyProperties(pageQuery.getSearchParams(),dbQuery);
            dbQuery.setDepId(currentUser.getDepId());
        }
        dbQuery.setDepId(currentUser.getDepId());
        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_MATERIALEXPIRED");
        try {
            lock.lock(10, TimeUnit.SECONDS);
            //执行无效物资过期
            this.materialExpired();
            //创建成功，释放锁
            lock.unlock();
        }catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(ResultCodes.SERVER_ERROR);
        }finally {
            if(lock.isLocked()){
                lock.unlock();
            }
        }
        Page<SafeMaterialDetailInfo> page = new Page(pageQuery.getPageIndex(),pageQuery.getPageSize());
        List<SafeMaterialDetailInfoDO> safeMaterialDetailInfoDOS = safeMaterialDetailInfoService.listByPage(page, pageQuery.getSearchParams());
        List<SafeMaterialDetailInfoDO> safeMaterialDetailInfoDOS = safeMaterialDetailInfoService.listByPage(page, dbQuery);
        List<SafeMaterialDetailDto> detailDtoList = new ArrayList<>();
        for(SafeMaterialDetailInfoDO materialDetailInfoDO : safeMaterialDetailInfoDOS){
            SafeMaterialDetailDto materialDetailDto = new SafeMaterialDetailDto();
@@ -539,11 +807,53 @@
            materialDetailDto.setValidStatusName(ValidStatusEnum.getByCode(materialDetailInfoDO.getValidStatus()).getValue());
            materialDetailDto.setValidTypeName(ValidTypeEnum.getByCode(materialDetailInfoDO.getValidType()).getValue());
            materialDetailDto.setIrStatusName(IssueReceiptEnum.getByCode(materialDetailInfoDO.getIrStatus()).getValue());
            materialDetailDto.setStatusName(MaterialStatusEnum.getByCode(materialDetailInfoDO.getStatus()).getValue());
            detailDtoList.add(materialDetailDto);
        }
        return new SearchResultVO<>(true, page.getCurrent(),page.getSize(), page.getPages(),page.getTotal(),detailDtoList,ResultCodes.OK);
    }

    private void materialExpired(){
        //获取所有物资管理
        List<SafeMaterialInfo> list = safeMaterialInfoService.list();
        //获取在库有效物资
        List<SafeMaterialDetailInfo> unValidList = safeMaterialDetailInfoService.getUnValidList();
        if(unValidList.size()>0){
            List<SafeMaterialBO> safeMaterialBOList = new ArrayList<>();
            List<SafeMaterialDetailInfo> updateValidStatusList = new ArrayList<>();
            for(SafeMaterialInfo safeMaterialInfo:list){
                //过滤出该管理下过期物资
                List<SafeMaterialDetailInfo> expiredList = unValidList.stream().filter(item -> item.getSmId().equals(safeMaterialInfo.getId())).collect(Collectors.toList());
                if(expiredList.size()>0){
                    //过滤非出库无效物资
                    List<SafeMaterialDetailInfo> expiredAndInLibraryList = expiredList.stream().filter(item -> item.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode())).collect(Collectors.toList());
                    if(expiredAndInLibraryList.size()>0){
                        //物资管理
                        SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
                        safeMaterialBO.setId(safeMaterialInfo.getId());
                        safeMaterialBO.setStockCount(-expiredAndInLibraryList.size());
                        safeMaterialBOList.add(safeMaterialBO);
                    }
                    //物资清单
                    for(SafeMaterialDetailInfo detailInfo:expiredList){
                        SafeMaterialDetailInfo safeMaterialDetailInfo = new SafeMaterialDetailInfo();
                        safeMaterialDetailInfo.setId(detailInfo.getId());
                        safeMaterialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
                        if(detailInfo.getStatus().equals(MaterialStatusEnum.INTACT.getCode())){
                            safeMaterialDetailInfo.setStatus(MaterialStatusEnum.OVERDUE.getCode());
                            safeMaterialDetailInfo.setRemark(MaterialStatusEnum.OVERDUE.getValue());
                        }
                        updateValidStatusList.add(safeMaterialDetailInfo);
                    }
                }
            }
            if(safeMaterialBOList.size()>0){
                safeMaterialInfoService.updateStockCount(safeMaterialBOList);
            }
            if(updateValidStatusList.size()>0){
                safeMaterialDetailInfoService.updateBatchById(updateValidStatusList);
            }
        }
    }
    @Override
    public ResultVO queryById(Long id) {
        if(null == id){
@@ -552,18 +862,19 @@
        SafeMaterialDetailInfo materialDetailInfo = safeMaterialDetailInfoService.queryById(id);
        SafeMaterialDetailDto detailDto = new SafeMaterialDetailDto();
        if(materialDetailInfo != null){
            SafeMaterialInfo materialInfo = safeMaterialInfoService.queryById(materialDetailInfo.getSmId());
            SafeMaterialDO safeMaterialDO = safeMaterialInfoService.queryById(materialDetailInfo.getSmId());
            SafeMaterialClassifyInfo classifyInfo = safeMaterialClassifyInfoService.queryById(materialDetailInfo.getBigClassifyId());
            BeanUtils.copyProperties(materialDetailInfo,detailDto);
            detailDto.setConsumableName(ConsumableEnum.getByCode(materialDetailInfo.getConsumable()).getValue());
            detailDto.setValidStatusName(ValidStatusEnum.getByCode(materialDetailInfo.getValidStatus()).getValue());
            detailDto.setValidTypeName(ValidTypeEnum.getByCode(materialDetailInfo.getValidType()).getValue());
            detailDto.setIrStatusName(IssueReceiptEnum.getByCode(materialDetailInfo.getIrStatus()).getValue());
            if(materialInfo != null){
              detailDto.setDepName(materialInfo.getDepName());
            detailDto.setStatusName(MaterialStatusEnum.getByCode(materialDetailInfo.getStatus()).getValue());
            if(safeMaterialDO != null){
              detailDto.setDepName(safeMaterialDO.getDepName());
            }
            if(classifyInfo != null){
                detailDto.setMaterialClassifyName(classifyInfo.getMaterialClassifyName());
                detailDto.setBigClassifyName(classifyInfo.getMaterialClassifyName());
            }

        }
@@ -576,7 +887,11 @@
     * @return
     */
    @Override
    public ResultVO singleDelivery(SafeMaterialDetailReq req) {
    @Transactional
    public void singleDelivery(ContextCacheUser currentUser,SafeMaterialDetailReq req) {
        if(null == req.getReceiveUid()){
            throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"领取人不可为空！");
        }
        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_SINGLEDELIVERY");
        try {
@@ -593,15 +908,68 @@
                throw new EquipmentException(EquipmentResultCodes.MATERIAL_OUT_OF_LIBRARY);
            }
            //检查认领人
            UserInfoRPCRespDTO userInfo = getUserInfo(req.getClaimantId());
            UserInfoRPCRespDTO userInfo = getUserInfo(req.getReceiveUid());
            //详细物资
            SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
            materialDetailInfo.setId(req.getId());
            materialDetailInfo.setIrStatus(IssueReceiptEnum.OUT_OF_LIBRARY.getCode());
            materialDetailInfo.setClaimantId(req.getClaimantId());
            materialDetailInfo.setClaimantName(userInfo.getUsername());
            materialDetailInfo.setReceiveUid(req.getReceiveUid());
            materialDetailInfo.setReceiveUname(userInfo.getUsername());
            materialDetailInfo.setDeliveryTime(LocalDateTime.now());

            //物资管理库存数量
            SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
            safeMaterialBO.setId(vo.getSmId());
            safeMaterialBO.setStockCount(-1);
            //出库记录
            MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
            receiveRecordsBaseInfo.setId(IdUtil.getSnowflake(0,0).nextId());
            receiveRecordsBaseInfo.setMaterialName(vo.getName());
            receiveRecordsBaseInfo.setReceiveCount(1);
            receiveRecordsBaseInfo.setRevertCount(0);
            receiveRecordsBaseInfo.setConsumeCount(0);
            receiveRecordsBaseInfo.setReceiveUid(userInfo.getUid());
            receiveRecordsBaseInfo.setReceiveUname(userInfo.getUsername());
            receiveRecordsBaseInfo.setSmId(vo.getSmId());
            //出库物资记录
            MaterialReceiveRecordsInfo receiveRecordsInfo = new MaterialReceiveRecordsInfo();
            receiveRecordsInfo.setId(IdUtil.getSnowflake(0,0).nextId());
            receiveRecordsInfo.setMaterialName(vo.getName());
            receiveRecordsInfo.setMaterialNo(vo.getMaterialNo());
            receiveRecordsInfo.setRfid(vo.getRfid());
            receiveRecordsInfo.setReceiveTime(LocalDateTime.now());
            receiveRecordsInfo.setReceiveUid(userInfo.getUid());
            receiveRecordsInfo.setReceiveUname(userInfo.getUsername());
            receiveRecordsInfo.setReceiveBaseId(receiveRecordsBaseInfo.getId());
            receiveRecordsInfo.setSmdId(vo.getId());

            if(vo.getConsumable().equals(ConsumableEnum.YES.getCode())){
                //耗材
                materialDetailInfo.setValidStatus(ValidStatusEnum.NO.getCode());
                materialDetailInfo.setStatus(MaterialStatusEnum.OTHER.getCode());
                materialDetailInfo.setRemark("耗材");
                receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.CONSUMABLE_RETURN_NO.getCode());
                receiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.DEPLETION.getCode());
                receiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.OTHER.getCode());
                receiveRecordsInfo.setRemark("耗材");
            }else{
                //默认未归还
                receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_NO.getCode());
                receiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_NO.getCode());
                receiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
                receiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
            }

            //修改出入库状态为出库
            safeMaterialDetailInfoService.updateById(materialDetailInfo);
            //修改物资管理库存
            safeMaterialInfoService.updateCountById(safeMaterialBO);
            //物资领取总记录
            materialReceiveRecordsBaseInfoService.save(receiveRecordsBaseInfo);
            //物资详细清单
            materialReceiveRecordsInfoService.save(receiveRecordsInfo);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
@@ -613,7 +981,6 @@
                lock.unlock();
            }
        }
        return new ResultVO<>(ResultCodes.OK);
    }

    /**
@@ -623,7 +990,8 @@
     */

    @Override
    public ResultVO singleReceipt(Long id) {
    @Transactional
    public void singleReceipt(Long id,ContextCacheUser currentUser) {
        if(null == id){
            throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
        }
@@ -634,7 +1002,7 @@
            //获取该条数据
            SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(id);
            if(null == vo){
                throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
                throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"未查询到该物资出库记录");
            }
            //如果是耗材不可重新入库
            if(vo.getConsumable().equals(ConsumableEnum.YES.getCode())){
@@ -643,8 +1011,60 @@
            if(vo.getIrStatus().equals(IssueReceiptEnum.IN_THE_LIBRARY.getCode())){
                throw new EquipmentException(EquipmentResultCodes.MATERIAL_IN_THE_LIBRARY);
            }
            //物资管理库存数量
            SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
            safeMaterialBO.setId(vo.getSmId());
            safeMaterialBO.setStockCount(1);

            //获取物资总记录数据
            MaterialDeliveryRecordDO deliveryRecordDO = materialReceiveRecordsInfoService.getRecordBySmdId(id);
            SafeMaterialDetailInfo safeMaterialDetailInfo = new SafeMaterialDetailInfo();
            safeMaterialDetailInfo.setId(vo.getId());
            safeMaterialDetailInfo.setIrStatus(IssueReceiptEnum.IN_THE_LIBRARY.getCode());
            safeMaterialDetailInfo.setWareHousingTime(LocalDateTime.now());
            if(null == deliveryRecordDO){
                //无领取记录
                if (vo.getValidStatus().equals(ValidStatusEnum.NO.getCode())) {//无效
                    if(vo.getStatus().equals(MaterialStatusEnum.OVERDUE.getCode())){//过期
                        safeMaterialBO.setStockCount(0);
                    }else{
                        //其他情况,重新入库则改成有效
                        safeMaterialDetailInfo.setValidStatus(ValidStatusEnum.YES.getCode());
                        safeMaterialDetailInfo.setStatus(MaterialStatusEnum.INTACT.getCode());
                        safeMaterialDetailInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                    }
                }

            }else{
                //有领取记录，则归还
                //获取未归还物资详细记录
                List<MaterialReceiveRecordsInfo> recordsInfos = materialReceiveRecordsInfoService.getNoReturnRecordByReceiveBaseId(deliveryRecordDO.getReceiveBaseId());
                //领取总记录填充
                MaterialReceiveRecordsBaseInfo receiveRecordsBaseInfo = new MaterialReceiveRecordsBaseInfo();
                receiveRecordsBaseInfo.setId(deliveryRecordDO.getReceiveBaseId());
                if(recordsInfos.size() > 1) {
                    receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_PART.getCode());
                }else {
                    receiveRecordsBaseInfo.setStatus(MaterialReceiveRecordsStatusEnum.RETURN_COMPLETE.getCode());
                }
                receiveRecordsBaseInfo.setRevertCount(deliveryRecordDO.getRevertCount()+1);
                materialReceiveRecordsBaseInfoService.updateById(receiveRecordsBaseInfo);
                //详细物资领取记录
                MaterialReceiveRecordsInfo receiveRecordsInfo = new MaterialReceiveRecordsInfo();
                receiveRecordsInfo.setId(deliveryRecordDO.getReceiveId());
                receiveRecordsInfo.setRevertStatus(MaterialRevertStatusEnum.REVERT_YES.getCode());
                receiveRecordsInfo.setRevertTime(LocalDateTime.now());
                receiveRecordsInfo.setMaterialStatus(MaterialStatusEnum.INTACT.getCode());
                receiveRecordsInfo.setRemark(MaterialStatusEnum.INTACT.getValue());
                materialReceiveRecordsInfoService.updateById(receiveRecordsInfo);
            }

            //修改出入库状态为入库
            safeMaterialDetailInfoService.updateReceiptStatus(id,IssueReceiptEnum.IN_THE_LIBRARY.getCode());
            safeMaterialDetailInfoService.updateById(safeMaterialDetailInfo);
            //修改物资管理库存
            safeMaterialInfoService.updateCountById(safeMaterialBO);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
@@ -656,62 +1076,8 @@
                lock.unlock();
            }
        }
        return new ResultVO<>(ResultCodes.OK);

    }

    @Override
    public ResultVO singleDdelivery0rReceipt(SafeMaterialDetailReq req) {
        if(null == IssueReceiptEnum.getByCode(req.getIrStatus())){
            throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"物资状态不合法");
        }

        //获取该条数据
        SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(req.getId());
        if(null == vo){
            throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
        }
        if(null == IssueReceiptEnum.getByCode(req.getIrStatus())){
            throw new EquipmentException(ResultCodes.CLIENT_PARAM_ILLEGAL,"出入库状态不合法");
        }

        if(IssueReceiptEnum.IN_THE_LIBRARY.getCode().equals(req.getIrStatus())){
            //如果是耗材不可重新入库
            if(vo.getConsumable().equals(ConsumableEnum.YES.getCode())){
                throw new EquipmentException(EquipmentResultCodes.MATERIAL_CONSUMABLE);
            }
            //重新入库
            if(vo.getIrStatus().equals(req.getIrStatus())){
                throw new EquipmentException(EquipmentResultCodes.MATERIAL_IN_THE_LIBRARY);
            }

            //修改出入库状态为入库
            safeMaterialDetailInfoService.updateReceiptStatus(req.getId(), req.getIrStatus());
        }else{
            //出库
            if(vo.getValidStatus().equals(ValidStatusEnum.NO.getCode())){
                throw new EquipmentException(EquipmentResultCodes.MATERIAL_INVALID,"无效物资不可出库");
            }
            if(vo.getIrStatus().equals(req.getIrStatus())){
                throw new EquipmentException(EquipmentResultCodes.MATERIAL_OUT_OF_LIBRARY);
            }
            if(null == req.getClaimantId()){
                throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL,"认领人不可为空！");
            }
            //检查认领人
            UserInfoRPCRespDTO userInfo = getUserInfo(req.getClaimantId());
            //出库
            SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
            materialDetailInfo.setId(req.getId());
            materialDetailInfo.setIrStatus(req.getIrStatus());
            materialDetailInfo.setClaimantId(req.getClaimantId());
            materialDetailInfo.setClaimantName(userInfo.getUsername());
            materialDetailInfo.setDeliveryTime(LocalDateTime.now());
            //修改出入库状态为入库
            safeMaterialDetailInfoService.updateById(materialDetailInfo);
        }
        return new ResultVO<>(ResultCodes.OK);
    }



    /**
@@ -719,21 +1085,55 @@
     * @param
     * @return
     */
    @Transactional
    @Override
    public ResultVO delete(Long id){
        if(null == id){
            throw new EquipmentException(ResultCodes.CLIENT_PARAM_NULL);
        }
        //获取该条数据
        SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(id);
        if(null == vo){
            throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
        }
        SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
        materialDetailInfo.setId(id);
        materialDetailInfo.setDelFlag(1);
        //删除一条数据
        safeMaterialDetailInfoService.updateById(materialDetailInfo);
        //加分布式锁，防止重复创建规则
        RLock lock = redissonClient.getLock("LOCK_SMD_DELETE");
        try {
            //获取该条数据
            SafeMaterialDetailInfo vo = safeMaterialDetailInfoService.queryById(id);
            if(null == vo){
                throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST);
            }
            if(vo.getIrStatus().equals(IssueReceiptEnum.OUT_OF_LIBRARY.getCode())){
                throw new EquipmentException(ResultCodes.SERVER_DEL_ERROR,"出库物资不可删除！");
            }
            SafeMaterialDetailInfo materialDetailInfo = new SafeMaterialDetailInfo();
            materialDetailInfo.setId(id);
            materialDetailInfo.setDelFlag(1);
            //物资管理库存数量
            SafeMaterialBO safeMaterialBO = new SafeMaterialBO();
            safeMaterialBO.setId(vo.getSmId());

            if(vo.getValidStatus().equals(ValidStatusEnum.YES.getCode())){
                //有效
                safeMaterialBO.setStockCount(-1);
                safeMaterialBO.setTotalCount(-1);
            }else{
                //无效
                safeMaterialBO.setTotalCount(-1);
            }
            //删除一条数据
            safeMaterialDetailInfoService.updateById(materialDetailInfo);
            //减少库存
            safeMaterialInfoService.updateCountById(safeMaterialBO);
            //创建成功，释放锁
            lock.unlock();
        }catch (EquipmentException e) {
            e.printStackTrace();
            throw new EquipmentException(e.getCode(), e.getMessage());
        }catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(ResultCodes.SERVER_ERROR);
        }finally {
            if(lock.isLocked()){
                lock.unlock();
            }
        }
        return new ResultVO<>(ResultCodes.OK);
    }

@@ -764,7 +1164,7 @@
            if (rpcResult.getData() != null) {
                userInfo = (UserInfoRPCRespDTO) rpcResult.getData();
            }else {
                throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"认领人员不存在！");
                throw new EquipmentException(EquipmentResultCodes.DATA_NOT_EXIST,"领取人员不存在！");
            }
        } else {
            throw new EquipmentException(ResultCodes.RPC_RESULT_NULL);
@@ -777,12 +1177,14 @@
            return null;
        }
        String serialCode = null;
        String prefix = "NO-";
        if(count >= 10000){
            serialCode = "" + (count+1);
        }else if(count >=0){
            String countStr = String.valueOf(count+1);
            serialCode = "10000".substring(0,(5 - countStr.length()))+countStr;
        }
        serialCode = prefix + serialCode;
        return serialCode;
    }
    private Date conversionTimeType(LocalDateTime localDateTime){