杰生重构

hx-service/storage-restructure/src/main/java/com/fjhx/controller/apply/ApplyPurchaseController.java

@@ -97,5 +97,23 @@ public class ApplyPurchaseController {
         return R.success(result);
     }
 
+    /**
+     * 申购金额统计
+     */
+    @PostMapping("/amountStatistics")
+    public R amountStatistics(@RequestBody Condition condition) {
+        Map<String, Object> result = applyPurchaseService.amountStatistics(condition);
+        return R.success(result);
+    }
+
+    /**
+     * 申购金额分页
+     */
+    @PostMapping("/amountPage")
+    public R amountPage(@RequestBody Condition condition) {
+        Page<Map<String, Object>> result = applyPurchaseService.amountPage(condition);
+        return R.success(result);
+    }
+
 }
 

hx-service/storage-restructure/src/main/java/com/fjhx/controller/contract/ContractDetailsController.java

@@ -10,6 +10,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -36,4 +37,31 @@ public class ContractDetailsController {
         return R.success(result);
     }
 
+    /**
+     * 出库统计
+     */
+    @PostMapping("/outStatistics")
+    public R outStatistics(@RequestBody Condition condition) {
+        Map<String, Object> result = contractDetailsService.outStatistics(condition);
+        return R.success(result);
+    }
+
+    /**
+     * 出库分页记录
+     */
+    @PostMapping("/outPage")
+    public R outPage(@RequestBody Condition condition) {
+        Page<Map<String, Object>> result = contractDetailsService.getOutPage(condition);
+        return R.success(result);
+    }
+
+    /**
+     * 出库件数
+     */
+    @PostMapping("/outCount")
+    public R outCount(@RequestBody Condition condition) {
+        List<Map<String, Object>> result = contractDetailsService.getOutCount(condition);
+        return R.success(result);
+    }
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/controller/material/MaterialController.java

@@ -1,6 +1,7 @@
 package com.fjhx.controller.material;
 
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fjhx.base.Condition;
 import com.fjhx.entity.material.Material;
 import com.fjhx.params.JumpVo;
 import com.fjhx.service.flow.MaterialUpdateFlowService;
@@ -92,5 +93,14 @@ public class MaterialController {
         return R.success(result);
     }
 
+    /**
+     * 物料库存分页
+     */
+    @PostMapping("/stockPage")
+    public R stockPage(@RequestBody Condition condition) {
+        Page<Map<String, Object>> result = materialService.getStockPage(condition);
+        return R.success(result);
+    }
+
 }
 

hx-service/storage-restructure/src/main/java/com/fjhx/controller/stock/ReportFormController.java

@@ -0,0 +1,66 @@
+package com.fjhx.controller.stock;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fjhx.base.Condition;
+import com.fjhx.service.contract.ContractDetailsService;
+import com.fjhx.service.water.WaterDetailService;
+import org.springblade.core.tool.api.R;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+ * 库存报表相关接口
+ */
+@RestController
+@RequestMapping("/reportForm")
+public class ReportFormController {
+
+    @Autowired
+    private WaterDetailService waterDetailService;
+
+    @Autowired
+    private ContractDetailsService contractDetailsService;
+
+    /**
+     * 领料序时浦 统计
+     */
+    @PostMapping("pickingStatistics")
+    public R pickingStatistics(@RequestBody Condition condition) {
+        Map<String, Object> result = waterDetailService.pickingStatistics(condition);
+        return R.success(result);
+    }
+
+    /**
+     * 领料序时浦 领料类型统计
+     */
+    @PostMapping("pickingTypeStatistics")
+    public R pickingTypeStatistics(@RequestBody Condition condition) {
+        Map<String, Integer> result = waterDetailService.pickingTypeStatistics(condition);
+        return R.success(result);
+    }
+
+    /**
+     * 领料序时浦 分页
+     */
+    @PostMapping("pickingPage")
+    public R pickingPage(@RequestBody Condition condition) {
+        Page<Map<String, Object>> result = waterDetailService.pickingPage(condition);
+        return R.success(result);
+    }
+
+    /**
+     * 入库序时浦 分页
+     */
+    @PostMapping("warehousingPage")
+    public R warehousingPage(@RequestBody Condition condition) {
+        Page<Map<String, Object>> result = contractDetailsService.warehousingPage(condition);
+        return R.success(result);
+    }
+
+
+}

hx-service/storage-restructure/src/main/java/com/fjhx/controller/water/WaterTagController.java

@@ -39,6 +39,12 @@ public class WaterTagController {
         return R.success(result);
     }
 
+    @PostMapping("/count")
+    public R count() {
+        Long count = waterTagService.count();
+        return R.success(count);
+    }
+
     /**
      * 添加标签
      */

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/apply/ApplyPurchaseMapper.java

@@ -27,4 +27,8 @@ public interface ApplyPurchaseMapper extends BaseMapper<ApplyPurchase> {
 
     List<Map<String, Object>> getApplyPurchaseDetailsList(@Param("page") Page<ApplyPurchase> page, @Param("applyPurchaseId") String applyPurchaseId);
 
+    List<Map<String, Object>> getAmountStatisticsList(@Param("ew") QueryWrapper<Object> wrapper);
+
+    Page<Map<String, Object>> amountPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<Object> wrapper);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/apply/ApplyPurchaseMapper.xml

@@ -55,4 +55,33 @@
         where apd.apply_purchase_id = #{applyPurchaseId}
     </select>
 
