修改消息推送接口代码

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/req/InvExpireReq.java

+package com.junmp.jyzb.api.bean.req;
+
+import lombok.Data;
+
+/**
+ * 过质保期的数据汇总数据
+ */
+@Data
+public class InvExpireReq {
+
+    private String typeId;
+
+    private String typeName;
+
+    private String sizeId;
+
+    private String sizeName;
+
+    private Long orgId;
+
+    private String locationId;
+
+    private String locationName;
+
+    private Integer sumExpireNumber;
+
+    private String userId;
+
+}

jyzb-biz/src/main/java/com/junmp/jyzb/entity/Inventory.java

@@ -88,6 +88,12 @@ public class Inventory implements Serializable {
     private Long orgId;
 
     /**
+     * 组织机构名称
+     */
+    @TableField(exist = false)
+    private String orgName;
+
+    /**
      * 规格尺寸
      */
     private String state;

jyzb-biz/src/main/java/com/junmp/jyzb/mapper/InventoryMapper.java

@@ -8,6 +8,7 @@ import com.junmp.jyzb.api.bean.dto.EqsSumDto;
 import com.junmp.jyzb.api.bean.dto.InventoryDto;
 import com.junmp.jyzb.api.bean.query.InventoryReq;
 import com.junmp.jyzb.api.bean.req.BatchEditingInvsReq;
+import com.junmp.jyzb.api.bean.req.InvExpireReq;
 import com.junmp.jyzb.api.bean.vo.InventoryVo;
 import com.junmp.jyzb.entity.Inventory;
 import com.junmp.jyzb.entity.InventorySummary;
@@ -67,4 +68,9 @@ public interface InventoryMapper extends BaseMapper<Inventory> {
 
     //根据epc获取装备信息
     List<InventoryDto> GetInvInfoByEpc(@Param("list") List<String> epcList);
+
+    //通过组织机构id获取组织机构下的userIdlist
+    List<InvExpireReq> selectUserListByOrgs(@Param("list") List<Long> uniqueOrgIDsList);
+
+    List<Inventory> searchExpireEqs(@Param("list") List<Object[]> searchItem);
 }
\ No newline at end of file

jyzb-biz/src/main/java/com/junmp/jyzb/service/impl/OrderMainServiceImpl.java

@@ -857,181 +857,8 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
     }
 
 
-    //快速生成入库单
-    @Override
-    public boolean addQuickOrder(OrderMain existOrder) {
-        //创建新的orderMain入库单
-        OrderMain orderMain = new OrderMain();
-        BeanPlusUtil.copyProperties(existOrder,orderMain);
-        orderMain.setEndOrgId(existOrder.getStartOrgId());
-        orderMain.setEndOrgName(existOrder.getStartOrgName());
-        orderMain.setOrderType("in");
-        orderMain.setId(UUID.randomUUID().toString());
-        //工作流流程设为空
-        orderMain.setProcessId(null);
-        //修改订单编号，设置为入库的单号
-        UpdateOrderReq req = new UpdateOrderReq();
-        BeanPlusUtil.copyProperties(orderMain,req);
-        OrderNum orderNum = setOrderCode(req);
-        String codeValue=String.format("%04d",orderNum.getNum());
-        orderMain.setOrderCode(orderNum.getBussinessType()+orderNum.getYear()+
-                String.format("%02d",LocalDateTime.now().getMonth().getValue())+
-                String.format("%02d",LocalDateTime.now().getDayOfMonth())+codeValue);
-        //保存入库单
-        save(orderMain);
-        //查询出库子单用于赋值到入库单中
-        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
-                .eq(OrderDetail::getOrderId, existOrder.getId()));
-        //查询条件，将所有查询条件放在searchCriteria中，用于修改库存表中的装备的仓库位置
-        //原来出库单的查询条件list（根据条件查询库存汇总表中包含有相同条件的数据）
-        List<Object[]> searchCriteria=new ArrayList<>();
-        //新建的入库单查询条件list（根据条件查询库存汇总表中是否包含有相同条件的数据）
-        List<Object[]> updateCriteria=new ArrayList<>();
-        //仓库id
-        String locationId = orderMain.getLocationId();
-        //创建入库单子单
-        List<OrderDetail> collect = list.stream().map(orderDetail -> {
-            OrderDetail orderDetail1 = new OrderDetail();
-            BeanPlusUtil.copyProperties(orderDetail, orderDetail1);
-            //修改主单据id
-            orderDetail1.setOrderId(orderMain.getId());
-            //修改单据出入状态
-            orderDetail1.setType("in");
-            //修改仓库id
-            orderDetail1.setWarehouseId(locationId);
-            orderDetail1.setWarehouseName(orderMain.getLocationName());
-            Object[] criteria=new Object[]{existOrder.getStartOrgId(),orderDetail.getWarehouseId(),orderDetail.getTypeId(),orderDetail.getSizeId(),orderDetail.getPrice()};
-            searchCriteria.add(criteria);
-            Object[] update=new Object[]{orderMain.getEndOrgId(),locationId,orderDetail1.getTypeId(),orderDetail1.getSizeId(),orderDetail1.getPrice()};
-            updateCriteria.add(update);
-            return orderDetail1;
-        }).collect(Collectors.toList());
-        orderDetailService.saveBatch(collect);
-
-
-        //将summary汇总表中数据进行修改(修改该组织机构下的装备汇总信息将库存信息的在库数，库存总数，总价还有其他数据数量进行修改)
-        //那么首先将原来的仓库下的装备汇总信息进行查询出来，对其进行修改
-        List<InventorySummary> oldSummaryList = inventorySummaryService.selectSumByItems(searchCriteria);
-        //其次查询出修改后的仓库下面的汇总信息，判断该仓库下是否已经存在该号型、类型、单价相同的装备数据
-        List<InventorySummary> newSummaryList = inventorySummaryService.selectSumByItems(updateCriteria);
 
