修改前端bug和测试bug，添加单据（跟出入库单据不同，用于移交，借用等的单子）

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/InventoryReq.java

@@ -51,7 +51,7 @@ public class InventoryReq extends BaseRequest {
     /**
      * 部门ID
      */
-    private long departmentId;
+    private Long departmentId;
     /**
      * 货架位置
      */
@@ -111,7 +111,7 @@ public class InventoryReq extends BaseRequest {
     /**
      * 质保期
      */
-    private long warrantyPeriod;
+    private Integer warrantyPeriod;
 
     /**
      * 维保期
@@ -138,7 +138,7 @@ public class InventoryReq extends BaseRequest {
     /**
      * 是否遗失
      */
-    private int lostFlag ;
+    private Integer lostFlag ;
     /**
      * 价格
      */

jyzb-api/src/main/java/com/junmp/jyzb/api/bean/query/OrderUploadReq.java

 package com.junmp.jyzb.api.bean.query;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.junmp.v2.common.bean.request.BaseRequest;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -25,6 +26,10 @@ public class OrderUploadReq extends BaseRequest {
      */
     private String orderState;
     /**
+     * 计划数量
+     */
+    private Integer inventoryQuantity;
+    /**
      * 实际数量
      */
     private Integer actualQuantity;
@@ -44,16 +49,36 @@ public class OrderUploadReq extends BaseRequest {
          */
         private Long detailId;
         /**
-         * 实际数量
+         * 应入库数量(计划数量)
          */
-        private Integer actualNum;
+        private Integer planNum;
         /**
-         * 价格
+         * 实际数量
          */
-        private BigDecimal price;
+        private Integer actualNum;
         /**
          * 订单状态 ready待入/出库，working入/出库中，finished已完成
          */
         private String orderType;
+
+        /**
+         * 物资类型id
+         */
+        private String typeId;
+
+        /**
+         * 物资类型名称
+         */
+        private String typeName;
+
+        /**
+         * 物资号型id
+         */
+        private Long sizeId;
+
+        /**
+         * 物资号型名称
+         */
+        private String sizeName;
     }
 }

jyzb-api/src/main/java/com/junmp/jyzb/api/exception/enums/OrderExceptionEnum.java

@@ -8,7 +8,11 @@ import lombok.Getter;
 public enum OrderExceptionEnum implements IExceptionEnum {
     ORDER_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE,"单据不存在"),
     ERROR_COMMOAND(CommonConstant.DEFAULT_USER_ERROR_CODE,"操作有误，无法既删除又修改"),
-    ORDER_CAN_NOT_UPDATE(CommonConstant.DEFAULT_USER_ERROR_CODE,"进行中的单据或已完成的单据无法修改");
+    ORDER_CAN_NOT_UPDATE(CommonConstant.DEFAULT_USER_ERROR_CODE,"进行中的单据或已完成的单据无法修改"),
+    ORDERDETAIL_ISNOT_NULL(CommonConstant.DEFAULT_USER_ERROR_CODE,"记账子单据不能为空"),
+    ORDERDETAIL_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE,"子单据不存在"),
+    ;
+
     /**
      * 错误编码
      */

jyzb-biz/src/main/java/com/junmp/jyzb/config/rabbitMQ/RabbitmqConfig.java

 //package com.junmp.jyzb.config.rabbitMQ;
 //
 //import com.junmp.jyzb.api.bean.dto.OrderDto;
-//import com.junmp.jyzb.service.OrderService;
+//import com.junmp.jyzb.service.OrderMainService;
 //import org.springframework.amqp.core.*;
 //import org.springframework.beans.factory.annotation.Qualifier;
 //import org.springframework.context.annotation.Bean;
@@ -14,7 +14,7 @@
 //@Configuration
 //public class RabbitmqConfig {
 //    @Resource
-//    private OrderService orderService;
+//    private OrderMainService orderMainService;
 //
 //    //1.交换机
 //    @Bean("LogExchange")
@@ -43,7 +43,7 @@
 //    @Bean
 //    public List<Queue> OrderQueue(){
 //        List<Queue> queues =new ArrayList<>();
-//        List<OrderDto> orderList = orderService.getOrder();
+//        List<OrderDto> orderList = orderMainService.getOrder();
 //        for (OrderDto orderDto:orderList) {
 //            queues.add(new Queue(orderDto.getEndOrgName()));
 //        }
@@ -54,7 +54,7 @@
 //    @Bean
 //    public List<Binding> bindQueueExchange(List<Queue> queue, DirectExchange exchange){
 //        List<Binding> bindings=new ArrayList<>();
-//        List<OrderDto> orderList = orderService.getOrder();
+//        List<OrderDto> orderList = orderMainService.getOrder();
 //        for(int i=0;i<Math.min(queue.size(),orderList.size());i++){
 //            bindings.add(BindingBuilder.bind(queue.get(i)).to(exchange).with(orderList.get(i).getEndOrgId()));
 //        }

jyzb-biz/src/main/java/com/junmp/jyzb/controller/InventoryController.java

@@ -205,6 +205,4 @@ public class InventoryController {
     public ApiRes<PageResult<InventoryDto>> GetDetailByTerms(@RequestBody @Validated(ValidationApi.export.class) InventoryReq req){
         return ApiRes.success(inventoryService.GetDetailByTerms(req));
     }
-
-
 }

jyzb-biz/src/main/java/com/junmp/jyzb/controller/OrderController.java

@@ -6,7 +6,7 @@ import com.junmp.jyzb.api.bean.dto.OrderMainDto;
 import com.junmp.jyzb.api.bean.query.OrderMainReq;
 import com.junmp.jyzb.api.bean.query.OrderUploadReq;
 import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
-import com.junmp.jyzb.service.OrderService;
+import com.junmp.jyzb.service.OrderMainService;
 import com.junmp.v2.common.bean.request.ValidationApi;
 import com.junmp.v2.common.bean.response.ApiRes;
 import com.junmp.v2.db.api.page.PageResult;
@@ -20,6 +20,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import javax.annotation.Resource;
+import java.util.List;
 
 @RestController
 @Slf4j
@@ -27,12 +28,12 @@ import javax.annotation.Resource;
 @Api(tags = "业务模块")
 public class OrderController {
     @Resource
-    public OrderService orderService;
+    public OrderMainService orderMainService;
 
     //通过工作流进行操作处理的
     @PostMapping("/AddOrder")
     @ApiOperation("新增任务单")
-    public ApiRes<String> addOrder(@RequestBody UpdateOrderReq req) {
+    public ApiRes<List<String>> addOrder(@RequestBody UpdateOrderReq req) {
         //判断是否有工作流id，如果有则将状态进行修改
         if (ObjectUtil.isEmpty(req.getProcessId()))
         {
@@ -42,9 +43,14 @@ public class OrderController {
         {
             req.setExamineState("working");
         }
-        return ApiRes.success(orderService.AddOrder(req));
+        return ApiRes.success(orderMainService.AddOrder(req));
     }
 
+    //装备移交
+    @PostMapping("/EquipmentHandover")
+    @ApiOperation("/装备移交")
+    public ApiRes<String>
+
 
 
     //内部处理，任务单状态直接设置成finished 添加到数据并且直接推送到消息队列中去
@@ -52,7 +58,7 @@ public class OrderController {
     @ApiOperation("新增已完成的任务单")
     public ApiRes<String> AddFinishOrder(@RequestBody UpdateOrderReq req)  {
         req.setExamineState("finished");
-        return ApiRes.success(orderService.AddFinishOrder(req));
+        return ApiRes.success(orderMainService.AddFinishOrder(req));
     }
 
 
@@ -60,39 +66,39 @@ public class OrderController {
     @PostMapping("/UpdateOrder")
     @ApiOperation("修改任务单")
     public ApiRes<Boolean>  updateOrder(@RequestBody @Validated(ValidationApi.edit.class) UpdateOrderReq req) {
-        return ApiRes.success(orderService.updateOrder(req));
+        return ApiRes.success(orderMainService.updateOrder(req));
     }
 
     //查询任务列表(根据组织机构id)
     @PostMapping("/GetOrderPage")
     @ApiOperation("/查询任务列表")
     public ApiRes<PageResult<OrderMainDto>> getOrderPage(@RequestBody @Validated(ValidationApi.add.class)OrderMainReq req ){
-        return ApiRes.success(orderService.getOrderPage(req));
+        return ApiRes.success(orderMainService.getOrderPage(req));
     }
 
     @PostMapping("/GetDetailById")
     @ApiOperation("根据任务单id查看业务明细")
     public ApiRes<OrderDto> GetDetailById(@RequestBody @Validated(ValidationApi.detail.class) OrderMainReq req){
-        return ApiRes.success(orderService.GetDetailById(req));
+        return ApiRes.success(orderMainService.GetDetailById(req));
     }
 
     @PostMapping("/PushState")
     @ApiOperation("单据状态上报")
     public ApiRes<Boolean> PushState(@RequestBody @Validated(ValidationApi.delete.class) OrderUploadReq req){
-        return ApiRes.success(orderService.PushState(req));
+        return ApiRes.success(orderMainService.PushState(req));
     }
 
     @PostMapping("/Accounting")
     @ApiOperation("记账")
     public ApiRes<Boolean> Accounting(@RequestBody @Validated(ValidationApi.delete.class) OrderUploadReq req){
-        return ApiRes.success(orderService.Accounting(req));
+        return ApiRes.success(orderMainService.Accounting(req));
     }
 
 //    //将工作单添加到rabbitmq中去
 //    @PostMapping("/AddOrderRabbitMq")
 //    @ApiOperation("将工作单添加到rabbitmq消息队列中去")
 //    public ApiRes<Boolean> AddOrderRabbitMq(){
-//        List<OrderDto> order = orderService.getOrder();
+//        List<OrderDto> order = orderMainService.getOrder();
 //        List<String> orderId=new ArrayList<>();
 //        for (OrderDto orderDto:order) {
 //            //将routingKey设置为收物机构id

jyzb-biz/src/main/java/com/junmp/jyzb/controller/ToOutController.java

@@ -28,4 +28,5 @@ public class ToOutController {
         return ApiRes.success(policeEquipmentService.AddBorrowEqs(req));
     }
     //警员领用装备后在数据库中增加相关领用装备数据
+
 }

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

+package com.junmp.jyzb.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import java.io.Serializable;
+import java.util.Date;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 
+ * @TableName bussiness_order
+ */
+@TableName(value ="bussiness_order")
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Order implements Serializable {
+    /**
+     * 单子id
+     */
+    @TableId(value = "id",type = IdType.ASSIGN_UUID)
+    private String id;
+
+    /**
+     * 号型id
+     */
+    @TableField("size_id")
+    private String sizeId;
+
+    /**
+     * 号型名称
+     */
+    @TableField("size_name")
+    private String sizeName;
+
+    /**
+     * 类别id
+     */
+    @TableField("type_id")
+    private String typeId;
+
+    /**
+     * 类别名称
+     */
+    @TableField("size_name")
+    private String typeName;
+
+    /**
+     * 申请时间
+     */
+    @TableField("apply_time")
+    private Date applyTime;
+
+    /**
+     * 申请人
+     */
+    @TableField("applicant_id")
+    private String applicantId;
+
+    /**
+     * 接收人
+     */
+    @TableField("recipient_id")
+    private String recipientId;
+
+    /**
+     * 申请理由
+     */
+    @TableField("apply_reason")
+    private String applyReason;
+
+    /**
+     * 仓库id
+     */
+    @TableField("location_id")
+    private String locationId;
+
+    /**
+     * 申请人组织机构id
+     */
+    @TableField("org_id")
+    private Long orgId;
+
+    /**
+     * 创世时间
+     */
+    @TableField("create_time")
+    private Date createTime;
+
+    /**
+     * 更新时间
+     */
+    @TableField("update_time")
+    private Date updateTime;
+
+    /**
+     * 创建人员
+     */
+    @TableField("create_user")
+    private String createUser;
+
+    /**
+     * 更新人员
+     */
+    @TableField("update_user")
+    private String updateUser;
+
+
+    private static final long serialVersionUID = 1L;
+
+
+}
\ No newline at end of file

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

@@ -14,6 +14,7 @@ import java.util.Date;
 @NoArgsConstructor
 @TableName("bussiness_order_main")
 public class OrderMain implements Serializable {
+
     private String id;
 
     @TableField("order_type")
@@ -72,7 +73,7 @@ public class OrderMain implements Serializable {
     private Integer manualState;
 
     @TableField("order_state")
-    private Integer orderState;
+    private String orderState;
 
     @TableField("attachment_location")
     private String attachmentLocation;
@@ -80,8 +81,8 @@ public class OrderMain implements Serializable {
     @TableField("inv_list")
     private String invList;
 
-    @TableField("return_data")
-    private Date returnData;
+    @TableField("return_date")
+    private Date returnDate;
 
     @TableField("use_date")
     private Date useDate;

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

@@ -44,7 +44,7 @@ public class PoliceEquipment implements Serializable {
     private String sizeName;
 
     /**
-     *装备类型id
+     * 装备类型id
      */
     @TableField("type_id")
     private String typeId;
@@ -56,18 +56,6 @@ public class PoliceEquipment implements Serializable {
     private String typeName;
 
     /**
-     *供应商id
-     */
-    @TableField("supplier_id")
-    private String supplierId;
-
-    /**
-     *供应商名称
-     */
-    @TableField("supplier_name")
-    private String supplierName;
-
-    /**
      * 装备数量
      */
     @TableField("num")

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

@@ -51,7 +51,6 @@ public class Policeman implements Serializable {
     private String doorCode;
 
     @TableField(value = "password",updateStrategy  = FieldStrategy.IGNORED)
-
     private String password;
 
     @TableField(value = "photo")

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

+package com.junmp.jyzb.mapper;
+
+import com.junmp.jyzb.entity.Order;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+* @author lxh专属坐骑
+* @description 针对表【bussiness_order】的数据库操作Mapper
+* @createDate 2023-09-08 16:28:58
+* @Entity com.junmp.jyzb.entity.Order
+*/
+public interface OrderMapper extends BaseMapper<Order> {
+
+}
+
+
+
+

jyzb-biz/src/main/java/com/junmp/jyzb/rabbitmq/OrderMQSender.java

 package com.junmp.jyzb.rabbitmq;
 
-import com.junmp.jyzb.api.bean.dto.OrderDto;
-import com.junmp.jyzb.service.OrderService;
+import com.junmp.jyzb.service.OrderMainService;
 import org.springframework.amqp.rabbit.core.RabbitTemplate;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
-import java.util.List;
 
 //将工作单上传到rabbitmq中
 @Component
@@ -14,7 +12,7 @@ public class OrderMQSender {
     @Resource
     private RabbitTemplate rabbitTemplate;
     @Resource
-    private OrderService orderService;
+    private OrderMainService orderMainService;
 
     public void send(){
         //将审核状态为finished的任务单放入rabbitmq中

jyzb-biz/src/main/java/com/junmp/jyzb/service/OrderMainService.java

+package com.junmp.jyzb.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.junmp.jyzb.api.bean.dto.OrderDto;
+import com.junmp.jyzb.api.bean.dto.OrderMainDto;
+import com.junmp.jyzb.api.bean.query.OrderMainReq;
+import com.junmp.jyzb.api.bean.query.OrderUploadReq;
+import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
+import com.junmp.jyzb.entity.OrderMain;
+import com.junmp.v2.db.api.page.PageResult;
+
+import java.util.List;
+import java.util.Map;
+
+public interface OrderMainService extends IService<OrderMain> {
+    List<String> AddOrder(UpdateOrderReq req);
+    String AddFinishOrder(UpdateOrderReq req);
+
+    //更新任务单
+    Boolean updateOrder(UpdateOrderReq req);
+
+
+    //判断任务单是否存在
+    OrderMain orderMainExist(String id);
+
+
+    //查询任务列表(根据组织机构id)
+    PageResult<OrderMainDto> getOrderPage(OrderMainReq req);
+
+    //根据任务单id查看业务明细
+    OrderDto GetDetailById(OrderMainReq req);
+
+    //设置page的pageNo和pageSize的通用方法
+    Map<String,Long> getPage(Long no,Long size);
+
+    //单据状态上报
+    boolean PushState(OrderUploadReq req);
+
+    //记账
+    boolean Accounting(OrderUploadReq req);
+}

jyzb-biz/src/main/java/com/junmp/jyzb/service/OrderService.java

 package com.junmp.jyzb.service;
 
+import com.junmp.jyzb.entity.Order;
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.junmp.jyzb.api.bean.dto.OrderDto;
-import com.junmp.jyzb.api.bean.dto.OrderMainDto;
-import com.junmp.jyzb.api.bean.query.OrderMainReq;
-import com.junmp.jyzb.api.bean.query.OrderUploadReq;
-import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
-import com.junmp.jyzb.entity.OrderMain;
-import com.junmp.v2.db.api.page.PageResult;
-import java.util.Map;
 
-public interface OrderService extends IService<OrderMain> {
-    String AddOrder(UpdateOrderReq req);
-    String AddFinishOrder(UpdateOrderReq req);
+/**
+* @author lxh专属坐骑
+* @description 针对表【base_order】的数据库操作Service
+* @createDate 2023-09-08 16:28:58
+*/
+public interface OrderService extends IService<Order> {
 
-    //更新任务单
-    Boolean updateOrder(UpdateOrderReq req);
-
-
-    //判断任务单是否存在
-    OrderMain orderMainExist(String id);
-
-
-    //查询任务列表(根据组织机构id)
-    PageResult<OrderMainDto> getOrderPage(OrderMainReq req);
-
-    //根据任务单id查看业务明细
-    OrderDto GetDetailById(OrderMainReq req);
-
-    //设置page的pageNo和pageSize的通用方法
-    Map<String,Long> getPage(Long no,Long size);
-
-    //单据状态上报
-    boolean PushState(OrderUploadReq req);
-
-    //记账
-    boolean Accounting(OrderUploadReq req);
 }

jyzb-biz/src/main/java/com/junmp/jyzb/service/SysuserService.java

-package com.junmp.jyzb.service;
-
-import com.baomidou.mybatisplus.extension.service.IService;
-import com.junmp.jyzb.entity.User;
-
-
-public interface SysuserService extends IService<User> {
-}

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

@@ -13,7 +13,6 @@ import com.junmp.jyzb.api.bean.req.UpdateCabinetReq;
 import com.junmp.jyzb.entity.*;
 import com.junmp.jyzb.api.exception.enums.CabinetExceptionEnum;
 import com.junmp.jyzb.api.exception.enums.PolicemanExceptionEnum;
-import com.junmp.jyzb.api.exception.enums.PubOrgExceptionEnum;
 import com.junmp.jyzb.mapper.*;
 import com.junmp.jyzb.service.*;
 import com.junmp.jyzb.utils.*;
@@ -46,7 +45,7 @@ public class CabinetServiceImpl extends ServiceImpl<CabinetMapper, Cabinet> impl
     private PolicemanService policemanService;
 
     @Resource
-    private OrderService orderService;
+    private OrderMainService orderMainService;
 
 
     private List<Long> getAllOrgId(CabinetReq req, String includeLowerLevel) {
@@ -234,7 +233,8 @@ public class CabinetServiceImpl extends ServiceImpl<CabinetMapper, Cabinet> impl
             CabinetDto cabinetDto = new CabinetDto();
             BeanPlusUtil.copyProperties(cabinet,cabinetDto);
             List<CabinetBox> list1 = cabinetBoxService.list(new LambdaQueryWrapper<CabinetBox>()
-                    .eq(CabinetBox::getCabinetId, cabinet.getId()));
+                    .eq(CabinetBox::getCabinetId, cabinet.getId())
+                    .orderByAsc(CabinetBox::getNum));
             List<CabinetBoxDto> cabinetBoxList=new ArrayList<>();
             for (CabinetBox cabinetBox:list1) {
                 CabinetBoxDto cabinetBoxDto = new CabinetBoxDto();

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

@@ -57,7 +57,14 @@ public class EquipmentTypeServiceImpl extends ServiceImpl<EquipmentTypeMapper, E
         list.forEach(p->{
             EquipmentTypeDto org=new EquipmentTypeDto();
             BeanPlusUtil.copyProperties(p, org);
-
+            //查询数据库中是否有他的下级，如果没有表示它就是叶子节点，返回true，否则返回false；
+            List<EquipmentType> list1 = list(new LambdaQueryWrapper<EquipmentType>()
+                    .eq(EquipmentType::getParentId, p.getId()));
+            if (list1.size()==0){
+                org.setIsLeaf(true);
+            }else {
+                org.setIsLeaf(false);
+            }
             orgs.add(org);
         });
         return orgs;
@@ -78,6 +85,12 @@ public class EquipmentTypeServiceImpl extends ServiceImpl<EquipmentTypeMapper, E
             int newcode = parentType.getMaxCode() + 1;
             type.setId(String.valueOf(newcode));
             type.setCode(String.valueOf(newcode));
+
+            //创建下级需要对下级的maxcode进行设置(生成三位随机数进行拼接)
+            Integer random = (int) ((Math.random() * 900) + 100);
+            String maxcode = random+"1000";
+            type.setMaxCode(Integer.valueOf(maxcode));
+
             parentType.setMaxCode(newcode);
             parentType.setCode(String.valueOf(newcode));
             List<SupplierType> supplierType = new ArrayList<>();

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

@@ -16,7 +16,6 @@ import com.junmp.jyzb.api.exception.enums.CabinetExceptionEnum;
 import com.junmp.jyzb.api.exception.enums.InventoryExceptionEnum;
 import com.junmp.jyzb.entity.*;
 
-import com.junmp.jyzb.mapper.InventorySummaryMapper;
 import com.junmp.jyzb.service.*;
 import com.junmp.v2.common.exception.base.ServiceException;
 import com.junmp.v2.common.util.BeanPlusUtil;
@@ -77,7 +76,7 @@ public class InventoryServiceImpl extends ServiceImpl<InventoryMapper, Inventory
     private OfficeExcelApi officeExcelApi;
 
     @Resource
-    private OrderService orderService;
+    private OrderMainService orderMainService;
 
     @Resource
     private InventorySummaryService inventorySummaryService;
@@ -316,12 +315,13 @@ public class InventoryServiceImpl extends ServiceImpl<InventoryMapper, Inventory
         LambdaQueryWrapper<Inventory> eq = new LambdaQueryWrapper<Inventory>()
                 .eq(Inventory::getOrgId, req.getOrgId())
                 .eq(Inventory::getLocationType, 0)
-                .eq(ObjectUtil.isNotNull(req.getLocationId()), Inventory::getLocationId, req.getLocationId())
-                .eq(ObjectUtil.isNotNull(req.getLocationState()), Inventory::getLocationState, req.getLocationState())
-                .eq(ObjectUtil.isNotNull(req.getBussinessState()), Inventory::getBussinessState, req.getBussinessState())
+                .eq(ObjectUtil.isNotNull(req.getLocationId()) && !req.getLocationId().trim().isEmpty(), Inventory::getLocationId, req.getLocationId())
+                .eq(ObjectUtil.isNotNull(req.getLocationState()) && !req.getLocationState().trim().isEmpty(), Inventory::getLocationState, req.getLocationState())
+                .eq(ObjectUtil.isNotNull(req.getBussinessState()) && !req.getBussinessState().trim().isEmpty(), Inventory::getBussinessState, req.getBussinessState())
                 .eq(ObjectUtil.isNotNull(req.getTermState()), Inventory::getTermState, req.getTermState())
-                .eq(ObjectUtil.isNotNull(req.getSizeId()),Inventory::getSizeId,req.getSizeId())
-                .eq(ObjectUtil.isNotNull(req.getTypeId()),Inventory::getTypeId,req.getTypeId());
+                .eq(ObjectUtil.isNotNull(req.getSizeId()) && !req.getSizeId().trim().isEmpty(),Inventory::getSizeId,req.getSizeId())
+                .eq(ObjectUtil.isNotNull(req.getTypeId()) && !req.getTypeId().trim().isEmpty(),Inventory::getTypeId,req.getTypeId());
+
         long size = list(eq).size();
         Page<Inventory> page = page(PageFactory.getDefaultPage(req.getPageNo(), req.getPageSize()), eq);
         List<Inventory> records = page.getRecords();
@@ -473,7 +473,7 @@ public class InventoryServiceImpl extends ServiceImpl<InventoryMapper, Inventory
     @Override
     public PageResult<InventorySummary> EqsByCabinetBoxIdPage(CabinetBoxReq req) {
         cabinetBoxService.CabinetBoxExist(req.getId());
-        Map<String, Long> map = orderService.getPage(req.getPageNo(), req.getPageSize());
+        Map<String, Long> map = orderMainService.getPage(req.getPageNo(), req.getPageSize());
         Long pageNo = map.get("pageNo");
         Long pageSize = map.get("pageSize");
         Page<InventorySummary> page=new Page<>(pageNo,pageSize);

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

@@ -5,14 +5,12 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.junmp.jyzb.api.bean.query.InventorySumReq;
-import com.junmp.jyzb.api.exception.enums.CabinetExceptionEnum;
 import com.junmp.jyzb.entity.Inventory;
 import com.junmp.jyzb.entity.InventorySummary;
 import com.junmp.jyzb.service.InventoryService;
 import com.junmp.jyzb.service.InventorySummaryService;
-import com.junmp.jyzb.service.OrderService;
+import com.junmp.jyzb.service.OrderMainService;
 import com.junmp.jyzb.service.PubOrgService;
-import com.junmp.v2.common.exception.base.ServiceException;
 import com.junmp.v2.db.api.factory.PageFactory;
 import com.junmp.v2.db.api.factory.PageResultFactory;
 import com.junmp.v2.db.api.page.PageResult;
@@ -20,9 +18,7 @@ import org.springframework.stereotype.Service;
 import com.junmp.jyzb.mapper.InventorySummaryMapper;
 
 import javax.annotation.Resource;
-import java.math.BigDecimal;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 @Service
@@ -32,7 +28,7 @@ public class InventorySummaryServiceImpl  extends ServiceImpl<InventorySummaryMa
     private PubOrgService pubOrgService;
 
     @Resource
-    private OrderService orderService;
+    private OrderMainService orderMainService;
 
     @Resource
     private InventoryService inventoryService;

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

@@ -2,19 +2,10 @@ package com.junmp.jyzb.service.impl;
 
 import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.junmp.jyzb.api.bean.query.QueryEquipmentSizeReq;
-import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
-import com.junmp.jyzb.api.exception.enums.OrderExceptionEnum;
 import com.junmp.jyzb.entity.*;
 import com.junmp.jyzb.mapper.OrderDetailMapper;
-import com.junmp.jyzb.mapper.OrderMainMapper;
 import com.junmp.jyzb.service.OrderDetailService;
-import com.junmp.jyzb.service.OrderService;
-import com.junmp.v2.common.exception.base.ServiceException;
-import com.junmp.v2.db.api.factory.PageFactory;
-import com.junmp.v2.db.api.factory.PageResultFactory;
 import org.springframework.stereotype.Service;
 
 import java.util.List;

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

+package com.junmp.jyzb.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.junmp.jyzb.api.bean.dto.OrderDetailDto;
+import com.junmp.jyzb.api.bean.dto.OrderDto;
+import com.junmp.jyzb.api.bean.dto.OrderMainDto;
+import com.junmp.jyzb.api.bean.query.OrderMainReq;
+import com.junmp.jyzb.api.bean.query.OrderUploadReq;
+import com.junmp.jyzb.api.bean.req.DetailListReq;
+import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
+import com.junmp.jyzb.api.exception.enums.CabinetExceptionEnum;
+import com.junmp.jyzb.api.exception.enums.OrderExceptionEnum;
+import com.junmp.jyzb.entity.*;
+import com.junmp.jyzb.mapper.OrderMainMapper;
+import com.junmp.jyzb.service.OrderDetailService;
+import com.junmp.jyzb.service.OrderNumService;
+import com.junmp.jyzb.service.OrderMainService;
+import com.junmp.jyzb.service.PubOrgService;
+import com.junmp.v2.common.exception.base.ServiceException;
+import com.junmp.v2.common.util.BeanPlusUtil;
+import com.junmp.v2.db.api.factory.PageFactory;
+import com.junmp.v2.db.api.factory.PageResultFactory;
+import com.junmp.v2.db.api.page.PageResult;
+import org.springframework.amqp.core.Queue;
+import org.springframework.amqp.rabbit.core.RabbitAdmin;
+import org.springframework.amqp.rabbit.core.RabbitTemplate;
+import org.springframework.amqp.core.*;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+@Service
+public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain> implements OrderMainService {
+
+    @Resource
+    private OrderDetailService orderDetailService;
+    @Resource
+    private RabbitTemplate rabbitTemplate;
+    @Resource
+    private RabbitAdmin rabbitAdmin;
+
+    @Resource
+    private OrderNumService orderNumService;
+
+    @Resource
+    private PubOrgService pubOrgService;
+
+
+
+    //新增任务单
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public List<String> AddOrder(UpdateOrderReq req) {
+        //存放主单据和子单据，便于返回
+        List<String> list=new ArrayList<>();
+        OrderMain order = new OrderMain();
+        BeanPlusUtil.copyProperties(req, order);
+        //设置单据单号（订单号）
+        OrderNum orderNum = setOrderCode(req);
+        String codeValue=String.format("%04d",orderNum.getNum());
+        order.setOrderCode(orderNum.getBussinessType()+"-"+orderNum.getOutInType()+"-"+orderNum.getYear()+"-"+codeValue);
+        //设置总价格和应出入库数量
+        //设置id
+        String id=UUID.randomUUID().toString();
+        order.setId(id);
+        Integer sumNum=0;
+        BigDecimal priceTotal=new BigDecimal(0);
+        List<OrderDetail> detailList = new ArrayList<>();
+        //通过遍历批量保存详细信息
+        for (DetailListReq listReq:req.getDetailList()) {
+            OrderDetail detail=new OrderDetail();
+            BeanPlusUtil.copyProperties(listReq, detail);
+            detail.setOrderId(order.getId());
+            //设置单据类型
+            detail.setType(order.getOrderType());
+            //将数量和价格进行累加
+            sumNum += detail.getPlanNum();
+            priceTotal = priceTotal.add(BigDecimal.valueOf(detail.getPlanNum()).multiply(detail.getPrice())) ;
+            detailList.add(detail);
+        }
+        orderDetailService.saveBatch(detailList);
+       //设置总价格和总数量
+        order.setPrice(priceTotal);
+        order.setInventoryQuantity(sumNum);
+        //保存
+        this.save(order);
+        list.add(order.getId());
+        for (OrderDetail orderDetail:detailList) {
+            list.add(Long.toString(orderDetail.getId()));
+        }
+        return list;
+    }
+
+
+    //设置单据单号（并且对order_num表进行新增或者更新）
+    public OrderNum setOrderCode(UpdateOrderReq req){
+        //设置采购单号，需要先判断该组织机构的采购单号是否存在，如果存在则将数量进行增加，如果不存在则新增一条对应的数据
+        OrderNum orderNum = new OrderNum();
+        //获取年份，获取业务出入状态，获取组织机构id，获取业务类型
+        orderNum.setYear(LocalDateTime.now().getYear());
+        //判断是出库还是入库，出库为发物单位，入库为收物单位
+        if (req.getOrderType().equals("in")){
+            orderNum.setOrgId(Long.valueOf(req.getEndOrgId()));
+        }else {
+            orderNum.setOrgId(Long.valueOf(req.getStartOrgId()));
+        }
+        //业务类型
+        orderNum.setBussinessType(req.getBussinessType());
+        //出入业务状态
+        orderNum.setOutInType(req.getOrderType());
+
+        OrderNum one = orderNumService.getOne(new LambdaQueryWrapper<OrderNum>()
+                .eq(OrderNum::getOrgId, orderNum.getOrgId())
+                .eq(OrderNum::getBussinessType, orderNum.getBussinessType())
+                .eq(OrderNum::getYear, orderNum.getYear())
+                .eq(OrderNum::getOutInType, orderNum.getOutInType()));
+        if (ObjectUtil.isNull(one)){
+            orderNum.setNum(1);
+            orderNumService.save(orderNum);
+            return orderNum;
+        }else {
+            one.setNum(one.getNum()+1);
+            orderNumService.updateById(one);
+            return one;
+        }
+
+    }
+
+
+    //新增默认审核通过的任务单
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public String AddFinishOrder(UpdateOrderReq req) {
+        //添加到数据库中
+        String orderId = AddOrder(req).get(0);
+        //将完成的任务单直接推送到消息队列rabbitmq中（需要判断是入库单还是出库单，入库单传发物单位id，出库单传收物单位id）
+        //方法1：一个交换机，一个队列。通过中间对象，object存储对象，type表标识
+//        if(req.getOrderType().equals("in")){
+//            rabbitTemplate.convertAndSend("OrderExchange","OrderRouting",new MessageWrapper(req,req.getStartOrgId()));
+//        }else {
+//            rabbitTemplate.convertAndSend("OrderExchange","OrderRouting",new MessageWrapper(req,req.getEndOrgId()));
+//        }
+        //方法2：一个交换机，多个队列。动态创建队列
+        String exchangeName="orderExchange";
+        //需要判断是入库单还是出库单，入库单传收物单位id，出库单传发物单位id
+        if(req.getOrderType().equals("in")){
+            Queue queue=new Queue(req.getEndOrgId(),true,false,false);
+            Exchange exchange = new DirectExchange(exchangeName, true, false);
+            rabbitAdmin.declareQueue(queue);
+            rabbitAdmin.declareExchange(exchange);
+            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(req.getEndOrgId()).noargs());
+            rabbitTemplate.convertAndSend(exchangeName, req.getEndOrgId(), req);
+
+        }else {
+            Queue queue = new Queue(req.getStartOrgId(), true, false, false);
+            Exchange exchange = new DirectExchange(exchangeName, true, false);
+            rabbitAdmin.declareQueue(queue);
+            rabbitAdmin.declareExchange(exchange);
+            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(req.getStartOrgId()).noargs());
+            rabbitTemplate.convertAndSend(exchangeName, req.getStartOrgId(), req);
+        }
+        return orderId;
+    }
+
+
+    //更新任务单（进入工作流中之后不能进行更改）
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public Boolean updateOrder(UpdateOrderReq req) {
+        OrderMain order = orderMainExist(req.getId());
+        if (!order.getExamineState().equals("none"))
+        {
+            throw new ServiceException(OrderExceptionEnum.ORDER_CAN_NOT_UPDATE);
+        }
+        List<OrderDetail> list= orderDetailService.QueryList(req.getId());
+        //idSet中存放的是存在数据库中的任务单中的orderDetail中的id（原始的工作单中的数据id）
+        Set<String> idSet =new HashSet<>();
+        for (OrderDetail orderDetail:list){
+            idSet.add(Long.toString(orderDetail.getId()));
+        }
+        //将该任务单的所有id转换为String,并添加到updateList中，用来判断删除或者修改新增的是否存在
+        //判断删除列表是否为空，如果不为空则进行批量删除
+        if (ObjectUtil.isNotNull(req.getDeleteList())&& ObjectUtil.isNotEmpty(req.getDeleteList())) {
+            //判断传递的list Id是否存在，如果不存在则抛出异常
+            for (String s:req.getDeleteList()){
+                if (idSet.contains(s)){
+                    //将要删除的装备价格和数据进行查询出来，并别对任务单的总数量和总价格进行更改
+                    OrderDetail one = orderDetailService.getOne(new LambdaQueryWrapper<OrderDetail>()
+                            .eq(OrderDetail::getOrderId, s));
+                    order.setPrice(order.getPrice().subtract(one.getPrice().multiply(BigDecimal.valueOf(one.getPlanNum()))));
+                    order.setInventoryQuantity(order.getInventoryQuantity() - one.getPlanNum());
+                    orderDetailService.removeBatchByIds(req.getDeleteList());
+                }else {
+                    throw new ServiceException(CabinetExceptionEnum.PARAMETER_ERROR);
+                }
+            }
+        }
+        //对detaillist进行处理
+        List<OrderDetail> addList = new ArrayList<>();//新增的
+        List<OrderDetail> updateList = new ArrayList<>();//更新
+        for (DetailListReq detailListReq :req.getDetailList()) {
+            //判断是否存在，存在则进行修改
+            if (idSet.contains(detailListReq.getId())){
+                OrderDetail one = orderDetailService.getOne(new LambdaQueryWrapper<OrderDetail>()
+                        .eq(OrderDetail::getId, detailListReq.getId()));
+                BeanPlusUtil.copyProperties(detailListReq,one);
+                one.setType(req.getOrderType());
+                //判断数量和价格是否有变动，如果有变动，则将order的总价和总数量进行更新操作，否则不变
+                if (one.getPlanNum().equals(detailListReq.getPlanNum()) && one.getPrice().compareTo(detailListReq.getPrice())!=0){
+                    order.setPrice(order.getPrice().subtract(one.getPrice().multiply(BigDecimal.valueOf(one.getPlanNum())))
+                            .add(detailListReq.getPrice().multiply(BigDecimal.valueOf(detailListReq.getPlanNum()))));
+                    order.setInventoryQuantity(order.getInventoryQuantity() - one.getPlanNum()+ detailListReq.getPlanNum());
+                }
+                updateList.add(one);
+            }else {
+                //否则判断id是否为空或者错误，如果为空则添加，不为空则抛出异常
+                if (ObjectUtil.isNull(detailListReq.getId()) || detailListReq.getId().equals("") || ObjectUtil.isEmpty(detailListReq.getId())){
+                    OrderDetail detail=new OrderDetail();
+                    BeanPlusUtil.copyProperties(detailListReq, detail);
+                    detail.setOrderId(req.getId());
+                    detail.setType(req.getOrderType());
+                    //将数量和价格进行相加处理
+                    order.setPrice(order.getPrice().add(detailListReq.getPrice().multiply(BigDecimal.valueOf(detailListReq.getPlanNum()))));
+                    order.setInventoryQuantity(order.getInventoryQuantity() + detailListReq.getPlanNum());
+                    addList.add(detail);
+                }else {
+                    throw new ServiceException(CabinetExceptionEnum.PARAMETER_ERROR);
+                }
+
+            }
+        }
+        orderDetailService.updateBatchById(updateList);
+        orderDetailService.saveBatch(addList);
+        BeanPlusUtil.copyProperties(req,order);
+        this.updateById(order);
+        return  true;
+    }
+    public boolean hasCommonElements(List<?> list1, List<?> list2) {
+        for (Object item1 : list1) {
+            if (list2.contains(item1)) {
+                return true; // 找到相同值
+            }
+        }
+        return false; // 没有相同值
+    }
+
+
+
+    //查询任务列表(根据组织机构id)
+    @Override
+    public PageResult<OrderMainDto> getOrderPage(OrderMainReq req) {
+        //判断组织机构是否存在
+        pubOrgService.PubOrgExist(req.getOrgId());
+        //判断是出库单还是入库单，选择的查询条件也不相同
+        Page<OrderMain> page=new Page<>();
+        LambdaQueryWrapper<OrderMain> wrapper = createWrapper(req);
+        if (req.getOrderType() != null && req.getOrderType().equals("in")){//入库单
+            LambdaQueryWrapper<OrderMain> eq = wrapper.eq(OrderMain::getOrderType, req.getOrderType())
+                    .eq(OrderMain::getEndOrgId, req.getOrgId());
+            page=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq);
+        } else if (req.getOrderType() != null && req.getOrderType().equals("out")) {//出库单
+            LambdaQueryWrapper<OrderMain> eq = wrapper.eq(OrderMain::getOrderType, req.getOrderType()).eq(OrderMain::getStartOrgId, req.getOrgId());
+            page=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq);
+        }else {//查询全部
+            Page<OrderMain> page1=new Page<>();
+            Page<OrderMain> page2=new Page<>();
+            LambdaQueryWrapper<OrderMain> eq1 = wrapper.eq(OrderMain::getEndOrgId, req.getOrgId());
+            page1=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq1);
+            LambdaQueryWrapper<OrderMain> eq2 = wrapper.eq(OrderMain::getStartOrgId, req.getOrgId());
+            page2=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq2);
+            List<OrderMain> list = new ArrayList<>();
+            list.addAll(page1.getRecords());
+            list.addAll(page2.getRecords());
+            page.setRecords(list);
+        }
+        List<OrderMainDto> orderMainDtoList=new ArrayList<>();
+        //遍历page,(如果出入库的组织机构为同一个的时候需要进行去重处理，不然会存在两条重复的数据)
+        for (OrderMain orderMain : page.getRecords()){
+            OrderMainDto orderMainDto = new OrderMainDto();
+            BeanPlusUtil.copyProperties(orderMain,orderMainDto);
+            if (!orderMainDtoList.contains(orderMainDto)){
+                orderMainDtoList.add(orderMainDto);
+            }
+        }
+        Page<OrderMainDto> page1 = PageFactory.getDefaultPage(req.getPageNo(), req.getPageSize());
+        page1.setTotal(orderMainDtoList.size());
+        page1.setRecords(orderMainDtoList);
+        return PageResultFactory.createPageResult(page1);
+    }
+
+    //根据任务单id查看业务明细
+    @Override
+    public OrderDto GetDetailById(OrderMainReq req) {
+        //判断任务单是否存在
+        OrderMain orderMain = orderMainExist(req.getId());
+        OrderDto orderDto = new OrderDto();
+        BeanPlusUtil.copyProperties(orderMain,orderDto);
+        //将详细信息存入列表属性中
+        //通过任务单id查询对应的详细信息
+        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
+                .eq(OrderDetail::getOrderId, req.getId()));
+        List<OrderDetailDto> orderDetailDtoList=new ArrayList<>();
+        for (OrderDetail orderDetail:list) {
+            OrderDetailDto orderDetailDto = new OrderDetailDto();
+            BeanPlusUtil.copyProperties(orderDetail,orderDetailDto);
+            orderDetailDtoList.add(orderDetailDto);
+        }
+        orderDto.setDetailList(orderDetailDtoList);
+        return orderDto;
+    }
+
+    //单据状态上报
+    @Override
+    public boolean PushState(OrderUploadReq req) {
+        OrderMain orderMain = orderMainExist(req.getId());
+        //获取单据的出入库，获取发物单位id或者收物单位id
+        String orderType = orderMain.getOrderType();
+        String exchangeName="OrderStateExchange";
+        //推送到rabbitmq中去
+        if (orderType.equals("in")){
+            Long endOrgId = orderMain.getEndOrgId();
+            Queue queue=new Queue(Long.toString(endOrgId),true,false,false);
+            Exchange exchange = new DirectExchange(exchangeName, true, false);
+            rabbitAdmin.declareQueue(queue);
+            rabbitAdmin.declareExchange(exchange);
+            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(Long.toString(endOrgId)).noargs());
+            rabbitTemplate.convertAndSend(exchangeName, Long.toString(endOrgId), req);
+
+        }else {
+            Long startOrgId = orderMain.getStartOrgId();
+            Queue queue = new Queue(Long.toString(startOrgId), true, false, false);
+            Exchange exchange = new DirectExchange(exchangeName, true, false);
+            rabbitAdmin.declareQueue(queue);
+            rabbitAdmin.declareExchange(exchange);
+            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(Long.toString(startOrgId)).noargs());
+            rabbitTemplate.convertAndSend(exchangeName, Long.toString(startOrgId), req);
+        }
+        return true;
+    }
+
+    //记账
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public boolean Accounting(OrderUploadReq req) {
+        //判断传递的订单主id是否存在
+        OrderMain orderMain = orderMainExist(req.getId());
+        //记账子单据不能传空
+        if (req.getChildrenOrder().size()==0){
+            throw new ServiceException(OrderExceptionEnum.ORDERDETAIL_ISNOT_NULL);
+        }
+        List<OrderUploadReq.OrderUploadDetailReq> childrenOrder = req.getChildrenOrder();
+        //并且记录到数据表order_log中
+        List<OrderLog> orderLogList=new ArrayList<>();
+        //将实际数量进行添加
+        Integer actualQuantity=0;
+        //记账直接将单子结束
+        orderMain.setOrderState("finished");
+        //判断传递的子单据id在数据库中是否存在，如果不存在则抛出子单据不存在异常
+        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
+                .in(OrderDetail::getId, childrenOrder));
+        Set<Long> existingIds = list.stream()
+                .map(OrderDetail::getId)
+                .collect(Collectors.toSet());
+        List<OrderUploadReq.OrderUploadDetailReq> missingList = new ArrayList<>();
+        for (OrderUploadReq.OrderUploadDetailReq uploadDetailReq : childrenOrder) {
+            if (!existingIds.contains(uploadDetailReq.getDetailId())) {
+                missingList.add(uploadDetailReq);
+            }
+            //遍历的时候记录每个子单据的实际数量,得到主单据的实际数量
+            actualQuantity+=uploadDetailReq.getActualNum();
+            //判断子单据实际数量和应入库数量是否相等,如果不相等记录下来并存于log表中
+            if (!uploadDetailReq.getActualNum().equals(uploadDetailReq.getPlanNum())){
+                OrderLog orderLog = new OrderLog();
+                orderLog.setOrderId(req.getId());
+                orderLog.setHistoryMsg("将"+uploadDetailReq.getOrderType()+"-"+
+                        uploadDetailReq.getSizeName()+"的物资数量修改为"+uploadDetailReq.getActualNum());
+                orderLogList.add(orderLog);
+            }
+        }
+        if (missingList.size()!=0){
+            throw new ServiceException(OrderExceptionEnum.ORDERDETAIL_NOT_EXIST);
+        }
+        //创建一个list用于存放修改的数据以便于进行批量操作
+
+        //批量更新子单据数量
+//        orderDetailService.updateBatchById();
+        orderMain.setActualQuantity(actualQuantity);
+        //更新主单据
+        return updateById(orderMain);
+    }
+
+
+    //判断任务单是否存在
+    @Override
+    public OrderMain orderMainExist(String id) {
+        OrderMain order = this.getById(id);
+        if (ObjectUtil.isNull(order)) {
+            throw new ServiceException(OrderExceptionEnum.ORDER_NOT_EXIST);
+        }
+        return order;
+    }
+
+    //设置pageNo和pageSize的通用方法
+    public Map<String,Long> getPage(Long no,Long size){
+        Map<String,Long> map=new HashMap<>();
+        long pageSize;
+        long pageNo;
+        if (ObjectUtil.isNull(no)){
+            pageNo = 1L;
+        }else {
+            pageNo= no;
+        }
+        if ( ObjectUtil.isNull(size)){
+            pageSize = 20L;
+        }else {
+            pageSize= size;
+        }
+        map.put("pageNo",pageNo);
+        map.put("pageSize",pageSize);
+        return map;
+    }
+
+
+
+    private LambdaQueryWrapper<OrderMain> createWrapper(OrderMainReq req) {
+        LambdaQueryWrapper<OrderMain> wrapper = new LambdaQueryWrapper<>();
+        if (ObjectUtil.isEmpty(req)) {
+            return wrapper;
+        }
+        wrapper.eq(ObjectUtil.isNotEmpty(req.getOrderState()), OrderMain::getOrderState, req.getOrderState());
+        wrapper.eq(ObjectUtil.isNotEmpty(req.getExamineState()), OrderMain::getExamineState, req.getExamineState());
+        wrapper.eq(ObjectUtil.isNotEmpty(req.getManualState()), OrderMain::getManualState, req.getManualState());
+        return wrapper;
+
+    }
+
+}

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

 package com.junmp.jyzb.service.impl;
 
-import cn.hutool.core.util.ObjectUtil;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.junmp.jyzb.api.bean.dto.OrderDetailDto;
-import com.junmp.jyzb.api.bean.dto.OrderDto;
-import com.junmp.jyzb.api.bean.dto.OrderMainDto;
-import com.junmp.jyzb.api.bean.query.OrderMainReq;
-import com.junmp.jyzb.api.bean.query.OrderUploadReq;
-import com.junmp.jyzb.api.bean.query.PolicemanFingerReq;
-import com.junmp.jyzb.api.bean.req.DetailListReq;
-import com.junmp.jyzb.api.bean.req.UpdateOrderReq;
-import com.junmp.jyzb.api.exception.enums.CabinetExceptionEnum;
-import com.junmp.jyzb.api.exception.enums.OrderExceptionEnum;
-import com.junmp.jyzb.entity.*;
-import com.junmp.jyzb.mapper.OrderMainMapper;
-import com.junmp.jyzb.service.OrderDetailService;
-import com.junmp.jyzb.service.OrderNumService;
+import com.junmp.jyzb.entity.Order;
 import com.junmp.jyzb.service.OrderService;
-import com.junmp.jyzb.service.PubOrgService;
-import com.junmp.v2.common.exception.base.ServiceException;
-import com.junmp.v2.common.util.BeanPlusUtil;
-import com.junmp.v2.db.api.factory.PageFactory;
-import com.junmp.v2.db.api.factory.PageResultFactory;
-import com.junmp.v2.db.api.page.PageResult;
-import org.apache.poi.ss.formula.functions.T;
-import org.springframework.amqp.core.Queue;
-import org.springframework.amqp.rabbit.core.RabbitAdmin;
-import org.springframework.amqp.rabbit.core.RabbitTemplate;
-import org.springframework.amqp.core.*;
+import com.junmp.jyzb.mapper.OrderMapper;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import javax.annotation.Resource;
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.*;
-
 
+/**
+* @author lxh专属坐骑
+* @description 针对表【base_order】的数据库操作Service实现
+* @createDate 2023-09-08 16:28:58
+*/
 @Service
-public class OrderServiceImpl  extends ServiceImpl<OrderMainMapper, OrderMain> implements OrderService {
-
-    @Resource
-    private OrderDetailService orderDetailService;
-    @Resource
-    private RabbitTemplate rabbitTemplate;
-    @Resource
-    private RabbitAdmin rabbitAdmin;
-
-    @Resource
-    private OrderNumService orderNumService;
-
-    @Resource
-    private PubOrgService pubOrgService;
-
-
-
-    //新增任务单
-    @Transactional(rollbackFor = Exception.class)
-    @Override
-    public String AddOrder(UpdateOrderReq req) {
-        OrderMain order = new OrderMain();
-        BeanPlusUtil.copyProperties(req, order);
-        //设置单据单号（订单号）
-        OrderNum orderNum = setOrderCode(req);
-        String codeValue=String.format("%04d",orderNum.getNum());
-        order.setOrderCode(orderNum.getBussinessType()+"-"+orderNum.getOutInType()+"-"+orderNum.getYear()+"-"+codeValue);
-        //设置总价格和应出入库数量
-        //设置id
-        String id=UUID.randomUUID().toString();
-        order.setId(id);
-        Integer sumNum=0;
-        BigDecimal priceTotal=new BigDecimal(0);
-        List<OrderDetail> detailList = new ArrayList<>();
-        //通过遍历批量保存详细信息
-        for (DetailListReq listReq:req.getDetailList()) {
-            OrderDetail detail=new OrderDetail();
-            BeanPlusUtil.copyProperties(listReq, detail);
-            detail.setOrderId(id);
-            //设置单据类型
-            detail.setType(order.getOrderType());
-            //将数量和价格进行累加
-            sumNum += detail.getPlanNum();
-            priceTotal = priceTotal.add(BigDecimal.valueOf(detail.getPlanNum()).multiply(detail.getPrice())) ;
-            detailList.add(detail);
-        }
-        orderDetailService.saveBatch(detailList);
-       //设置总价格和总数量
-        order.setPrice(priceTotal);
-        order.setInventoryQuantity(sumNum);
-        //保存
-        this.save(order);
-        return order.getId();
-    }
-
-
-    //设置单据单号（并且对order_num表进行新增或者更新）
-    public OrderNum setOrderCode(UpdateOrderReq req){
-        //设置采购单号，需要先判断改组织机构的采购单号是否存在，如果存在则将数量进行增加，如果不存在则新增一条对应的数据
-        OrderNum orderNum = new OrderNum();
-        //获取年份，获取业务出入状态，获取组织机构id，获取业务类型
-        orderNum.setYear(LocalDateTime.now().getYear());
-        //判断是出库还是入库，出库为发物单位，入库为收物单位
-        if (req.getOrderType().equals("in")){
-            orderNum.setOrgId(Long.valueOf(req.getEndOrgId()));
-        }else {
-            orderNum.setOrgId(Long.valueOf(req.getStartOrgId()));
-        }
-        //业务类型(简写)
-        orderNum.setBussinessType(req.getBussinessBrief());
-        //出入业务状态
-        orderNum.setOutInType(req.getOrderType());
-
-        OrderNum one = orderNumService.getOne(new LambdaQueryWrapper<OrderNum>()
-                .eq(OrderNum::getOrgId, orderNum.getOrgId())
-                .eq(OrderNum::getBussinessType, orderNum.getBussinessType())
-                .eq(OrderNum::getYear, orderNum.getYear())
-                .eq(OrderNum::getOutInType, orderNum.getOutInType()));
-        if (ObjectUtil.isNull(one)){
-            orderNum.setNum(1);
-            orderNumService.save(orderNum);
-            return orderNum;
-        }else {
-            one.setNum(one.getNum()+1);
-            orderNumService.updateById(one);
-            return one;
-        }
-
-    }
-
-
-    //新增默认审核通过的任务单
-    @Transactional(rollbackFor = Exception.class)
-    @Override
-    public String AddFinishOrder(UpdateOrderReq req) {
-        //添加到数据库中
-        String orderId = AddOrder(req);
-        //将完成的任务单直接推送到消息队列rabbitmq中（需要判断是入库单还是出库单，入库单传发物单位id，出库单传收物单位id）
-        //方法1：一个交换机，一个队列。通过中间对象，object存储对象，type表标识
-//        if(req.getOrderType().equals("in")){
-//            rabbitTemplate.convertAndSend("OrderExchange","OrderRouting",new MessageWrapper(req,req.getStartOrgId()));
-//        }else {
-//            rabbitTemplate.convertAndSend("OrderExchange","OrderRouting",new MessageWrapper(req,req.getEndOrgId()));
-//        }
-        //方法2：一个交换机，多个队列。动态创建队列
-        String exchangeName="orderExchange";
-        //需要判断是入库单还是出库单，入库单传收物单位id，出库单传发物单位id
-        if(req.getOrderType().equals("in")){
-            Queue queue=new Queue(req.getEndOrgId(),true,false,false);
-            Exchange exchange = new DirectExchange(exchangeName, true, false);
-            rabbitAdmin.declareQueue(queue);
-            rabbitAdmin.declareExchange(exchange);
-            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(req.getEndOrgId()).noargs());
-            rabbitTemplate.convertAndSend(exchangeName, req.getEndOrgId(), req);
-
-        }else {
-            Queue queue = new Queue(req.getStartOrgId(), true, false, false);
-            Exchange exchange = new DirectExchange(exchangeName, true, false);
-            rabbitAdmin.declareQueue(queue);
-            rabbitAdmin.declareExchange(exchange);
-            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(req.getStartOrgId()).noargs());
-            rabbitTemplate.convertAndSend(exchangeName, req.getStartOrgId(), req);
-        }
-        return orderId;
-    }
-
-
-    //更新任务单（进入工作流中之后不能进行更改）
-    @Transactional(rollbackFor = Exception.class)
-    @Override
-    public Boolean updateOrder(UpdateOrderReq req) {
-        OrderMain order = orderMainExist(req.getId());
-        if (!order.getExamineState().equals("none"))
-        {
-            throw new ServiceException(OrderExceptionEnum.ORDER_CAN_NOT_UPDATE);
-        }
-        List<OrderDetail> list= orderDetailService.QueryList(req.getId());
-        //idSet中存放的是存在数据库中的任务单中的orderDetail中的id（原始的工作单中的数据id）
-        Set<String> idSet =new HashSet<>();
-        for (OrderDetail orderDetail:list){
-            idSet.add(Long.toString(orderDetail.getId()));
-        }
-        //将该任务单的所有id转换为String,并添加到updateList中，用来判断删除或者修改新增的是否存在
-        //判断删除列表是否为空，如果不为空则进行批量删除
-        if (ObjectUtil.isNotNull(req.getDeleteList())&& ObjectUtil.isNotEmpty(req.getDeleteList())) {
-            //判断传递的list Id是否存在，如果不存在则抛出异常
-            for (String s:req.getDeleteList()){
-                if (idSet.contains(s)){
-                    //将要删除的装备价格和数据进行查询出来，并别对任务单的总数量和总价格进行更改
-                    OrderDetail one = orderDetailService.getOne(new LambdaQueryWrapper<OrderDetail>()
-                            .eq(OrderDetail::getOrderId, s));
-                    order.setPrice(order.getPrice().subtract(one.getPrice().multiply(BigDecimal.valueOf(one.getPlanNum()))));
-                    order.setInventoryQuantity(order.getInventoryQuantity() - one.getPlanNum());
-                    orderDetailService.removeBatchByIds(req.getDeleteList());
-                }else {
-                    throw new ServiceException(CabinetExceptionEnum.PARAMETER_ERROR);
-                }
-            }
-        }
-        //对detaillist进行处理
-        List<OrderDetail> addList = new ArrayList<>();//新增的
-        List<OrderDetail> updateList = new ArrayList<>();//更新
-        for (DetailListReq detailListReq :req.getDetailList()) {
-            //判断是否存在，存在则进行修改
-            if (idSet.contains(detailListReq.getId())){
-                OrderDetail one = orderDetailService.getOne(new LambdaQueryWrapper<OrderDetail>()
-                        .eq(OrderDetail::getId, detailListReq.getId()));
-                BeanPlusUtil.copyProperties(detailListReq,one);
-                one.setType(req.getOrderType());
-                //判断数量和价格是否有变动，如果有变动，则将order的总价和总数量进行更新操作，否则不变
-                if (one.getPlanNum().equals(detailListReq.getPlanNum()) && one.getPrice().compareTo(detailListReq.getPrice())!=0){
-                    order.setPrice(order.getPrice().subtract(one.getPrice().multiply(BigDecimal.valueOf(one.getPlanNum())))
-                            .add(detailListReq.getPrice().multiply(BigDecimal.valueOf(detailListReq.getPlanNum()))));
-                    order.setInventoryQuantity(order.getInventoryQuantity() - one.getPlanNum()+ detailListReq.getPlanNum());
-                }
-                updateList.add(one);
-            }else {
-                //否则判断id是否为空或者错误，如果为空则添加，不为空则抛出异常
-                if (ObjectUtil.isNull(detailListReq.getId()) || detailListReq.getId().equals("") || ObjectUtil.isEmpty(detailListReq.getId())){
-                    OrderDetail detail=new OrderDetail();
-                    BeanPlusUtil.copyProperties(detailListReq, detail);
-                    detail.setOrderId(req.getId());
-                    detail.setType(req.getOrderType());
-                    //将数量和价格进行相加处理
-                    order.setPrice(order.getPrice().add(detailListReq.getPrice().multiply(BigDecimal.valueOf(detailListReq.getPlanNum()))));
-                    order.setInventoryQuantity(order.getInventoryQuantity() + detailListReq.getPlanNum());
-                    addList.add(detail);
-                }else {
-                    throw new ServiceException(CabinetExceptionEnum.PARAMETER_ERROR);
-                }
-
-            }
-        }
-        orderDetailService.updateBatchById(updateList);
-        orderDetailService.saveBatch(addList);
-        BeanPlusUtil.copyProperties(req,order);
-        this.updateById(order);
-        return  true;
-    }
-    public boolean hasCommonElements(List<?> list1, List<?> list2) {
-        for (Object item1 : list1) {
-            if (list2.contains(item1)) {
-                return true; // 找到相同值
-            }
-        }
-        return false; // 没有相同值
-    }
-
-
-
-    //查询任务列表(根据组织机构id)
-    @Override
-    public PageResult<OrderMainDto> getOrderPage(OrderMainReq req) {
-        //判断组织机构是否存在
-        pubOrgService.PubOrgExist(req.getOrgId());
-        //判断是出库单还是入库单，选择的查询条件也不相同
-        Page<OrderMain> page=new Page<>();
-        LambdaQueryWrapper<OrderMain> wrapper = createWrapper(req);
-        if (req.getOrderType() != null && req.getOrderType().equals("in")){//入库单
-            LambdaQueryWrapper<OrderMain> eq = wrapper.eq(OrderMain::getOrderType, req.getOrderType())
-                    .eq(OrderMain::getEndOrgId, req.getOrgId());
-            page=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq);
-        } else if (req.getOrderType() != null && req.getOrderType().equals("out")) {//出库单
-            LambdaQueryWrapper<OrderMain> eq = wrapper.eq(OrderMain::getOrderType, req.getOrderType()).eq(OrderMain::getStartOrgId, req.getOrgId());
-            page=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq);
-        }else {//查询全部
-            Page<OrderMain> page1=new Page<>();
-            Page<OrderMain> page2=new Page<>();
-            LambdaQueryWrapper<OrderMain> eq1 = wrapper.eq(OrderMain::getEndOrgId, req.getOrgId());
-            page1=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq1);
-            LambdaQueryWrapper<OrderMain> eq2 = wrapper.eq(OrderMain::getStartOrgId, req.getOrgId());
-            page2=this.page(PageFactory.getDefaultPage(req.getPageNo(),req.getPageSize()),eq2);
-            List<OrderMain> list = new ArrayList<>();
-            list.addAll(page1.getRecords());
-            list.addAll(page2.getRecords());
-            page.setRecords(list);
-        }
-        List<OrderMainDto> orderMainDtoList=new ArrayList<>();
-        //遍历page,(如果出入库的组织机构为同一个的时候需要进行去重处理，不然会存在两条重复的数据)
-        for (OrderMain orderMain : page.getRecords()){
-            OrderMainDto orderMainDto = new OrderMainDto();
-            BeanPlusUtil.copyProperties(orderMain,orderMainDto);
-            if (!orderMainDtoList.contains(orderMainDto)){
-                orderMainDtoList.add(orderMainDto);
-            }
-        }
-        Page<OrderMainDto> page1 = PageFactory.getDefaultPage(req.getPageNo(), req.getPageSize());
-        page1.setTotal(orderMainDtoList.size());
-        page1.setRecords(orderMainDtoList);
-        return PageResultFactory.createPageResult(page1);
-    }
-
-    //根据任务单id查看业务明细
-    @Override
-    public OrderDto GetDetailById(OrderMainReq req) {
-        //判断任务单是否存在
-        OrderMain orderMain = orderMainExist(req.getId());
-        OrderDto orderDto = new OrderDto();
-        BeanPlusUtil.copyProperties(orderMain,orderDto);
-        //将详细信息存入列表属性中
-        //通过任务单id查询对应的详细信息
-        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
-                .eq(OrderDetail::getOrderId, req.getId()));
-        List<OrderDetailDto> orderDetailDtoList=new ArrayList<>();
-        for (OrderDetail orderDetail:list) {
-            OrderDetailDto orderDetailDto = new OrderDetailDto();
-            BeanPlusUtil.copyProperties(orderDetail,orderDetailDto);
-            orderDetailDtoList.add(orderDetailDto);
-        }
-        orderDto.setDetailList(orderDetailDtoList);
-        return orderDto;
-    }
-
-    //单据状态上报
-    @Override
-    public boolean PushState(OrderUploadReq req) {
-        OrderMain orderMain = orderMainExist(req.getId());
-        //获取单据的出入库，获取发物单位id或者收物单位id
-        String orderType = orderMain.getOrderType();
-        String exchangeName="OrderStateExchange";
-        //推送到rabbitmq中去
-        if (orderType.equals("in")){
-            Long endOrgId = orderMain.getEndOrgId();
-            Queue queue=new Queue(Long.toString(endOrgId),true,false,false);
-            Exchange exchange = new DirectExchange(exchangeName, true, false);
-            rabbitAdmin.declareQueue(queue);
-            rabbitAdmin.declareExchange(exchange);
-            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(Long.toString(endOrgId)).noargs());
-            rabbitTemplate.convertAndSend(exchangeName, Long.toString(endOrgId), req);
-
-        }else {
-            Long startOrgId = orderMain.getStartOrgId();
-            Queue queue = new Queue(Long.toString(startOrgId), true, false, false);
-            Exchange exchange = new DirectExchange(exchangeName, true, false);
-            rabbitAdmin.declareQueue(queue);
-            rabbitAdmin.declareExchange(exchange);
-            rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with(Long.toString(startOrgId)).noargs());
-            rabbitTemplate.convertAndSend(exchangeName, Long.toString(startOrgId), req);
-        }
-        return true;
-    }
-
-    //记账
-    @Transactional(rollbackFor = Exception.class)
-    @Override
-    public boolean Accounting(OrderUploadReq req) {
-        //判断传递的订单主id是否存在
-        OrderMain orderMain = orderMainExist(req.getId());
-        List<OrderUploadReq.OrderUploadDetailReq> childrenOrder = req.getChildrenOrder();
-        orderMain.setPrice(req.getPrice());
-        orderMain.setActualQuantity(req.getActualQuantity());
-        //设置子单据的价格和实际数量
-        List<OrderDetail> list = orderDetailService.list(new LambdaQueryWrapper<OrderDetail>()
-                .in(OrderDetail::getId, childrenOrder));
-        if(list.size()==0){
-            throw new ServiceException(CabinetExceptionEnum.PARAMETER_ERROR);
-        }
-        //通过totalMap存放需要修改的子单据，根据id作为key存放。
-        Map<Long,Map<String,Object>> totalMap=new HashMap<>();
-        for (OrderUploadReq.OrderUploadDetailReq detailReq: childrenOrder) {
-            Map<String,Object> map=new HashMap<>();
-            map.put("actualNum",detailReq.getActualNum());
-            map.put("price",detailReq.getPrice());
-            totalMap.put(detailReq.getDetailId(),map);
-        }
-        //遍历通过传递的子单据id查询出来的子单据信息并且进行修改
-        for (OrderDetail orderDetail:list ) {
-            Map<String,Object> map=totalMap.get(orderDetail.getId());
-            orderDetail.setActualNum((Integer) map.get("actualNum"));
-            orderDetail.setPrice((BigDecimal) map.get("price"));
-        }
-        orderDetailService.updateBatchById(list);
-        updateById(orderMain);
-        return true;
-    }
-
-
-    //判断任务单是否存在
-    @Override
-    public OrderMain orderMainExist(String id) {
-        OrderMain order = this.getById(id);
-        if (ObjectUtil.isNull(order)) {
-            throw new ServiceException(OrderExceptionEnum.ORDER_NOT_EXIST);
-        }
-        return order;
-    }
-
-    //设置pageNo和pageSize的通用方法
-    public Map<String,Long> getPage(Long no,Long size){
-        Map<String,Long> map=new HashMap<>();
-        long pageSize;
-        long pageNo;
-        if (ObjectUtil.isNull(no)){
-            pageNo = 1L;
-        }else {
-            pageNo= no;
-        }
-        if ( ObjectUtil.isNull(size)){
-            pageSize = 20L;
-        }else {
-            pageSize= size;
-        }
-        map.put("pageNo",pageNo);
-        map.put("pageSize",pageSize);
-        return map;
-    }
+public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order>
+    implements OrderService{
 
+}
 
 
-    private LambdaQueryWrapper<OrderMain> createWrapper(OrderMainReq req) {
-        LambdaQueryWrapper<OrderMain> wrapper = new LambdaQueryWrapper<>();
-        if (ObjectUtil.isEmpty(req)) {
-            return wrapper;
-        }
-        wrapper.eq(ObjectUtil.isNotEmpty(req.getOrderState()), OrderMain::getOrderState, req.getOrderState());
-        wrapper.eq(ObjectUtil.isNotEmpty(req.getExamineState()), OrderMain::getExamineState, req.getExamineState());
-        wrapper.eq(ObjectUtil.isNotEmpty(req.getManualState()), OrderMain::getManualState, req.getManualState());
-        return wrapper;
 
-    }
 