+    <select id="getAmountStatisticsList" resultType="java.util.Map">
+        select ifnull(m.technology_type, 4)                      materialType,
+               if(c.status = 3, c.adjust_amount, c.amount_money) money,
+               c.account_date                                    accountDate,
+               c.supplier_id                                     supplierId,
+               s.Name                                            supplierName
+        from contract c
+                 left join contract_details cd on c.id = cd.contract_id
+                 left join material m on cd.material_id = m.id
+                 left join supplier s on c.supplier_id = s.id
+            ${ew.customSqlSegment}
+    </select>
+
+    <select id="amountPage" resultType="java.util.LinkedHashMap">
+        select s.Name          supplierName,
+               c.code          contractCode,
+               m.name          materialName,
+               cd.quantity     quantity,
+               cd.price        price,
+               c.amount_money  amountMoney,
+               c.adjust_amount adjustAmount,
+               c.approval_time approvalTime
+        from contract c
+                 left join contract_details cd on c.id = cd.contract_id
+                 left join material m on cd.material_id = m.id
+                 left join supplier s on c.supplier_id = s.id
+            ${ew.customSqlSegment}
+    </select>
+
 </mapper>

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/contract/ContractDetailsMapper.java

@@ -1,11 +1,12 @@
 package com.fjhx.mapper.contract;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.entity.contract.ContractDetails;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -20,4 +21,12 @@ public interface ContractDetailsMapper extends BaseMapper<ContractDetails> {
 
     Page<Map<String, Object>> getInPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<Object> wrapper);
 
+    Map<String, Object> outStatistics(@Param("ew") QueryWrapper<Object> wrapper);
+
+    Page<Map<String, Object>> getOutPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<Object> wrapper);
+
+    List<Map<String, Object>> getOutCount(@Param("ew") QueryWrapper<Object> wrapper);
+
+    Page<Map<String, Object>> warehousingPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<Object> wrapper);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/contract/ContractDetailsMapper.xml

@@ -18,4 +18,56 @@
             ${ew.customSqlSegment}
     </select>
 
+    <select id="outStatistics" resultType="java.util.Map">
+        select count(0)                    count,
+               ifnull(sum(wd.quantity), 0) sum
+        from water w
+                 left join water_detail wd on w.id = wd.water_id
+            ${ew.customSqlSegment}
+    </select>
+
+    <select id="getOutPage" resultType="java.util.LinkedHashMap">
+        select m.id                        materialId,
+               w.id                        waterId,
+               m.name                      materialName,
+               m.code                      materialCode,
+               w.oper_user_id,
+               w.type,
+               w.create_time,
+               count(0)                    count,
+               ifnull(sum(wd.quantity), 0) sum,
+               w.remark
+        from water w
+                 left join water_detail wd on w.id = wd.water_id
+                 left join material m on wd.material_id = m.id
+            ${ew.customSqlSegment}
+    </select>
+
+    <select id="getOutCount" resultType="java.util.Map">
+        select wd.quantity,
+               wd.rfid_code
+        from water_detail wd
+                 left join material m on wd.material_id = m.id
+            ${ew.customSqlSegment}
+    </select>
+
+    <select id="warehousingPage" resultType="java.util.Map">
+        select m.code                                                         materialCode,
+               m.name                                                         materialName,
+               m.spec                                                         materialSpec,
+               cd.contract_code,
+               s.name                                                         supplierName,
+               m.unit                                                         materialUnit,
+               cd.quantity,
+               cd.price,
+               cd.update_time                                                 updateTime,
+               cd.arrival_quantity - cd.back_quantity                         arrivalQuantity,
+               format(cd.price * (cd.arrival_quantity - cd.back_quantity), 2) amountMoney
+        from contract_details cd
+                 left join supplier s on cd.supplier_id = s.id
+                 left join material m on cd.material_id = m.id
+            ${ew.customSqlSegment}
+    </select>
+
+
 </mapper>

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/material/MaterialMapper.java

@@ -1,5 +1,7 @@
 package com.fjhx.mapper.material;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.entity.material.Material;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
@@ -19,4 +21,6 @@ public interface MaterialMapper extends BaseMapper<Material> {
 
     List<Map<String, Object>> getMaterialBySupplierId(@Param("supplierId") Long supplierId);
 
+    Page<Map<String, Object>> getStockPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<Object> wrapper);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/material/MaterialMapper.xml

@@ -12,4 +12,16 @@
         where sp.supplier_id = #{supplierId}
     </select>
 
+    <select id="getStockPage" resultType="java.util.LinkedHashMap">
+        select m.id,
+               m.name,
+               m.code,
+               ifnull(s.quantity, 0) quantity,
+               m.unit,
+               m.spec
+        from material m
+                 left join stock s on m.id = s.material_id
+            ${ew.customSqlSegment}
+    </select>
+
 </mapper>

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/stock/StockMapper.java

@@ -1,7 +1,10 @@
 package com.fjhx.mapper.stock;
 
-import com.fjhx.entity.stock.Stock;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fjhx.entity.stock.Stock;
+import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 import java.util.Map;
@@ -18,5 +21,6 @@ public interface StockMapper extends BaseMapper<Stock> {
 
     List<Map<String, Object>> statistics();
 
+    Page<Map<String, Object>> getPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<?> wrapper);
 
 }

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/stock/StockMapper.xml

@@ -14,4 +14,9 @@
         where s.number > 0
     </select>
 
+    <select id="getPage" resultType="java.util.Map">
+        select * from
+
+    </select>
+
 </mapper>

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/water/WaterDetailMapper.java

@@ -1,5 +1,7 @@
 package com.fjhx.mapper.water;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.entity.water.WaterDetail;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
