yangjun
/
nursing_unit_java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

This commit is contained in:
曹磊 2025-12-11 18:02:57 +08:00
parent b6bd61ae82
commit 03f120ca88
1 changed files with 214 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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;
SendOrderRule sendOrderRule;
List<SendOrderRuleSub> ruleSubList;
/**
* 获取派单规则
*/
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;
}
IThOrdersService thOrdersService;
@Autowired
IEmpOrdersService empOrdersService;
/**
* 指令池批量生成工单-定时调用
@ -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);//生成工单主表
}
}
/**
* 获取满足条件的员工
*
* @return
* 点击开始
* @param invoicingOrdersEntity
*/
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) {
InvoicingOrders data = new InvoicingOrders();
BeanUtils.copyProperties(orderEntity,data);
return baseMapper.insert(data);
public Result<String> beginOrder(InvoicingOrdersEntity invoicingOrdersEntity){
try {
Calendar c = Calendar.getInstance();
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();
}
}