-        //创建删除列表用于将没用的数据汇总信息进行删除
-        List<InventorySummary> deleteList=new ArrayList<>();
-        for (OrderDetail orderDetail: list ) {
-            for (InventorySummary oldSum:oldSummaryList) {
-                //如果组织机构、仓库id、sizeId、typeId、unitPrice相同，那么修改其各项数值（不会存在两个列表长度不对等的情况，一定是一对一的，只不过是顺序问题，所以需要进行遍历）
-                //需要判断传递的计划数量是否和在库数相等，如果相等表示将报废区数的数量也一起移库，否则表示报废区的数量
-                if (orderDetail.getSizeId().equals(oldSum.getSizeId())
-                        && orderDetail.getTypeId().equals(oldSum.getTypeId())
-                        && orderDetail.getPrice().compareTo(oldSum.getUnitPrice())==0 ){
-                    //直接修改各项数据，并且判断库存总数是否为0，如果为0 ，判断其他数据是否为0，只有当所有数据为0才能将这条信息进行删除，否则装备数据会不准确（销毁数量）
-                    oldSum.setNumber(oldSum.getNumber()-orderDetail.getPlanNum());
-                    oldSum.setPrice(oldSum.getPrice().subtract(orderDetail.getPrice().multiply(BigDecimal.valueOf(orderDetail.getPlanNum()))));
-                    oldSum.setStockNumber(oldSum.getStockNumber()-orderDetail.getPlanNum());
-
-                    //如果存在删减数量完成之后所有的数量值都是0的情况，那么将这一条数据进行删除操作
-                    if (oldSum.getStockNumber()==0 && oldSum.getNumber()==0 && oldSum.getOutboundNumber()==0
-                            && oldSum.getBrokenNumber()==0 && oldSum.getDestructionNumber()!=0 ){
-                        deleteList.add(oldSum);
-                    }
-                    break;//查询到直接跳过该循环进入下一循环
-                }
-
-            }
-            for (InventorySummary oldSum:oldSummaryList) {
-                if (orderDetail.getSizeId().equals(oldSum.getSizeId())
-                        && orderDetail.getTypeId().equals(oldSum.getTypeId())
-                        && orderDetail.getPrice().compareTo(oldSum.getUnitPrice())==0 ){
-                    //直接修改各项数据，并且判断库存总数是否为0，如果为0 ，判断其他数据是否为0，只有当所有数据为0才能将这条信息进行删除，否则装备数据会不准确（销毁数量）
-                    oldSum.setNumber(oldSum.getNumber()-orderDetail.getPlanNum());
-                    oldSum.setPrice(oldSum.getPrice().subtract(orderDetail.getPrice().multiply(BigDecimal.valueOf(orderDetail.getPlanNum()))));
-                    oldSum.setStockNumber(oldSum.getStockNumber()-orderDetail.getPlanNum());
-                    //如果存在删减数量完成之后所有的数量值都是0的情况，那么将这一条数据进行删除操作
-                    if (oldSum.getStockNumber()==0 && oldSum.getNumber()==0 && oldSum.getOutboundNumber()==0
-                            && oldSum.getBrokenNumber()==0 && oldSum.getDestructionNumber()!=0 ){
-                        deleteList.add(oldSum);
-                    }
-                    break;//查询到直接跳过该循环进入下一循环
-                }
-                break;
-            }
-
-
-        }
-
-
-        // 如果存在那么只需要修改在库数，出库数，库存总数和单价；
-        // 如果不存在那么新增一条该型号，类型和单价的数据，并且对在库数，出库数，库存总数和单价进行赋值添加；
-        //判断查询的汇总表中是否存在数据，如果list为空，那么直接进行新增即可，如果不为空，那么需要遍历哪些满足条件，如果满足条件只需要进行修改更新，如果未找到那么则进行新增
-        //查询组织机构编码
-        String orgCode = pubOrgService.PubOrgExist(orderMain.getEndOrgId()).getOrgCode();
-        //新建list用于存放新的汇总数据
-        List<InventorySummary> newList=new ArrayList<>();
-        if (newSummaryList.size()==0){
-            for (OrderDetail orderDetail1:collect) {
-                InventorySummary newSummary = addNewSum(orderMain, orderDetail1, orgCode);
-                newList.add(newSummary);
-            }
-        }else {
-            //遍历两个list，判断是否存在，如果不存在，那么将新增数据放在newList中最后进行批量新增，如果存在，那么修改数据，还是放在newSummaryList中，之后同老的数据一起进行修改
-            for (OrderDetail orderDetail1:collect) {
-                boolean flag=false;
-                for (InventorySummary newSum:newSummaryList) {
-                    if (orderDetail1.getSizeId().equals(newSum.getSizeId())
-                            && orderDetail1.getTypeId().equals(newSum.getTypeId())
-                            && orderDetail1.getPrice().compareTo(newSum.getUnitPrice())==0){
-                        newSum.setNumber(newSum.getNumber()-orderDetail1.getPlanNum());
-                        newSum.setPrice(newSum.getPrice().subtract(orderDetail1.getPrice().multiply(BigDecimal.valueOf(orderDetail1.getPlanNum()))));
-                        newSum.setStockNumber(newSum.getStockNumber()-orderDetail1.getPlanNum());
-                        //过质保数？临近质保？报废数？
-
-                        flag=true;
-                        break;
-                    }
-                }
-                if (!flag){
-                    //新增一条数据并且返回
-                    InventorySummary newSummary = addNewSum(orderMain, orderDetail1, orgCode);
-                    newList.add(newSummary);
-                }
-            }
-        }
-        //保存新的inventorySummary数据
-        //如果newList不为空则save
-        boolean a=true;
-        if(newList.size()>0){
-            a=inventorySummaryService.saveBatch(newList);
-        }
-        //如果删除list不为空，那么进行批量删除
-        boolean b=true;
-        if (deleteList.size()>0){
-            b=inventorySummaryService.removeBatchByIds(deleteList);
-        }
-        //将orderSum和newSum两个列表进行拼接，最终得到一个更新的list进行更新
-        List<InventorySummary> totalSumList=new ArrayList<>();
-        totalSumList.addAll(oldSummaryList);
-        totalSumList.addAll(newSummaryList);
-        boolean c =inventorySummaryService.updateBatchById(totalSumList);
-
-        //将库存表inventory中的装备的仓库id进行修改
-        List<Inventory> eqsList = inventoryService.selectEqsByItem(searchCriteria);
-        for (Inventory inventory : eqsList) {
-            for (OrderDetail detail2 : collect) {
-                if (inventory.getOrgId().equals(existOrder.getStartOrgId())
-                        && inventory.getSizeId().equals(detail2.getSizeId())
-                        && inventory.getTypeId().equals(detail2.getTypeId())
-                        && inventory.getPrice().equals(detail2.getPrice())) {
-                    // 修改 仓库id
-                    inventory.setLocationId(detail2.getWarehouseId());
-                    break; // 找到匹配的对象后跳出内循环
-                }
-            }
-        }
-        boolean d=inventoryService.updateBatchById(eqsList);
-        return (a && b && c && d);
-    }
-
-    public boolean addQuickOrder1(OrderMain existOrder) {
+    public boolean addQuickOrder(OrderMain existOrder) {
         //创建新的orderMain入库单
         OrderMain orderMain = new OrderMain();
         BeanPlusUtil.copyProperties(existOrder,orderMain);
@@ -1235,26 +1062,7 @@ public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain
         return true;
     }
 
-    //新增一条inventorysummary数据
-    public InventorySummary addNewSum(OrderMain orderMain,OrderDetail orderDetail1,String orgCode){
-        InventorySummary newSummary = new InventorySummary();
-        newSummary.setOrgId(orderMain.getEndOrgId());
-        newSummary.setOrgName(orderMain.getEndOrgName());
-        newSummary.setOrgCode(orgCode);
-        newSummary.setTypeId(orderDetail1.getTypeId());
-        newSummary.setTypeName(orderDetail1.getTypeName());
-        newSummary.setSizeId(orderDetail1.getSizeId());
-        newSummary.setSizeName(orderDetail1.getSizeName());
-        newSummary.setLocationId(orderMain.getLocationId());
-        newSummary.setLocationName(orderMain.getLocationName());
-        newSummary.setLocationType("0");
-        newSummary.setNumber(orderDetail1.getPlanNum());
-        newSummary.setPrice(orderDetail1.getPrice().multiply(BigDecimal.valueOf(orderDetail1.getPlanNum())));
-        newSummary.setUnitPrice(orderDetail1.getPrice());
-        newSummary.setStockNumber(orderDetail1.getPlanNum());
-        newSummary.setCreateTime(DateTimeUtil.getCurrentDateTime());
-        return newSummary;
-    }
+
 
 
 

jyzb-biz/src/main/java/com/junmp/jyzb/task/InvExpireMsg.java

@@ -5,12 +5,14 @@ import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.junmp.jyzb.api.bean.req.InvExpireReq;
 import com.junmp.jyzb.api.util.GenCodeUtil;
 import com.junmp.jyzb.entity.Company;
 import com.junmp.jyzb.entity.Inventory;
 import com.junmp.jyzb.entity.InventorySummary;
 import com.junmp.jyzb.entity.ProductSku;
 import com.junmp.jyzb.mapper.ExpireMapper;
+import com.junmp.jyzb.mapper.InventoryMapper;
 import com.junmp.jyzb.mapper.MsgMapper;
 import com.junmp.jyzb.service.InventoryService;
 import com.junmp.v2.common.util.BeanPlusUtil;
@@ -26,10 +28,7 @@ import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
 import java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 
 /**
@@ -48,6 +47,9 @@ public class InvExpireMsg implements JobAction {
     private InventoryService inventoryService;
 
     @Resource
+    private InventoryMapper inventoryMapper;
+
+    @Resource
     private MessageApi messageApi;
 
     @Resource
@@ -60,65 +62,99 @@ public class InvExpireMsg implements JobAction {
         int pageSize = 1000; // 每页记录数，可以根据需求调整
         int currentPage = 1; // 当前页数
 
-        //所有待判断的物资
-        wrapper.eq( Inventory::getTermState, 0);
-
+        //所有待判断的物资(只获取仓库下的过质保期数量)
+        //除去销毁出库数
+        wrapper.eq(Inventory::getTermState, 0);
+        wrapper.ne(Inventory::getState,"destory");
         //获取未超期的物资数量
         long termCount= inventoryService.count(wrapper);
         List<Inventory> list=new ArrayList<>();
         if (termCount>0) {
             // 分页查询
             while ((currentPage - 1) * pageSize < termCount) {
-                List<Inventory> inventoryList = processPageData(currentPage, pageSize);
+                int startPageSize=(currentPage - 1) * pageSize ;
+                List<Inventory> inventoryList = processPageData(startPageSize, pageSize);
                 currentPage++;
                 list.addAll(inventoryList);
             }
         }
         //超期物资查询出来之后，将超期物资进行消息推送提醒
         //直接对list进行处理操作推送消息即可
-        for (Inventory inventory:list) {
-            MessageSendReq sendReq = new MessageSendReq();
-            sendReq.setSendUserId("1000");
-            sendReq.setReceiveUserIds("1000");
-            sendReq.setMsgTitle("物资过质保期");
-            //设置业务类型
-            SysDictItem one = sysDictItemService.getOne(new LambdaQueryWrapper<SysDictItem>()
-                    .eq(SysDictItem::getDictItemId, "expire"));
-            sendReq.setBizType(one.getItemValue());
-            sendReq.setMsgContent("仓库下的装备的物资已经过质保期");
-            sendReq.setPriority("0");
-            sendReq.setSendTime(DateTime.now());
-            messageApi.sendMessage(sendReq);
+        //需要对该所有超期物资进行分组
+        List<InvExpireReq> invExpireReqList=new ArrayList<>();
+        List<Long> orgIdsList=new ArrayList<>();
+        for (Inventory inventory : list) {
+            if (invExpireReqList.size()==0){
+                InvExpireReq invExpireReq = new InvExpireReq();
+                BeanPlusUtil.copyProperties(inventory,invExpireReq);
+                invExpireReq.setSumExpireNumber(1);
+                invExpireReqList.add(invExpireReq);
+                orgIdsList.add(inventory.getOrgId());
+                continue;
+            }
+            boolean found = false;
+            for (InvExpireReq groupedSum : invExpireReqList) {
+                if (groupedSum.getOrgId().equals(inventory.getOrgId()) && groupedSum.getLocationId().equals(inventory.getLocationId())
+                        && groupedSum.getSizeId().equals(inventory.getSizeId()) && groupedSum.getTypeId().equals(inventory.getTypeId())) {
+                    groupedSum.setSumExpireNumber(groupedSum.getSumExpireNumber()+1);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                InvExpireReq invExpireReq = new InvExpireReq();
+                BeanPlusUtil.copyProperties(inventory,invExpireReq);
+                invExpireReq.setSumExpireNumber(1);
+                invExpireReqList.add(invExpireReq);
+                orgIdsList.add(inventory.getOrgId());
+            }
         }
-        messageApi.queryCount(new MessageReq());
+        //根据分好组的数据查询出所有的需要被提醒的组织机构id，并且查询出组织机构下的仓管员信息，并且将消息进行推送
+        //再将汇总list进行遍历获取不重复的组织机构
+        Set<Long> uniqueOrgIDs = new HashSet<>(orgIdsList);
+        List<Long> uniqueOrgIDsList = new ArrayList<>(uniqueOrgIDs);
+        //查询组织机构下面的所有仓管员的useId
+        List<InvExpireReq> userIdsList=inventoryMapper.selectUserListByOrgs(uniqueOrgIDsList);
+
+        //获取到之后，将该条信息进行消息推送
+        for (InvExpireReq invExpireReq:invExpireReqList ) {
+            for (InvExpireReq userIds:userIdsList) {
+                if (invExpireReq.getOrgId()==userIds.getOrgId()){
+                    MessageSendReq sendReq = new MessageSendReq();
+                    sendReq.setReceiveUserIds(userIds.getUserId());
+                    sendReq.setMsgTitle("过质保期提醒");
+                    sendReq.setBizType("过质保提醒");
+                    sendReq.setMsgContent(invExpireReq.getLocationName()+"下的"+invExpireReq.getTypeName()+
+                            invExpireReq.getSizeName()+"装备已经过质保期,数量为"+invExpireReq.getSumExpireNumber());
+                    sendReq.setPriority("0");
+                    sendReq.setSendTime(DateTime.now());
+                    messageApi.sendMessage(sendReq);
+                }
+            }
+        }
+
         /*推送发送未读数量*/
-        List<Long> userIdList=new ArrayList<>();
-        userIdList.add(1000L);
-        for(Long userId :userIdList){
+        for(InvExpireReq userIds:userIdsList){
             MessageReq req1 = new MessageReq();
             req1.setReadFlag(0);
-            req1.setReceiveUserId(userId);
+            req1.setReceiveUserId(Long.parseLong(userIds.getUserId()));
             Integer count1 = messageApi.queryCount(req1);
-            messageApi.pushMsgToUser(String.valueOf(userId),count1);
+            messageApi.pushMsgToUser(userIds.getUserId(),count1);
         }
     }
 
     // 处理每页数据
-    private List<Inventory> processPageData(long pageSize, long currentPage)
+    private List<Inventory> processPageData(long startPageSize, long currentPage)
     {
-        LocalDate localdate =LocalDate.now();
-        // 使用LambdaQueryWrapper构建查询条件
-        LambdaQueryWrapper<Inventory> wrapper = Wrappers.lambdaQuery();
-        wrapper.eq( Inventory::getTermState, 0);
-        //如果 生产日期 < 当前日期减去质保数,表示该装备已经超过质保期
-        wrapper.apply("production_date <= DATE_SUB({0}, INTERVAL warranty_period DAY)", localdate);
-        //获取过质保期的物资信息
-        List<Inventory> page= inventoryService.page(PageFactory.getDefaultPage(pageSize,currentPage),wrapper).getRecords();
-        page.forEach(o->o.setTermState(1));
-        inventoryService.saveOrUpdateBatch(page);
-        return page;
-
-//        Page<Inventory> page = inventoryService.page(PageFactory.getDefaultPage(), wrapper)
+        List<Object[]> searchItem =new ArrayList<>();
+        Object[] criteria=new Object[]{0,"destory",startPageSize,currentPage};
+        searchItem.add(criteria);
+        List<Inventory> list = inventoryMapper.searchExpireEqs(searchItem);
+        list.forEach(o->o.setTermState(1));
+        inventoryService.saveOrUpdateBatch(list);
+        return list;
+
+
     }
 
 

jyzb-biz/src/main/java/com/junmp/jyzb/task/InvOverDueMsg.java

@@ -2,7 +2,9 @@ package com.junmp.jyzb.task;
 
 import cn.hutool.core.date.DateTime;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.junmp.jyzb.api.bean.req.InvExpireReq;
 import com.junmp.jyzb.entity.OrderMain;
+import com.junmp.jyzb.mapper.InventoryMapper;
 import com.junmp.jyzb.service.OrderMainService;
 import com.junmp.jyzb.utils.DateTimeUtil;
 import com.junmp.v2.db.api.factory.PageFactory;
@@ -16,9 +18,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 
 /**
  * @author lxh
@@ -37,14 +37,17 @@ public class InvOverDueMsg implements JobAction {
     private MessageApi messageApi;
 
     @Resource
+    private InventoryMapper inventoryMapper;
+
+    @Resource
     private SysDictItemService sysDictItemService;
 
     @Override
     public void action() {
         //获取超期物资
-        //先查询出 出入库单据为借用单的数据
+        //先查询出 出入库单据为领用单的数据
         LambdaQueryWrapper<OrderMain> wrapper = new LambdaQueryWrapper<OrderMain>()
-                .eq(OrderMain::getBussinessType, "borrow")
+                .eq(OrderMain::getBussinessType, "use")
                 .eq(OrderMain::getOrderType,"out");
         int pageSize =1000;
         int currentPage=1;
@@ -59,32 +62,41 @@ public class InvOverDueMsg implements JobAction {
             }
         }
         //将消息进行推送
+        //我需要将orgId进行查询并去重
+        Set<Long> uniqueOrgIDs = new HashSet<>();
         for (OrderMain orderMain:list) {
-            MessageSendReq sendReq = new MessageSendReq();
-            sendReq.setSendUserId("1000");
-            //接收用户id先写死，后面再修改
-            sendReq.setReceiveUserIds("1000");
-            sendReq.setMsgTitle("物资超期");
-            //设置业务类型
-            SysDictItem one = sysDictItemService.getOne(new LambdaQueryWrapper<SysDictItem>()
-                    .eq(SysDictItem::getDictItemId, "over_due"));
-            sendReq.setBizType(one.getItemValue());
-            sendReq.setMsgContent("单据id为："+orderMain.getId()+"的物资超期，请及时查看提醒");
-            sendReq.setPriority("0");
-            sendReq.setSendTime(DateTime.now());
-            messageApi.sendMessage(sendReq);
+            uniqueOrgIDs.add(orderMain.getStartOrgId());
         }
-        messageApi.queryCount(new MessageReq());
+        List<Long> uniqueOrgIDsList = new ArrayList<>(uniqueOrgIDs);
+        //查询组织机构下面的所有仓管员的useId
+        List<InvExpireReq> userIdsList=inventoryMapper.selectUserListByOrgs(uniqueOrgIDsList);
+
+        for (OrderMain orderMain:list) {
+            for (InvExpireReq userIds:userIdsList) {
+                if (orderMain.getStartOrgId()==userIds.getOrgId()){
+                    MessageSendReq sendReq = new MessageSendReq();
+                    sendReq.setReceiveUserIds(userIds.getUserId());
+                    sendReq.setMsgTitle("物资超期提醒");
+                    sendReq.setBizType("超期提醒");
+                    //设置业务类型
+//                    SysDictItem one = sysDictItemService.getOne(new LambdaQueryWrapper<SysDictItem>()
+//                            .eq(SysDictItem::getDictItemId, "over_due"));
+//                    sendReq.setBizType(one.getItemValue());
+                    sendReq.setMsgContent("单据id为："+orderMain.getId()+"的领用单已超期，请及时查看处理");
+                    sendReq.setPriority("0");
+                    sendReq.setSendTime(DateTime.now());
+                    messageApi.sendMessage(sendReq);
+                }
+            }
+        }
+
         /*推送发送未读数量*/
-        //添加需要将消息推送的userid，先写死，可以查询数据库表动态设置userid；
-        List<Long> userIdList=new ArrayList<>();
-        userIdList.add(1000L);
-        for(Long userId :userIdList){
+        for(InvExpireReq userIds:userIdsList){
             MessageReq req1 = new MessageReq();
             req1.setReadFlag(0);
-            req1.setReceiveUserId(userId);
+            req1.setReceiveUserId(Long.parseLong(userIds.getUserId()));
             Integer count1 = messageApi.queryCount(req1);
-            messageApi.pushMsgToUser(String.valueOf(userId),count1);
+            messageApi.pushMsgToUser(userIds.getUserId(),count1);
         }
 
     }
@@ -94,9 +106,10 @@ public class InvOverDueMsg implements JobAction {
         //获取对应的借用单据数据
         Date currentDateTime = DateTimeUtil.getCurrentDateTime();
         LambdaQueryWrapper<OrderMain> wrapper = new LambdaQueryWrapper<OrderMain>()
-                .eq(OrderMain::getBussinessType, "borrow")
+                .eq(OrderMain::getBussinessType, "use")
                 .eq(OrderMain::getOrderType,"out")
-                .lt(OrderMain::getReturnDate,currentDateTime);
+                .lt(OrderMain::getReturnDate,currentDateTime)
+                .isNotNull(OrderMain::getReturnDate);
         List<OrderMain> records = orderMainService.page(PageFactory.getDefaultPage(pageSize, currentPage),wrapper).getRecords();
         return records;
     }

jyzb-biz/src/main/resources/mapper/InventoryMapper.xml

@@ -500,6 +500,50 @@
             #{item}
         </foreach>
     </select>
+    <select id="selectUserListByOrgs" resultType="com.junmp.jyzb.api.bean.req.InvExpireReq">
+        select suo.user_id,suo.org_id FROM sys_user_org suo
+           JOIN sys_user_role sur ON suo.user_id=sur.user_id
+           JOIN sys_role sr ON sur.role_id=sr.role_id and sr.role_id="1528003832557232130"
+        where suo.org_id in
+        <foreach collection="list" item="item" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </select>
+    <select id="searchExpireEqs" resultType="com.junmp.jyzb.entity.Inventory">
+
+        SELECT
+        bi.size_id AS size_id,
+        bes.name AS size_name,
+        bi.type_id,
+        bet.name AS type_name,
+        bi.org_id_int AS org_id,
+        COALESCE(bcb.cabinet_id, bw.id) AS location_id,
+        COALESCE(MAX(bc.name), MAX(bw.name)) AS location_name
+        FROM
+        base_inventory bi
+        JOIN base_equipment_size bes ON bi.size_id = bes.id
+        JOIN base_equipment_type bet ON bi.type_id = bet.id
+        LEFT JOIN base_cabinet_box bcb ON bi.location_id = bcb.id AND bi.location_type = 1
+        LEFT JOIN base_cabinet bc ON bcb.cabinet_id = bc.id
+        LEFT JOIN base_warehouse bw ON bi.location_id = bw.id AND bi.location_type = 0
+        WHERE
+        bi.warranty_period != 0
+        AND DATE_ADD(bi.production_date, INTERVAL bi.warranty_period MONTH) > NOW()
+        <foreach collection="list" item="item" open="(" separator="," close=")">
+            AND bi.term_state = ${item[0]}
+            AND bi.state != '${item[1]}'
+        </foreach>
+        GROUP BY
+        bi.size_id,
+        bes.name,
+        bi.type_id,
+        bet.name,
+        bi.org_id_int,
+        COALESCE(bcb.cabinet_id, bw.id)
+        <foreach collection="list" item="item" open="(" separator="," close=")">
+            limit ${item[2]},${item[3]}
+        </foreach>
+    </select>
 
 
 </mapper>
\ No newline at end of file