@@ -19,4 +21,10 @@ public interface WaterDetailMapper extends BaseMapper<WaterDetail> {
 
     List<Map<String, Object>> getInQuantityByApplyPurchaseDetailsId(@Param("applyPurchaseDetailsId") Long applyPurchaseDetailsId);
 
+    List<Map<String, Object>> getPickingList(@Param("ew") QueryWrapper<Object> wrapper);
+
+    Map<String, Integer> pickingTypeStatistics(@Param("ew") QueryWrapper<Object> wrapper);
+
+    Page<Map<String, Object>> pickingPage(@Param("page") Page<Object> page, @Param("ew") QueryWrapper<Object> wrapper);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/mapper/water/WaterDetailMapper.xml

@@ -11,5 +11,40 @@
         where wb.apply_purchase_details_id = #{applyPurchaseDetailsId}
         group by wb.id
     </select>
+    <select id="getPickingList" resultType="java.util.Map">
+        select if(wd.type = 15, -wd.quantity, wd.quantity) changeNum,
+               ifnull(wd.price, 0)                         materialPrice,
+               m.technology_type                           materialType,
+               m.Width                                     materialWidth,
+               wd.oper_user_id                             userId
+        from water_detail wd
+                 inner join material m on wd.material_id = m.id
+            ${ew.customSqlSegment}
+    </select>
+
+    <select id="pickingTypeStatistics" resultType="java.util.Map">
+        select sum(if(wd.type = 15, 1, 0)) cancellingStocks,
+               sum(if(wd.type = 20, 1, 0)) exWarehouse,
+               sum(if(wd.type = 23, 1, 0)) supplementaryDelivery
+        from water_detail wd
+                 inner join material m on wd.material_id = m.id
+            ${ew.customSqlSegment}
+    </select>
+
+    <select id="pickingPage" resultType="java.util.Map">
+        select wd.create_time                    createdTime,
+               m.technology_type                 materialType,
+               m.code                            materialCode,
+               m.name                            materialName,
+               m.spec                            materialSpec,
+               m.unit                            materialUnit,
+               wd.quantity                       changeNum,
+               wd.Price                          materialPrice,
+               format(wd.price * wd.quantity, 2) money,
+               wd.oper_user_id                   operUserId
+        from water_detail wd
+                 inner join material m on wd.material_id = m.id
+            ${ew.customSqlSegment}
+    </select>
 
 </mapper>

hx-service/storage-restructure/src/main/java/com/fjhx/service/apply/ApplyPurchaseService.java

@@ -2,8 +2,8 @@ package com.fjhx.service.apply;
 
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.base.Condition;
-import com.fjhx.entity.apply.ApplyPurchase;
 import com.fjhx.base.StorageBaseService;
+import com.fjhx.entity.apply.ApplyPurchase;
 
 import java.util.List;
 import java.util.Map;
@@ -30,4 +30,8 @@ public interface ApplyPurchaseService extends StorageBaseService<ApplyPurchase>
 
     Map<String, Object> getApplyPurchaseDetailsList(Condition condition);
 
+    Map<String, Object> amountStatistics(Condition condition);
+
+    Page<Map<String, Object>> amountPage(Condition condition);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/apply/impl/ApplyPurchaseServiceImpl.java

@@ -25,6 +25,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -266,6 +267,143 @@ public class ApplyPurchaseServiceImpl extends ServiceImpl<ApplyPurchaseMapper, A
         return result;
     }
 
+    @Override
+    public Map<String, Object> amountStatistics(Condition condition) {
+
+        QueryWrapper<Object> wrapper = getAmountWrapper(condition);
+
+        List<Map<String, Object>> list = baseMapper.getAmountStatisticsList(wrapper);
+
+        Map<String, Object> result = new HashMap<>();
+
+        /*
+            0 =》申购金额
+            1 =》面料采购
+            2 =》墨水采购
+            3 =》其他
+         */
+        Map<String, BigDecimal> money = list.stream().collect(Collectors.toMap(
+                item -> {
+                    String materialType = item.get("materialType").toString();
+                    switch (materialType) {
+                        case "3":
+                            return "2";
+                        case "4":
+                            return "3";
+                        default:
+                            return "1";
+                    }
+                },
+                item -> ((BigDecimal) item.get("money")).setScale(2, RoundingMode.HALF_UP),
+                BigDecimal::add
+        ));
+        money.putIfAbsent("1", BigDecimal.ZERO);
+        money.putIfAbsent("2", BigDecimal.ZERO);
+        money.putIfAbsent("3", BigDecimal.ZERO);
+        money.put("0", money.get("1").add(money.get("2")).add(money.get("3")));
+
+         /*
+            4 =》45天账期
+            5 =》30天账期
+            6 =》15天账期
+            7 =》预付款
+         */
+        Map<String, BigDecimal> collect2 = list.stream().collect(Collectors.toMap(
+                item -> {
+                    Integer accountDate = (Integer) item.get("accountDate");
+                    switch (accountDate) {
+                        case 45:
+                            return "4";
+                        case 30:
+                            return "5";
+                        case 15:
+                            return "6";
+                        default:
+                            return "7";
+                    }
+                },
+                item -> ((BigDecimal) item.get("money")).setScale(2, RoundingMode.HALF_UP),
+                BigDecimal::add
+        ));
+        money.putIfAbsent("4", BigDecimal.ZERO);
+        money.putIfAbsent("5", BigDecimal.ZERO);
+        money.putIfAbsent("6", BigDecimal.ZERO);
+        money.putIfAbsent("7", BigDecimal.ZERO);
+
+        money.putAll(collect2);
+
+        // 赋值全部金额查询信息
+        result.put("money", money);
+
+
+        // 根据供应商id，统计出向每家公司付款的金额
+        List<Map<String, Object>> values = list.stream().collect(Collectors.toMap(
+                        item -> item.get("supplierId").toString(),
+                        item -> {
+                            Map<String, Object> map = new HashMap<>();
+                            map.put("supplierId", item.get("supplierId"));
+                            map.put("supplierName", item.get("supplierName"));
+                            map.put("money", item.get("money"));
+                            return map;
+                        },
+                        (v1, v2) -> {
+                            v1.put("money", Convert.toBigDecimal(v1.get("money")).add(Convert.toBigDecimal(v2.get("money"))));
+                            return v1;
+                        }
+                )).values().stream()
+                .sorted(Comparator.comparing((Map<String, Object> v) -> ((BigDecimal) v.get("money"))).reversed())
+                .collect(Collectors.toList());
+
+        /*
+         0 全部公司统计
+         1 50万以上
+         2 20~50万
+         3 10~20万
+         4 5~20万
+         5 5万以下
+         */
+        Map<String, List<Map<String, Object>>> statisticsSupplier = values.stream()
+
+                .collect(Collectors.groupingBy(item -> {
+                    BigDecimal amountMoney = Convert.toBigDecimal(item.get("money"));
+                    if (amountMoney.compareTo(new BigDecimal("50000")) < 0) {
+                        return "5";
+                    }
+                    if (amountMoney.compareTo(new BigDecimal("100000")) < 0) {
+                        return "4";
+                    }
+                    if (amountMoney.compareTo(new BigDecimal("200000")) < 0) {
+                        return "3";
+                    }
+                    if (amountMoney.compareTo(new BigDecimal("500000")) < 0) {
+                        return "2";
+                    }
+                    return "1";
+                }));
+
+        statisticsSupplier.put("0", values);
+        statisticsSupplier.putIfAbsent("1", new ArrayList<>());
+        statisticsSupplier.putIfAbsent("2", new ArrayList<>());
+        statisticsSupplier.putIfAbsent("3", new ArrayList<>());
+        statisticsSupplier.putIfAbsent("4", new ArrayList<>());
+        statisticsSupplier.putIfAbsent("5", new ArrayList<>());
+
+        result.put("statisticsSupplier", statisticsSupplier);
+
+        return result;
+    }
+
+    @Override
+    public Page<Map<String, Object>> amountPage(Condition condition) {
+
+        Long supplierId = condition.getLong("supplierId");
+
+        QueryWrapper<Object> wrapper = getAmountWrapper(condition);
+        wrapper.eq(ObjectUtil.isNotEmpty(supplierId), "c.supplier_id", supplierId);
+
+        return baseMapper.amountPage(condition.getPage(), wrapper);
+    }
+
     /**
      * 根据类型统计物料采购情况
      */