-}

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

@@ -24,7 +24,9 @@ import com.junmp.v2.db.api.factory.PageResultFactory;
 import com.junmp.v2.db.api.page.PageResult;
 import com.junmp.v2.sys.api.bean.user.req.SysUserReq;
 import com.junmp.v2.sys.api.bean.user.req.UserOrgReq;
+import com.junmp.v2.sys.user.entity.SysUser;
 import com.junmp.v2.sys.user.service.SysUserOrgService;
+import com.junmp.v2.sys.user.service.SysUserService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -57,7 +59,12 @@ public class PolicemanServiceImpl extends ServiceImpl<PolicemanMapper, Policeman
     private PoliceFingerService policeFingerService;
 
     @Resource
-    private SysuserService sysUserService;
+    private SysUserService sysUserService;
+
+    @Resource
+    private PoliceEquipmentService policeEquipmentService;
+
+
 
     @Resource
     private SysUserOrgService sysUserOrgService;
@@ -169,8 +176,8 @@ public class PolicemanServiceImpl extends ServiceImpl<PolicemanMapper, Policeman
             throw new ServiceException(CabinetBoxExceptionEnum.CABINETBOX_ISNOT_EXISTS);
         }
         //通过警员信息中的userId对账号进行删除
-        sysUserService.remove(new LambdaQueryWrapper<User>()
-                .eq(User::getUserId, policeman.getUserId()));
+        sysUserService.remove(new LambdaQueryWrapper<SysUser>()
+                .eq(SysUser::getUserId, policeman.getUserId()));
         //
         return removeById(req.getId());
 
