服务指令-请领流程指令工单

nursing-unit-services/nu-services-biz/src/main/java/com/nu/modules/biz/invoicing/order/service/impl/InvoicingOrdersServiceImpl.java

@@ -1,17 +1,22 @@
 package com.nu.modules.biz.invoicing.order.service.impl;
 
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-
 import com.nu.entity.InvoicingOrdersEntity;
+import com.nu.modules.biz.care.datapool.entity.CareDataPoolSub;
 import com.nu.modules.biz.invoicing.order.entity.InvoicingOrders;
 import com.nu.modules.biz.invoicing.order.mapper.InvoicingOrdersMapper;
+import com.nu.modules.biz.invoicing.order.service.IEmpOrdersService;
 import com.nu.modules.biz.invoicing.order.service.IInvoicingOrdersService;
-import com.nu.modules.care.api.IInvoicingOrdersApi;
+import com.nu.modules.biz.invoicing.order.service.IQlOrdersService;
+import com.nu.modules.biz.invoicing.order.service.IThOrdersService;
+import com.nu.modules.invoicing.api.IInvoicingOrdersApi;
 import com.nu.modules.config.sendorderrule.entity.SendOrderRule;
 import com.nu.modules.config.sendorderrule.entity.SendOrderRuleSub;
 import com.nu.modules.config.sendorderrule.service.ISendOrderRuleService;
 import com.nu.modules.config.sendorderrule.service.ISendOrderRuleSubService;
+import com.nu.modules.sysconfig.ISysConfigApi;
 import lombok.extern.slf4j.Slf4j;
 import org.jeecg.common.api.vo.Result;
 import org.springframework.beans.BeanUtils;