@@ -381,4 +519,17 @@ public class ApplyPurchaseServiceImpl extends ServiceImpl<ApplyPurchaseMapper, A
 
     }
 
+    private QueryWrapper<Object> getAmountWrapper(Condition condition) {
+        QueryWrapper<Object> wrapper = Wrappers.query();
+
+        Date beginTime = condition.getBeginTime();
+        Date endTime = condition.getEndTime();
+
+        wrapper.between(ObjectUtil.isAllNotEmpty(beginTime, endTime), "c.approval_time", beginTime, endTime);
+        wrapper.eq("c.del_flag", StatusConstant.NOT_DELETED);
+        wrapper.in("c.account_date", 45, 30, 15, 0);
+
+        return wrapper;
+    }
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/contract/ContractDetailsService.java

@@ -45,4 +45,24 @@ public interface ContractDetailsService extends StorageBaseService<ContractDetai
      */
     Page<Map<String, Object>> getInPage(Condition condition);
 
+    /**
+     * 出库统计
+     */
+    Map<String, Object> outStatistics(Condition condition);
+
+    /**
+     * 出库分页记录
+     */
+    Page<Map<String, Object>> getOutPage(Condition condition);
+
+    /**
+     * 出库件数
+     */
+    List<Map<String, Object>> getOutCount(Condition condition);
+
+    /**
+     * 入库序时浦 分页
+     */
+    Page<Map<String, Object>> warehousingPage(Condition condition);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/contract/impl/ContractDetailsServiceImpl.java

@@ -1,5 +1,6 @@
 package com.fjhx.service.contract.impl;
 
+import cn.hutool.core.convert.Convert;
 import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -13,12 +14,15 @@ import com.fjhx.entity.contract.ContractDetails;
 import com.fjhx.entity.water.WaterBatch;
 import com.fjhx.entity.water.WaterTag;
 import com.fjhx.enums.ContractStatusEnum;
+import com.fjhx.enums.OutTypeEnum;
 import com.fjhx.enums.PurchaseProgressEnum;
 import com.fjhx.mapper.contract.ContractDetailsMapper;
 import com.fjhx.service.contract.ContractDetailsService;
 import com.fjhx.service.contract.ContractService;
 import com.fjhx.service.water.WaterBatchService;
+import com.fjhx.utils.Assert;
 import com.fjhx.utils.BigDecimalUtil;
+import com.fjhx.utils.UserClientUtil;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -166,15 +170,110 @@ public class ContractDetailsServiceImpl extends ServiceImpl<ContractDetailsMappe
     public Page<Map<String, Object>> getInPage(Condition condition) {
         String keyword = condition.getKeyword();
         Integer completeStatus = condition.getStatus();
+        Long materialId = condition.getLong("materialId");
 
         QueryWrapper<Object> wrapper = Wrappers.query();
 
         wrapper.and(ObjectUtil.isNotEmpty(keyword),
                         q -> q.like("m.code", keyword).or().like("m.name", keyword))
                 .eq(ObjectUtil.isNotEmpty(completeStatus), "cd.complete_status", completeStatus)
+                .eq(ObjectUtil.isNotEmpty(materialId), "cd.material_id", materialId)
                 .orderByDesc("cd.id");
 
         return baseMapper.getInPage(condition.getPage(), wrapper);
     }
 