@@ -456,16 +463,17 @@ public class PolicemanServiceImpl extends ServiceImpl<PolicemanMapper, Policeman
         if (ObjectUtil.isNotNull(policeman.getUserId())){
             throw new ServiceException(PolicemanExceptionEnum.POLICEUSER_IS_EXISTS);
         }
-        User user = new User();
+        SysUser user = new SysUser();
         BeanPlusUtil.copyProperties(req, user);
         //判断数据库中是否已经存在账号，如果存在则抛出异常提示账号已存在
         //密码加密，bcrypt加密方式
         BcryptPasswordStoredEncrypt passwordStoredEncrypt = new BcryptPasswordStoredEncrypt();
         String encrypt = passwordStoredEncrypt.encrypt(req.getPassword());
         user.setPassword(encrypt);
-        User one = sysUserService.getOne(new LambdaQueryWrapper<User>()
-                .eq(User::getAccount, user.getAccount())
-                .eq(User::getPassword, user.getPassword()));
+        SysUser one = sysUserService.getOne(new LambdaQueryWrapper<SysUser>()
+                .eq(SysUser::getAccount, user.getAccount())
+                .eq(SysUser::getPassword, user.getPassword()));
+
         if (ObjectUtil.isNotNull(one)){
             throw new ServiceException(UserExceptionEnum.USER_IS_EXIST);
         }