@@ -22,7 +27,7 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 /**
- * @Description: 仓库类服务指令工单主表
+ * @Description: 仓库类服务指令工单
  * @Author: caolei
  * @Date: 2025-12-1
  * @Version: V1.0
@@ -32,61 +37,11 @@ import java.util.stream.Collectors;
 public class InvoicingOrdersServiceImpl extends ServiceImpl<InvoicingOrdersMapper, InvoicingOrders> implements IInvoicingOrdersService, IInvoicingOrdersApi {
 
     @Autowired
-    ISendOrderRuleService sendOrderRuleService;
+    IQlOrdersService qlOrdersService;
     @Autowired
-    ISendOrderRuleSubService sendOrderRuleSubService;
+    IThOrdersService thOrdersService;
-    SendOrderRule sendOrderRule;
+    @Autowired
-    List<SendOrderRuleSub> ruleSubList;
+    IEmpOrdersService empOrdersService;
-
-    /**
-     * 获取派单规则
-     */
-    private void getSendOrderRule(){
-        if(sendOrderRule == null){
-            QueryWrapper<SendOrderRule> qw = new QueryWrapper<>();
-            qw.eq("iz_enabled", "Y");
-            sendOrderRule = sendOrderRuleService.getOne(qw);
-            QueryWrapper<SendOrderRuleSub> subqw = new QueryWrapper<>();
-            subqw.eq("iz_enabled", "Y");
-            subqw.eq("main_id", sendOrderRule.getId());
-            subqw.orderByAsc("sort");
-            ruleSubList = sendOrderRuleSubService.list(subqw);
-        }
-    }
-
-    /**
-     * 获取在线，有指令权限的员工，并获取员工的接单上限、收益、服务时长、单次
-     *
-     * @param directiveId
-     * @return
-     */
-    private List<InvoicingOrders> getEmpPermissionAndOnline(String directiveId, Date startTime) {
-        return baseMapper.getEmpPermissionAndOnline(directiveId, startTime);
-    }
-
-    /**
-     * 获取长者指定所有护理员
-     *
-     * @param customerId
-     * @return
-     */
-    private Map<String, String> getEmpOrderly(String customerId) {
-        Map<String, String> map = null;
-        InvoicingOrders orders = baseMapper.getEmpOrderly(customerId);
-        if (orders != null) {
-            String empIds = orders.getEmployeeIds();
-            if (empIds != null && !empIds.equals("")) {
-                String[] pairs = empIds.split(",");
-                if (pairs.length > 0) {
-                    map = new HashMap<>();
-                    for (String pair : pairs) {
-                        map.put(pair, pair);
-                    }
-                }
-            }
-        }
-        return map;
-    }
 
     /**
      * 指令池批量生成工单-定时调用
@@ -95,8 +50,6 @@ public class InvoicingOrdersServiceImpl extends ServiceImpl<InvoicingOrdersMappe
      */
     @Override
     public Result<?> generateOrdersBatch() {
-        //获取派单规则
-        getSendOrderRule();
         List<InvoicingOrders> ordersList = baseMapper.queryDataPoolList(null);
         for (int i = 0; i < ordersList.size(); i++) {
             InvoicingOrders orders = ordersList.get(i);
@@ -112,337 +65,219 @@ public class InvoicingOrdersServiceImpl extends ServiceImpl<InvoicingOrdersMappe
      */
     private void generateOrders(InvoicingOrders orders) {
         //获取满足条件的员工
-        InvoicingOrders employee = employeeScreening(orders.getDirectiveId(), orders.getCustomerId(), orders.getStartTime());
+        InvoicingOrders employee = empOrdersService.employeeScreening(orders.getDirectiveId(), orders.getCustomerId(), orders.getStartTime());
         if (employee != null) {
             orders.setEmployeeId(employee.getEmployeeId());
             orders.setEmployeeName(employee.getEmployeeName());
             orders.setIzStart("N");
             orders.setIzFinish("N");
+            orders.setIzRollback("N");
             this.save(orders);//生成工单主表
         }
     }
 
     /**
-     * 获取满足条件的员工
+     * 点击开始
-     *
+     * @param invoicingOrdersEntity
-     * @return
      */
-    private InvoicingOrders employeeScreening(String directiveId, String customerId, Date startTime) {
-        if (sendOrderRule.getRuleCode().equals("1")) {
-            //按优先级
-            return getByPriority(directiveId, customerId, startTime);
-        }
-        if (sendOrderRule.getRuleCode().equals("2")) {
-            //按人头
-            return getByHeadCount(directiveId, customerId, startTime);
-        }
-        return null;
-    }
-
-    /**
-     * 优先级派单
-     *
-     * @return
-     */
-    private InvoicingOrders getByPriority(String directiveId, String customerId, Date startTime) {
-        List<InvoicingOrders> empList = getEmpPermissionAndOnline(directiveId, startTime);
-        if (empList.size() > 0) {
-            if(ruleSubList.size()>0){
-                for(SendOrderRuleSub ruleSub : ruleSubList){
-                    switch (ruleSub.getRuleCode()) {
-                        case 1:
-                            //空闲积分
-                            sortByIzFree(empList,ruleSub.getCoefficient());
-                            break;
-                        case 2:
-                            //专员积分
-                            sortByOrderly(empList,ruleSub.getCoefficient(),customerId);
-                            break;
-                        case 3:
-                            //单次积分
-                            sortByNumAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 4:
-                            //收益积分
-                            sortByPriceAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 5:
-                            //服务时长积分
-                            sortByDurationAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 6:
-                            //最后接单时间积分
-                            sortByMaxTimeAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 7:
-                            //超出上限积分
-                            sortByLimit(empList,ruleSub.getCoefficient());
-                            break;
-                    }
-                }
-                //获取员工信息
-                sortEmpList(empList);
-                return empList.get(0);
-            }else{
-                //随机获取一个员工
-                Random random = new Random();
-                return empList.get(random.nextInt(empList.size()));
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 按人头派单
-     *
-     * @return
-     */
-    private InvoicingOrders getByHeadCount(String directiveId, String customerId, Date startTime) {
-        List<InvoicingOrders> empList = getEmpPermissionAndOnline(directiveId,startTime);
-        if (empList.size() > 0) {
-            for(int i=0;i<empList.size();i++){
-                InvoicingOrders emp = empList.get(i);
-                System.out.println("员工信息:"+emp.getEmployeeName()+","+emp.getOrderCap()+","+emp.getOrderNum()+","+emp.getTotalDuration()+","+emp.getTotalComPrice()+","+emp.getMaxTime()+","+emp.getOwnCn()+","+emp.getIzFree());
-            }
-
-            //****************获取指定护理员工列表，不指定的排除掉=============================>
-            getByOrderly(empList,customerId);
-
-            if(ruleSubList.size()>0){
-                for(SendOrderRuleSub ruleSub : ruleSubList){
-                    switch (ruleSub.getRuleCode()) {
-                        case 1:
-                            //空闲积分
-                            sortByIzFree(empList,ruleSub.getCoefficient());
-                            break;
-                        case 2:
-                            //单次积分
-                            sortByNumAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 3:
-                            //收益积分
-                            sortByPriceAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 4:
-                            //服务时长积分
-                            sortByDurationAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 5:
-                            //最后接单时间积分
-                            sortByMaxTimeAndSetLevel(empList,ruleSub.getCoefficient());
-                            break;
-                        case 6:
-                            //超出上限积分
-                            sortByLimit(empList,ruleSub.getCoefficient());
-                            break;
-                    }
-                }
-                //获取员工信息
-                sortEmpList(empList);
-                return empList.get(0);
-            }else{
-                //随机获取一个员工
-                Random random = new Random();
-                return empList.get(random.nextInt(empList.size()));
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 通过员工空闲状态来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByIzFree(List<InvoicingOrders> empList, Integer coefficient) {
-        for (int i = 0; i < empList.size(); i++) {
-            InvoicingOrders emp = empList.get(i);
-            if (emp.getIzFree().equals(1)) {
-                Integer empLevel = emp.getLevel();
-                empLevel = empLevel + empList.size() * coefficient; //提高5N等级
-                emp.setLevel(empLevel);
-            }
-        }
-    }
-
-    /**
-     * 通过员工专项指定状态来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByOrderly(List<InvoicingOrders> empList, Integer coefficient, String customerId) {
-        for (int i = 0; i < empList.size(); i++) {
-            InvoicingOrders emp = empList.get(i);
-            String employeeId = emp.getEmployeeId();
-            Map<String, String> orderlyMap = getEmpOrderly(customerId);
-            if (orderlyMap != null) {
-                String orderlyId = orderlyMap.get(employeeId);
-                if (orderlyId != null && !orderlyId.equals("")) {
-                    Integer empLevel = emp.getLevel();
-                    empLevel = empLevel + empList.size() * coefficient; //提高4N等级
-                    emp.setLevel(empLevel);
-                }
-            }
-        }
-    }
-
-    /**
-     * 通过工单次数排序数据来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByNumAndSetLevel(List<InvoicingOrders> empList, Integer coefficient) {
-        // 根据orderNum倒序排序，并为level顺序赋值
-        List<InvoicingOrders> sortedEmployees = empList.stream()
-                .sorted(Comparator.comparing(InvoicingOrders::getOrderNum).reversed())
-                .collect(Collectors.toList());
-
-        // 为level字段顺序赋值1,2,3...
-        for (int i = 0; i < sortedEmployees.size(); i++) {
-            Integer levle = sortedEmployees.get(i).getLevel()*coefficient + i + 1;
-            sortedEmployees.get(i).setLevel(levle);
-        }
-
-        // 如果需要返回新列表，可以返回sortedEmployees
-        // 如果要在原列表上修改，可以清空原列表并添加所有元素
-        empList.clear();
-        empList.addAll(sortedEmployees);
-    }
-
-    /**
-     * 通过总收益排序数据来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByPriceAndSetLevel(List<InvoicingOrders> empList, Integer coefficient) {
-        // 根据totalComPrice倒序排序，并为level顺序赋值
-        List<InvoicingOrders> sortedEmployees = empList.stream()
-                .sorted(Comparator.comparing(InvoicingOrders::getTotalComPrice).reversed())
-                .collect(Collectors.toList());
-
-        // 为level字段顺序赋值1,2,3...
-        for (int i = 0; i < sortedEmployees.size(); i++) {
-            Integer levle = sortedEmployees.get(i).getLevel()*coefficient + i + 1;
-            sortedEmployees.get(i).setLevel(levle);
-        }
-
-        // 如果需要返回新列表，可以返回sortedEmployees
-        // 如果要在原列表上修改，可以清空原列表并添加所有元素
-        empList.clear();
-        empList.addAll(sortedEmployees);
-    }
-
-    /**
-     * 通过服务时长排序数据来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByDurationAndSetLevel(List<InvoicingOrders> empList, Integer coefficient) {
-        // 根据totalDuration倒序排序，并为level顺序赋值
-        List<InvoicingOrders> sortedEmployees = empList.stream()
-                .sorted(Comparator.comparing(InvoicingOrders::getTotalDuration).reversed())
-                .collect(Collectors.toList());
-
-        // 为level字段顺序赋值1,2,3...
-        for (int i = 0; i < sortedEmployees.size(); i++) {
-            Integer levle = sortedEmployees.get(i).getLevel()*coefficient + i + 1;
-            sortedEmployees.get(i).setLevel(levle);
-        }
-
-        // 如果需要返回新列表，可以返回sortedEmployees
-        // 如果要在原列表上修改，可以清空原列表并添加所有元素
-        empList.clear();
-        empList.addAll(sortedEmployees);
-    }
-
-    /**
-     * 通过最后一次接收派单时间排序数据来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByMaxTimeAndSetLevel(List<InvoicingOrders> empList, Integer coefficient) {
-        // 根据maxTime倒序排序，并为level顺序赋值
-        List<InvoicingOrders> sortedEmployees = empList.stream()
-                .sorted(Comparator.comparing(
-                        InvoicingOrders::getMaxTime,
-                        Comparator.nullsLast(Comparator.reverseOrder())
-                ))
-                .collect(Collectors.toList());
-
-        // 为level字段顺序赋值1,2,3...
-        for (int i = 0; i < sortedEmployees.size(); i++) {
-            Integer levle = sortedEmployees.get(i).getLevel()*coefficient + i + 1;
-            sortedEmployees.get(i).setLevel(levle);
-        }
-
-        // 如果需要返回新列表，可以返回sortedEmployees
-        // 如果要在原列表上修改，可以清空原列表并添加所有元素
-        empList.clear();
-        empList.addAll(sortedEmployees);
-    }
-
-    /**
-     * 通过接单上限来排序数据来设置优先级
-     *
-     * @param empList
-     */
-    public void sortByLimit(List<InvoicingOrders> empList, Integer coefficient) {
-        for (int i = 0; i < empList.size(); i++) {
-            //工单超出接单上限，降4N级
-            if (empList.get(i).getOwnCn() >= empList.get(i).getOrderCap()) {
-                Integer levle = empList.get(i).getLevel() + empList.size() * coefficient;
-                empList.get(i).setLevel(levle);
-            }
-        }
-    }
-
-    /**
-     * 按优先级排序数据
-     *
-     * @param empList
-     */
-    public void sortEmpList(List<InvoicingOrders> empList) {
-        //为level顺序
-        List<InvoicingOrders> sortedEmployees = empList.stream()
-                .sorted(Comparator.comparing(InvoicingOrders::getLevel).reversed())
-                .collect(Collectors.toList());
-        // 如果需要返回新列表，可以返回sortedEmployees
-        // 如果要在原列表上修改，可以清空原列表并添加所有元素
-        empList.clear();
-        empList.addAll(sortedEmployees);
-    }
-
-    /**
-     * 获取指定护理员工列表
-     *
-     * @param empList
-     */
-    public void getByOrderly(List<InvoicingOrders> empList, String customerId) {
-        List<InvoicingOrders> newList = new ArrayList();
-        for (int i = 0; i < empList.size(); i++) {
-            InvoicingOrders emp = empList.get(i);
-            String employeeId = emp.getEmployeeId();
-            Map<String, String> orderlyMap = getEmpOrderly(customerId);
-            if (orderlyMap != null) {
-                String orderlyId = orderlyMap.get(employeeId);
-                if (orderlyId != null && !orderlyId.equals("")) {
-                    newList.add(emp);
-                }
-            }
-
-        }
-        empList.clear();
-        empList.addAll(newList);
-        for(int i=0;i<empList.size();i++){
-            InvoicingOrders emp = empList.get(i);
-            System.out.println("获取指定护理员工信息:"+emp.getEmployeeId()+"-"+emp.getEmployeeName());
-        }
-    }
-
     @Override
-    public int insertData(InvoicingOrdersEntity orderEntity) {
+    public Result<String> beginOrder(InvoicingOrdersEntity invoicingOrdersEntity){
-        InvoicingOrders data = new InvoicingOrders();
+        try {
-        BeanUtils.copyProperties(orderEntity,data);
+            Calendar c = Calendar.getInstance();
-        return baseMapper.insert(data);
+            InvoicingOrders entity = new InvoicingOrders();
+            entity.setId(invoicingOrdersEntity.getId());
+            entity.setBeginTime(c.getTime());
+            entity.setIzStart("Y");
+            entity.setUpdateBy(invoicingOrdersEntity.getInitiatorId());
+            entity.setUpdateTime(c.getTime());
+            entity.setBizType(invoicingOrdersEntity.getFlowCode());
+            baseMapper.updateOrder(entity);
+        }catch (Exception e){
+            return Result.error("开始失败："+e.getMessage());
+        }
+        return Result.ok("开始成功");
     }
+
+    /**
+     * 点击完成
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> finishOrder(InvoicingOrdersEntity invoicingOrdersEntity){
+        try {
+            Calendar c = Calendar.getInstance();
+            InvoicingOrders entity = new InvoicingOrders();
+            entity.setId(invoicingOrdersEntity.getId());
+            entity.setFinishTime(c.getTime());
+            entity.setIzFinish("Y");
+            entity.setUpdateBy(invoicingOrdersEntity.getInitiatorId());
+            entity.setUpdateTime(c.getTime());
+            entity.setBizType(invoicingOrdersEntity.getFlowCode());
+            baseMapper.updateOrder(entity);
+        }catch (Exception e){
+            return Result.error("完成失败："+e.getMessage());
+        }
+        return Result.ok("完成成功");
+    }
+
+    /**
+     * 请领流程-请领申请
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowQlsq(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("qlsq")){
+            try{
+                qlOrdersService.flowQlsq(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error("请领申请失败："+e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("请领申请流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 请领流程-重新请领申请
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowQlsqR(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if (code != null && !code.equals("") && code.equals("qlsqr")) {
+            try {
+                qlOrdersService.flowQlsqR(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error("请领重新申请失败："+e.getMessage());
+            }
+        } else {
+            //返回错误信息
+            return Result.error("重新请领申请流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 请领流程-出库
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowQlck(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("qlck")){
+            try {
+                qlOrdersService.flowQlck(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error("请领出库失败："+e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("请领出库流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 请领流程-回退
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowQlht(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("qlht")){
+            try {
+                qlOrdersService.flowQlht(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error("请领回退失败："+e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("请领回退流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 请领流程-作废
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowQlzf(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("qlzf")){
+            try {
+                qlOrdersService.flowQlzf(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error("请领作废失败："+e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("请领作废流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 请领流程-回退作废
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowQlhtzf(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("qlhtzf")){
+            try{
+                qlOrdersService.flowQlhtzf(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error("请领回退作废失败："+e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("请领回退作废流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 单元退货-单元申请
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowDythDysq(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("dyth_dysq")){
+            try{
+                thOrdersService.flowDythDysq(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error(e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("单元退货申请流程编码错误");
+        }
+        return Result.ok();
+    }
+
+    /**
+     * 单元退货-仓库收货
+     * @param invoicingOrdersEntity
+     */
+    @Override
+    public Result<String> flowDythCksh(InvoicingOrdersEntity invoicingOrdersEntity) {
+        String code = invoicingOrdersEntity.getFlowCode();
+        if(code!=null&&!code.equals("")&&code.equals("dyth_cksh")){
+            try{
+                thOrdersService.flowDythCksh(invoicingOrdersEntity);
+            }catch (Exception e){
+                return Result.error(e.getMessage());
+            }
+        }else {
+            //返回错误信息
+            return Result.error("单元退货收货流程编码错误");
+        }
+        return Result.ok();
+    }
+
 }