+    @Override
+    public Map<String, Object> outStatistics(Condition condition) {
+        QueryWrapper<Object> wrapper = getOutWrapper(condition);
+
+        return baseMapper.outStatistics(wrapper);
+    }
+
+    @Override
+    public Page<Map<String, Object>> getOutPage(Condition condition) {
+
+        QueryWrapper<Object> wrapper = getOutWrapper(condition);
+        wrapper.groupBy("w.id", "wd.material_id");
+
+        Page<Map<String, Object>> page = baseMapper.getOutPage(condition.getPage(), wrapper);
+        List<Map<String, Object>> records = page.getRecords();
+
+        if (records.size() == 0) {
+            return page;
+        }
+
+        Map<Long, String> userNameMap = UserClientUtil.getUserNameMapFunctionLong(records, item -> Convert.toLong(item.get("operUserId")));
+        for (Map<String, Object> record : records) {
+            record.put("operUserName", userNameMap.get(Convert.toLong(record.get("operUserId"))));
+        }
+
+        return page;
+    }
+
+    @Override
+    public List<Map<String, Object>> getOutCount(Condition condition) {
+        Long materialId = condition.getLong("materialId");
+        Long waterId = condition.getLong("waterId");
+
+        Assert.notEmpty(materialId, "物料id不能未空");
+        Assert.notEmpty(waterId, "流水id不能未空");
+
+        QueryWrapper<Object> wrapper = Wrappers.query();
+
+        wrapper.eq("wd.water_id", waterId).eq("wd.material_id", materialId);
+
+        return baseMapper.getOutCount(wrapper);
+    }
+
+    @Override
+    public Page<Map<String, Object>> warehousingPage(Condition condition) {
+        String keyword = condition.getKeyword();
+        Date beginTime = condition.getBeginTime();
+        Date endTime = condition.getEndTime();
+
+        QueryWrapper<Object> wrapper = Wrappers.query();
+
+        wrapper.between(ObjectUtil.isAllNotEmpty(beginTime, endTime), "cd.update_time", beginTime, endTime)
+                .and(ObjectUtil.isNotEmpty(keyword), q -> q
+                        .like("m.name", keyword).or()
+                        .like("n.code", keyword).or()
+                        .like("cd.contract_code", keyword).or()
+                        .like("s.name", keyword));
+
+        return baseMapper.warehousingPage(condition.getPage(), wrapper);
+    }
+
+    private QueryWrapper<Object> getOutWrapper(Condition condition) {
+        String keyword = condition.getKeyword();
+        Date beginTime = condition.getBeginTime();
+        Date endTime = condition.getEndTime();
+        Long materialId = condition.getLong("materialId");
+
+        // 出库类型
+        Integer outType = condition.getInt("outType");
+        // 操作人id
+        Long operUserId = condition.getLong("operUserId");
+
+        QueryWrapper<Object> wrapper = Wrappers.query();
+
+        wrapper.and(ObjectUtil.isNotEmpty(keyword),
+                        q -> q.like("m.name", keyword).or().like("m.code", keyword))
+                .func(q -> {
+                    if (ObjectUtil.isEmpty(outType)) {
+                        q.in("w.type",
+                                OutTypeEnum.ISSUE.getType(),
+                                OutTypeEnum.RETURN_ISSUE.getType(),
+                                OutTypeEnum.SCRAP_ISSUE.getType());
+                    } else {
+                        q.eq("w.type", outType);
+                    }
+                })
+                .eq(ObjectUtil.isNotEmpty(operUserId), "w.oper_user_id", operUserId)
+                .eq(ObjectUtil.isNotEmpty(materialId), "wd.material_id", materialId)
+                .between(ObjectUtil.isAllNotEmpty(beginTime, endTime), "w.create_time", beginTime, endTime);
+
+        return wrapper;
+    }
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/material/MaterialService.java

@@ -1,6 +1,7 @@
 package com.fjhx.service.material;
 
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fjhx.base.Condition;
 import com.fjhx.base.StorageBaseService;
 import com.fjhx.entity.material.Material;
 
@@ -25,4 +26,6 @@ public interface MaterialService extends StorageBaseService<Material> {
 
     List<Map<String, Object>> getMaterialBySupplierId(Long supplierId);
 
+    Page<Map<String, Object>> getStockPage(Condition condition);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/material/impl/MaterialServiceImpl.java

@@ -1,9 +1,11 @@
 package com.fjhx.service.material.impl;
 
+import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.fjhx.base.Condition;
 import com.fjhx.constants.ConfigConstant;
 import com.fjhx.entity.material.Material;
 import com.fjhx.mapper.material.MaterialMapper;
@@ -62,4 +64,15 @@ public class MaterialServiceImpl extends ServiceImpl<MaterialMapper, Material> i
         return baseMapper.getMaterialBySupplierId(supplierId);
     }
 
+    @Override
+    public Page<Map<String, Object>> getStockPage(Condition condition) {
+        String keyword = condition.getKeyword();
+
+        QueryWrapper<Object> wrapper = Wrappers.query();
+        wrapper.and(ObjectUtil.isNotEmpty(keyword), q ->
+                q.like("m.name", keyword).or().like("m.code", keyword));
+
+        return baseMapper.getStockPage(condition.getPage(), wrapper);
+    }
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/stock/impl/StockServiceImpl.java

@@ -144,6 +144,9 @@ public class StockServiceImpl extends ServiceImpl<StockMapper, Stock> implements
 
     @Override
     public Page<Map<String, Object>> getPage(Condition condition) {
+        QueryWrapper<?> wrapper = createRemainingTodayWrapper(condition);
+
+        Page<Map<String, Object>> page = baseMapper.getPage(condition.getPage(), wrapper);
 
         return null;
     }