@@ -529,10 +537,37 @@ public class PolicemanServiceImpl extends ServiceImpl<PolicemanMapper, Policeman
 
     //警员调岗
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public boolean changePoliceOrg(PoliceReassignmentReq req) {
+        //通过警员id查询出该警员的基本信息
+        Policeman policeman = getById(req.getId());
         //如果警员绑定账号，将警员的账号进行删除
-        //修改警员的
-        return false;
+        if (ObjectUtil.isNotNull(policeman.getUserId())){
+            policeman.setUserId(null);
+            policeman.setPassword(null);
+            sysUserService.removeById(policeman.getUserId());
+        }
+        //修改警员的个人信息(删除指纹信息，修改组织机构信息)
+        List<PoliceFinger> list = policeFingerService.list(new LambdaQueryWrapper<PoliceFinger>()
+                .eq(PoliceFinger::getPoliceId, policeman.getId()));
+        if (list.size()!=0){
+            policeFingerService.removeBatchByIds(list);
+        }
+        policeman.setOrgId(req.getGoalOrgId());
+        //如果绑定箱门，进行解绑
+        if (ObjectUtil.isNotNull(policeman.getCabinetBoxId())){
+            policeman.setCabinetBoxId(null);
+        }
+        //对装备进行相关操作
+        //判断前端传递的装备列表是否为空，如果为空则表示该警员不拿走任何装备信息，将警员装备表中的数据删除即可
+        if (req.getEqsReqList().size()==0){
+            policeEquipmentService.remove(new LambdaQueryWrapper<PoliceEquipment>()
+                    .eq(PoliceEquipment::getPoliceId, policeman.getId()));
+        }else{
+            //警员带走的装备
+            
+        }
+        return updateById(policeman);
     }
 
 

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