@@ -190,9 +193,9 @@ public class StockServiceImpl extends ServiceImpl<StockMapper, Stock> implements
 
     private QueryWrapper<?> createRemainingTodayWrapper(Condition condition) {
         QueryWrapper<?> wrapper = WrapperUtil.init(condition)
-                .keyword("m.Code", "m.Name") // 关键字查询
-                .eq("m.CategoryCode", "categoryCode") // 物料分类
-                .eq("m.Purpose", "purpose") // 用途
+                .keyword("m.code", "m.name") // 关键字查询
+                .eq("m.material_classify_id", "materialClassifyId") // 物料分类
+                .eq("m.purpose", "purpose") // 用途
                 .getWrapper();
 
         // 查询指定分类的物料

hx-service/storage-restructure/src/main/java/com/fjhx/service/water/WaterDetailService.java

@@ -1,5 +1,6 @@
 package com.fjhx.service.water;
 
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.base.Condition;
 import com.fjhx.entity.water.WaterDetail;
 import com.fjhx.entity.water.WaterTag;
@@ -21,6 +22,25 @@ public interface WaterDetailService extends StorageBaseService<WaterDetail> {
 
     void add(WaterVo waterVo, List<WaterTag> waterTagList);
 
+    /**
+     * 根据申购单id获取入库明细
+     * TODO
+     */
     List<Map<String, Object>> getInQuantityByApplyPurchaseDetailsId(Condition condition);
 
+    /**
+     * 领料序时浦 统计
+     */
+    Map<String, Object> pickingStatistics(Condition condition);
+
+    /**
+     * 领料序时浦 领料类型统计
+     */
+    Map<String, Integer> pickingTypeStatistics(Condition condition);
+
+    /**
+     * 领料序时浦 分页
+     */
+    Page<Map<String, Object>> pickingPage(Condition condition);
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/water/impl/WaterDetailServiceImpl.java

@@ -1,19 +1,28 @@
 package com.fjhx.service.water.impl;
 
 import cn.hutool.core.convert.Convert;
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.fjhx.base.Condition;
+import com.fjhx.constants.StatusConstant;
 import com.fjhx.entity.water.WaterDetail;
 import com.fjhx.entity.water.WaterTag;
+import com.fjhx.enums.InTypeEnum;
+import com.fjhx.enums.MaterialTypeEnum;
+import com.fjhx.enums.OutTypeEnum;
 import com.fjhx.mapper.water.WaterDetailMapper;
 import com.fjhx.params.water.WaterVo;
 import com.fjhx.service.water.WaterDetailService;
 import com.fjhx.utils.UserClientUtil;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * <p>
@@ -64,4 +73,198 @@ public class WaterDetailServiceImpl extends ServiceImpl<WaterDetailMapper, Water
         return list;
     }
 
+    @Override
+    public Map<String, Object> pickingStatistics(Condition condition) {
+
+        QueryWrapper<Object> wrapper = getPickingWrapper(condition);
+
+        List<Map<String, Object>> pickingList = baseMapper.getPickingList(wrapper);
+        if (pickingList.size() > 0) {
+            Map<Long, String> userMap = UserClientUtil.getUserNameMapFunctionLong(pickingList, item -> Convert.toLong(item.get("userId")));
+            for (Map<String, Object> map : pickingList) {
+                map.put("userName", userMap.get(Convert.toLong(map.get("userId"))));
+            }
+        }
+
+        HashMap<String, Object> result = new HashMap<>();
+
+        // 按物料属性分组
+        Map<String, List<Map<String, Object>>> groupByStatistics = pickingList.stream().collect(
+                Collectors.groupingBy(item -> item.get("materialType").toString()));
+
+        // 统计面料
+        HashMap<String, Object> fabricStatistics = new HashMap<>();
+        fabricStatistics.put("total", 0);
+        fabricStatistics.put("length", BigDecimal.ZERO);
+        fabricStatistics.put("measureArea", BigDecimal.ZERO);
+        fabricStatistics.put("money", BigDecimal.ZERO);
+
+        // 面料属性属性
+        List<Map<String, Object>> fabricTree = new ArrayList<>();
+
+        // 构建前端所需参数
+        for (Map.Entry<String, List<Map<String, Object>>> entry : groupByStatistics.entrySet()) {
+            String key = entry.getKey();
+            List<Map<String, Object>> value = entry.getValue();
+
+            // 墨水统计
+            if (key.equals("3")) {
+                // 墨水统计
+                HashMap<Object, Object> inkStatistics = new HashMap<>();
+                // 件数
+                inkStatistics.put("total", value.size());
+                // 公斤
+                inkStatistics.put("weight", value.stream().map(item -> (BigDecimal) item.get("changeNum"))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add));
+                // 金额
+                inkStatistics.put("money", value.stream()
+                        .map(item -> ((BigDecimal) item.get("changeNum")).multiply((BigDecimal) item.get("materialPrice")))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, RoundingMode.HALF_UP));
+
+                result.put("inkStatistics", inkStatistics);
+
+                // 墨水领料明细
+                List<HashMap<String, Object>> inkDetails = new ArrayList<>(value.stream().collect(Collectors.toMap(
+                        item -> item.get("userId").toString(), // 根据用户id分组
+                        item -> { // 统计单条数据
+                            HashMap<String, Object> map = new HashMap<>();
+                            map.put("userId", item.get("userId"));
+                            map.put("userName", item.get("userName"));
+                            map.put("total", 1);
+                            map.put("weight", item.get("changeNum"));
+                            map.put("money", ((BigDecimal) item.get("changeNum"))
+                                    .multiply((BigDecimal) item.get("materialPrice")).setScale(2, RoundingMode.HALF_UP));
+                            return map;
+                        },
+                        (v1, v2) -> { // 当有多条用户记录时，统计数据
+                            v1.put("total", ((Integer) v1.get("total")) + 1);
+                            v1.put("weight", ((BigDecimal) v1.get("weight")).add((BigDecimal) v2.get("weight")));
+                            v1.put("money", ((BigDecimal) v1.get("money")).add((BigDecimal) v2.get("money")));
+                            return v1;
+                        })).values());
+
+                result.put("inkDetails", inkDetails);
+            }
+            // 面料统计
+            else {
+                // 卷数
+                int size = value.size();
+                // 米数
+                BigDecimal length = value.stream().map(item -> (BigDecimal) item.get("changeNum")).reduce(BigDecimal.ZERO, BigDecimal::add);
+                // 面积
+                BigDecimal measureArea = value.stream().map(item -> ((BigDecimal) item.get("changeNum"))
+                                .multiply(BigDecimal.valueOf((float) item.get("materialWidth")))
+                                .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, RoundingMode.HALF_UP);
+                // 金额
+                BigDecimal money = value.stream().map(item -> ((BigDecimal) item.get("changeNum")).multiply((BigDecimal) item.get("materialPrice")))
+                        .reduce(BigDecimal.ZERO, BigDecimal::add).setScale(2, RoundingMode.HALF_UP);
+
+                // 添加到面料统计
+                fabricStatistics.put("total", (Integer) fabricStatistics.get("total") + size);
+                fabricStatistics.put("length", ((BigDecimal) fabricStatistics.get("length")).add(length));
+                fabricStatistics.put("measureArea", ((BigDecimal) fabricStatistics.get("measureArea")).add(measureArea));
+                fabricStatistics.put("money", ((BigDecimal) fabricStatistics.get("money")).add(money));
+
+                // 构建树形
+                Map<String, Object> attribute = new HashMap<>();
+                attribute.put("materialType", key);
+                attribute.put("total", size);
+                attribute.put("length", length);
+                attribute.put("measureArea", measureArea);
+                attribute.put("money", money);
+                attribute.put("name", MaterialTypeEnum.getName(Convert.toInt(key)));
+
+                // 查询子集
+                List<HashMap<String, Object>> children = new ArrayList<>(value.stream().collect(Collectors.toMap(
+                        item -> item.get("userId").toString(), // 根据用户id分组
+                        item -> { // 统计单条数据
+                            HashMap<String, Object> map = new HashMap<>();
+                            map.put("userId", item.get("userId"));
+                            map.put("name", item.get("userName"));
+                            map.put("total", 1); // 数量
+                            map.put("length", item.get("changeNum")); // 米数
+
+                            // 面积
+                            map.put("measureArea", ((BigDecimal) item.get("changeNum"))
+                                    .multiply(BigDecimal.valueOf((float) item.get("materialWidth")))
+                                    .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP)); // 面积
+                            // 金额
+                            map.put("money", ((BigDecimal) item.get("changeNum")).multiply((BigDecimal) item.get("materialPrice"))
+                                    .setScale(2, RoundingMode.HALF_UP));
+                            return map;
+                        },
+                        (v1, v2) -> { // 当有多条用户记录时，统计数据
+                            v1.put("total", ((Integer) v1.get("total")) + 1);
+                            v1.put("length", ((BigDecimal) v1.get("length")).add((BigDecimal) v2.get("length")));
+                            v1.put("measureArea", ((BigDecimal) v1.get("measureArea")).add((BigDecimal) v2.get("measureArea")));
+                            v1.put("money", ((BigDecimal) v1.get("money")).add((BigDecimal) v2.get("money")));
+                            return v1;
+                        })).values());
+
+                attribute.put("children", children);
+
+                fabricTree.add(attribute);
+            }
+        }
+
+        // 面料统计
+        result.put("fabricStatistics", fabricStatistics);
+
+        // 面料树形
+        result.put("fabricTree", fabricTree);
+
+        return result;
+    }
+
+    @Override
+    public Map<String, Integer> pickingTypeStatistics(Condition condition) {
+        Integer materialType = condition.getInt("materialType");
+        Long userId = condition.getLong("userId");
+
+        QueryWrapper<Object> wrapper = getPickingWrapper(condition);
+        wrapper.eq(ObjectUtil.isNotEmpty(materialType), "m.technology_type", materialType);
+        wrapper.eq(ObjectUtil.isNotEmpty(userId), "wd.oper_user_id", userId);
+
+        return baseMapper.pickingTypeStatistics(wrapper);
+    }
+
+    @Override
+    public Page<Map<String, Object>> pickingPage(Condition condition) {
+        Integer materialType = condition.getInt("materialType");
+        Long userId = condition.getLong("userId");
+        Integer type = condition.getInt("type");
+
+        QueryWrapper<Object> wrapper = getPickingWrapper(condition);
+        wrapper.eq(ObjectUtil.isNotEmpty(materialType), "m.technology_type", materialType);
+        wrapper.eq(ObjectUtil.isNotEmpty(userId), "wd.oper_user_id", userId);
+        wrapper.eq(ObjectUtil.isNotEmpty(type), "wd.type", type);
+
+        Page<Map<String, Object>> page = baseMapper.pickingPage(condition.getPage(), wrapper);
+        List<Map<String, Object>> records = page.getRecords();
+        if (records.size() == 0) {
+            return page;
+        }
+        Map<Long, String> userMap = UserClientUtil.getUserNameMapFunctionLong(records, item -> Convert.toLong(item.get("operUserId")));
+        for (Map<String, Object> map : records) {
+            map.put("realName", userMap.get(Convert.toLong(map.get("operUserId"))));
+        }
+
+        return page;
+    }
+
+    private QueryWrapper<Object> getPickingWrapper(Condition condition) {
+        Date beginTime = condition.getBeginTime();
+        Date endTime = condition.getEndTime();
+
+        QueryWrapper<Object> wrapper = Wrappers.query();
+        wrapper.in("wd.type",
+                        OutTypeEnum.ISSUE.getType(),
+                        OutTypeEnum.REPLENISHMENT.getType(),
+                        InTypeEnum.BACK.getType())
+                .eq("wd.del_flag", StatusConstant.NOT_DELETED)
+                .between(ObjectUtil.isAllNotEmpty(beginTime, endTime), "wd.create_time", beginTime, endTime);
+        return wrapper;
+    }
+
 }