@@ -11,7 +11,7 @@ import com.junmp.jyzb.api.exception.JYZBAppException;
 import com.junmp.jyzb.api.exception.enums.EquipmentTypeExceptionEnum;
 import com.junmp.jyzb.api.exception.enums.SupplierExceptionEnum;
 import com.junmp.jyzb.entity.Supplier;
-import com.junmp.jyzb.service.OrderService;
+import com.junmp.jyzb.service.OrderMainService;
 import com.junmp.jyzb.service.SupplierService;
 import com.junmp.v2.common.exception.base.ServiceException;
 import com.junmp.v2.common.util.BeanPlusUtil;
@@ -29,7 +29,7 @@ public class SupplierServiceImpl extends ServiceImpl<SupplierMapper, Supplier> i
 
 
     @Resource
-    OrderService orderService;
+    OrderMainService orderMainService;
 
     @Override
     public String AddSupplier(UpdateSupplierReq req) {
@@ -67,7 +67,8 @@ public class SupplierServiceImpl extends ServiceImpl<SupplierMapper, Supplier> i
 
     public List<String>  CheckSupplierList(List<String> req){
         if (ObjectUtil.isNull(req)){
-            String msg="以下供应商不存在：" +String.join(",", req);
+//            String msg="以下供应商不存在：" +String.join(",", req);
+            String msg= "供应商为空";
             throw new JYZBAppException(EquipmentTypeExceptionEnum.SUPPLIER_NOT_EXIST, msg);
         }
         LambdaQueryWrapper<Supplier> wp = new LambdaQueryWrapper<>();

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

-package com.junmp.jyzb.service.impl;
-
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.junmp.jyzb.entity.User;
-import com.junmp.jyzb.mapper.SysuserMapper;
-import com.junmp.jyzb.service.SysuserService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-@Service
-@Slf4j
-public class SysuserServiceImpl extends ServiceImpl<SysuserMapper, User> implements SysuserService {
-}

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

@@ -43,8 +43,7 @@ import java.util.Map;
 @Component
 public class InvExpireMsg implements JobAction {
 
-    @Resource
-    private ExpireMapper ExpireMapper;
+
     @Resource
     private InventoryService inventoryService;
 

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

 package com.junmp.jyzb.task;
 
+import cn.hutool.core.date.DateTime;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.junmp.jyzb.entity.InventorySummary;
 import com.junmp.jyzb.entity.OrderMain;
-import com.junmp.jyzb.service.InventoryService;
-import com.junmp.jyzb.service.OrderService;
+import com.junmp.jyzb.service.OrderMainService;
+import com.junmp.jyzb.utils.DateTimeUtil;
+import com.junmp.v2.db.api.factory.PageFactory;
+import com.junmp.v2.dict.entity.SysDictItem;
+import com.junmp.v2.dict.service.SysDictItemService;
 import com.junmp.v2.job.api.JobAction;
+import com.junmp.v2.message.api.MessageApi;
+import com.junmp.v2.message.api.bean.req.MessageReq;
+import com.junmp.v2.message.api.bean.req.MessageSendReq;
 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;
 
 /**
@@ -25,17 +32,23 @@ import java.util.List;
 public class InvOverDueMsg implements JobAction {
 
     @Resource
-    private OrderService orderService;
+    private OrderMainService orderMainService;
+    @Resource
+    private MessageApi messageApi;
+
+    @Resource
+    private SysDictItemService sysDictItemService;
 
     @Override
     public void action() {
         //获取超期物资
         //先查询出 出入库单据为借用单的数据
         LambdaQueryWrapper<OrderMain> wrapper = new LambdaQueryWrapper<OrderMain>()
-                .eq(OrderMain::getBussinessType, "borrow");
+                .eq(OrderMain::getBussinessType, "borrow")
+                .eq(OrderMain::getOrderType,"out");
         int pageSize =1000;
         int currentPage=1;
-        long termCount=orderService.count(wrapper);
+        long termCount= orderMainService.count(wrapper);
         List<OrderMain> list=new ArrayList<>();
         if (termCount>0) {
             // 分页查询
@@ -45,12 +58,46 @@ public class InvOverDueMsg implements JobAction {
                 list.addAll(orderMainList);
             }
         }
+        //将消息进行推送
+        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, "1698969778501099522"));
+            sendReq.setBizType(one.getItemValue());
+            sendReq.setMsgContent("单据id为："+orderMain.getId()+"的物资超期，请及时查看提醒");
+            sendReq.setPriority("0");
+            sendReq.setSendTime(DateTime.now());
+            messageApi.sendMessage(sendReq);
+        }
+        messageApi.queryCount(new MessageReq());
+        /*推送发送未读数量*/
+        //添加需要将消息推送的userid，先写死，可以查询数据库表动态设置userid；
+        List<Long> userIdList=new ArrayList<>();
+        userIdList.add(1000L);
+        for(Long userId :userIdList){
+            MessageReq req1 = new MessageReq();
+            req1.setReadFlag(0);
+            req1.setReceiveUserId(userId);
+            Integer count1 = messageApi.queryCount(req1);
+            messageApi.pushMsgToUser(String.valueOf(userId),count1);
+        }
 
     }
 
     // 处理每页数据
     private List<OrderMain> processPageData(long pageSize, long currentPage) {
-
-        return null;
+        //获取对应的借用单据数据
+        Date currentDateTime = DateTimeUtil.getCurrentDateTime();
+        LambdaQueryWrapper<OrderMain> wrapper = new LambdaQueryWrapper<OrderMain>()
+                .eq(OrderMain::getBussinessType, "borrow")
+                .eq(OrderMain::getOrderType,"out")
+                .lt(OrderMain::getReturnDate,currentDateTime);
+        List<OrderMain> records = orderMainService.page(PageFactory.getDefaultPage(pageSize, currentPage),wrapper).getRecords();
+        return records;
     }
 }

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

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.junmp.jyzb.mapper.OrderMapper">
+
+    <resultMap id="BaseResultMap" type="com.junmp.jyzb.entity.Order">
+            <id property="id" column="id" jdbcType="VARCHAR"/>
+            <result property="sizeId" column="size_id" jdbcType="VARCHAR"/>
+            <result property="sizeName" column="size_name" jdbcType="VARCHAR"/>
+            <result property="typeId" column="type_id" jdbcType="VARCHAR"/>
+            <result property="typeName" column="type_name" jdbcType="VARCHAR"/>
+            <result property="applyTime" column="apply_time" jdbcType="TIMESTAMP"/>
+            <result property="applicantId" column="applicant_id" jdbcType="VARCHAR"/>
+            <result property="recipientId" column="recipient_id" jdbcType="VARCHAR"/>
+            <result property="applyReason" column="apply_reason" jdbcType="VARCHAR"/>
+            <result property="locationId" column="location_id" jdbcType="VARCHAR"/>
+            <result property="orgId" column="org_id" jdbcType="BIGINT"/>
+            <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
+            <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
+            <result property="createUser" column="create_user" jdbcType="VARCHAR"/>
+            <result property="updateUser" column="update_user" jdbcType="VARCHAR"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        id,size_id,size_name,
+        type_id,type_name,apply_time,
+        applicant_id,recipient_id,apply_reason,
+        location_id,org_id,create_time,
+        update_time,create_user,update_user
+    </sql>
+</mapper>