hx-service/storage-restructure/src/main/java/com/fjhx/service/water/impl/WaterTagServiceImpl.java

@@ -3,6 +3,7 @@ package com.fjhx.service.water.impl;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.lang.UUID;
+import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -61,9 +62,12 @@ public class WaterTagServiceImpl extends ServiceImpl<WaterTagMapper, WaterTag> i
 
         Long waterBatchId = condition.getLong("waterBatchId");
         Integer hadPrinter = condition.getInt("hadPrinter");
+        Date beginTime = condition.getBeginTime();
+        Date endTime = condition.getEndTime();
         String keyword = condition.getKeyword();
 
         QueryWrapper<WaterTag> wrapper = Wrappers.<WaterTag>query()
+                .between(ObjectUtil.isAllNotEmpty(beginTime, endTime), "wt.create_time", beginTime, endTime)
                 .eq(waterBatchId != null, "wt.water_batch_id", waterBatchId)
                 .eq(hadPrinter != null, "wt.had_printer", hadPrinter)
                 .and(keyword != null, q -> q

hx-service/storage/src/main/java/com/fjhx/stock/service/StockBackPlanService.java

@@ -17,7 +17,7 @@ import java.util.Map;
  */
 public interface StockBackPlanService extends BaseService<StockBackPlan> {
 
-    void getScheduleTask();
+    void getScheduleTask(int offset);
 
     void statisticsScheduleDateTask(int offset);
 

hx-service/storage/src/main/java/com/fjhx/stock/service/impl/StockBackPlanServiceImpl.java

@@ -39,8 +39,9 @@ public class StockBackPlanServiceImpl extends ServiceImpl<StockBackPlanMapper, S
     @Autowired
     private StockBackPlanDetailsService stockBackPlanDetailsService;
 
+    @Transactional(rollbackFor = Exception.class)
     @Override
-    public void getScheduleTask() {
+    public void getScheduleTask(int offset) {
 
         synchronized (obj) {
 
@@ -50,7 +51,7 @@ public class StockBackPlanServiceImpl extends ServiceImpl<StockBackPlanMapper, S
             // 请求v3接口获取所有人领料信息
             Date date = new Date();
 
-            String beginDate = DateUtil.format(DateUtil.offsetDay(date, -4), "yyyy-MM-dd 00:00:00");
+            String beginDate = DateUtil.format(DateUtil.offsetDay(date, -offset), "yyyy-MM-dd 00:00:00");
             String endDate = DateUtil.format(date, "yyyy-MM-dd 23:59:59");
 
             String url = "http://mes.cfmfactory.com:8087/MesWeb/planPersonOutAction.do?action=list&beginDate="
@@ -84,9 +85,8 @@ public class StockBackPlanServiceImpl extends ServiceImpl<StockBackPlanMapper, S
                 addOrEditFlagMap(flagMap, distributor, plantotalsquare, planDate, material, newDate);
 
                 // 打纸人员工号添加领料记录标记
-                if (ObjectUtil.isNotEmpty(paperMan) && !Objects.equals(paperMan, "0")) {
-                    addOrEditFlagMap(flagMap, paperMan, plantotalsquare, planDate, "热转印纸", newDate);
-                }
+                addOrEditFlagMap(flagMap, paperMan, plantotalsquare, planDate, "热转印纸", newDate);
+
             });
 
 //        List<Map<String, Object>> list = baseMapper.getList(Wrappers.<Scheduling>lambdaQuery()
@@ -211,6 +211,10 @@ public class StockBackPlanServiceImpl extends ServiceImpl<StockBackPlanMapper, S
      * 赋值排班数据
      */
     private void addOrEditFlagMap(Map<String, StockBackPlan> flagMap, String jobNo, BigDecimal plantotalsquare, String planDate, String material, Date date) {
+        if (Objects.equals(jobNo, "0")) {
+            return;
+        }
+
         String key = jobNo + material + planDate;
         StockBackPlan stockBackPlan = flagMap.get(key);
 

hx-service/storage/src/main/java/com/fjhx/stock/service/impl/StockBackServiceImpl.java

@@ -318,7 +318,15 @@ public class StockBackServiceImpl extends ServiceImpl<StockBackMapper, StockBack
         List<StockBackPlanDetails> list = stockBackPlanDetailsService.list(
                 Wrappers.<StockBackPlanDetails>lambdaQuery()
                         .between(StockBackPlanDetails::getPlanTime, beginTime, endTime)
-                        .eq(ObjectUtil.isNotEmpty(jobNo), StockBackPlanDetails::getJobNo, jobNo));
+                        .func(q -> {
+                            if (ObjectUtil.isNotEmpty(jobNo)) {
+                                q.eq(StockBackPlanDetails::getJobNo, jobNo);
+                            } else {
+                                List<Object> jobNoList = userList().stream().map(item -> item.get("jobNo")).collect(Collectors.toList());
+                                q.in(StockBackPlanDetails::getJobNo, jobNoList);
+                            }
+                        })
+        );
 
         for (StockBackPlanDetails item : list) {
             result.setScheduleArea(result.getScheduleArea().add(item.getQuantity()));

hx-service/storage/src/main/java/com/fjhx/task/controller/ScheduleTaskController.java

@@ -44,19 +44,19 @@ public class ScheduleTaskController {
      * 获取排班面积
      */
     @Scheduled(cron = "0 0/5 * * * ?")
-//    @Scheduled(cron = "0 * * * * ?")
+//    @Scheduled(cron = "0 32 17 * * ?")
     private void getScheduleTask() {
         if (BladeApplication.isLocalDev()) {
             return;
         }
-        stockBackPlanService.getScheduleTask();
+        stockBackPlanService.getScheduleTask(2);
     }
 
     /**
      * 统计排班数据
      */
     @Scheduled(cron = "30 0/5 * * * ?")
-//    @Scheduled(cron = "0 52 11 * * ?")
+//    @Scheduled(cron = "0 35 17 * * ?")
     private void statisticsScheduleDateTask() {
         if (BladeApplication.isLocalDev()) {
             return;