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

1、服务超时后，进行转单，最后的提示是当前服务已超时，不可协助执行（应该是转单执行） 

2、开始服务后，其他指令是未开始的状态
3、开始服务后，切换菜单在回到工单里，指令集的数据都是一个，展示的不对了
4、没有整体移动，只移动了一个指令
5、服务指令集：按照其中结束时间最晚的指令作为超时判断依据
6、调整前端判断是否可以点击开始服务、结束服务的字段的代码逻辑处理
7、新增服务指令接口增加逻辑：同一个单元格不允许添加相同的服务指令
This commit is contained in:
1378012178@qq.com 2026-04-07 17:29:51 +08:00
parent 3b688543ae
commit 9d72c3f677
10 changed files with 332 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
nursing-unit-api/src/main/java/com/nu/modules/pad/directiveorder/api/ServiceOrderApi.java
View File

@ -51,17 +51,17 @@ public class ServiceOrderApi {
@ApiOperation(value = "服务指令工单-开始服务", notes = "服务指令工单-开始服务")
@AutoLog(value = "服务指令工单-开始服务", clientType = "app", operateType = 2)
@PostMapping(value = "/startOrder")
public Result<String> startOrder(@RequestBody DirectiveOrderEntity directiveOrderEntity) {
public Result<?> startOrder(@RequestBody DirectiveOrderEntity directiveOrderEntity) {
Map<String, Object> result = directiveOrderApi.startOrder(directiveOrderEntity);
return Result.OK("操作成功！");
return Result.OK(result);
}
@ApiOperation(value = "服务指令工单-结束服务", notes = "服务指令工单-结束服务")
@AutoLog(value = "服务指令工单-结束服务", clientType = "app", operateType = 2)
@PostMapping(value = "/endOrder")
public Result<String> endOrder(@RequestBody DirectiveOrderEntity directiveOrderEntity) {
public Result<?> endOrder(@RequestBody DirectiveOrderEntity directiveOrderEntity) {
Map<String, Object> result = directiveOrderApi.endOrder(directiveOrderEntity);
return Result.OK("操作成功！");
return Result.OK(result);
}

7
nursing-unit-api/src/main/java/com/nu/modules/pad/directiveplan/api/CareDirectiveApi.java
View File

@ -117,14 +117,14 @@ public class CareDirectiveApi {
* @return
*/
@PostMapping(value = "/addDirective")
public Result<CareDirectiveEntity> addDirective(@RequestBody CareDirectiveEntity careDirectiveEntity) {
public Result<?> addDirective(@RequestBody CareDirectiveEntity careDirectiveEntity) {
if (StringUtils.isBlank(careDirectiveEntity.getNuId())) {
return Result.error("未提供护理单元nuId");
}
if (StringUtils.isBlank(careDirectiveEntity.getInstructionTagId())) {
return Result.error("未提供分类标签");
}
return Result.OK(careDirectivePlanApi.addDirective(careDirectiveEntity));
return careDirectivePlanApi.addDirective(careDirectiveEntity);
}
/**
@ -135,6 +135,9 @@ public class CareDirectiveApi {
*/
@PostMapping(value = "/editDirective")
public Result<String> editDirective(@RequestBody CareDirectiveEntity careDirectiveEntity) {
if (StringUtils.isBlank(careDirectiveEntity.getId())) {
return Result.error("未提供id");
}
if (StringUtils.isBlank(careDirectiveEntity.getNuId())) {
return Result.error("未提供护理单元nuId");
}

4
nursing-unit-api/src/main/java/com/nu/modules/pad/directiveplan/api/InvoicingDirectiveApi.java
View File

@ -18,9 +18,9 @@ import java.util.Map;
* @Date: 2025-11-28
* @Version: V1.0
*/
//弃用
@RestController
@RequestMapping("/api/pad/invoicing/directive")
@RequestMapping("/api/pad/invoicing/directive/qiyong")
@Slf4j
public class InvoicingDirectiveApi {

4
nursing-unit-api/src/main/java/com/nu/modules/pad/directiveplan/api/LogisticsDirectiveApi.java
View File

@ -21,9 +21,9 @@ import java.util.Map;
* @Date: 2026-1-6
* @Version: V1.0
*/
//弃用
@RestController
@RequestMapping("/api/pad/logistics/directive")
@RequestMapping("/api/pad/logistics/directive/qiyong")
@Slf4j
public class LogisticsDirectiveApi {

3
nursing-unit-services/nu-services-api/nu-services-local-api/src/main/java/com/nu/modules/care/api/ICareDirectivePlanApi.java
View File

@ -1,6 +1,7 @@
package com.nu.modules.care.api;
import com.nu.entity.*;
import org.jeecg.common.api.vo.Result;
import java.util.List;
import java.util.Map;
@ -8,7 +9,7 @@ import java.util.Map;
public interface ICareDirectivePlanApi {
Map<String,Object> getPlanList(CareDirectiveEntity careDirectiveEntity);
void addBatch(CareDirectiveEntity careDirectiveEntity);
CareDirectiveEntity addDirective(CareDirectiveEntity careDirectiveEntity);
Result<?> addDirective(CareDirectiveEntity careDirectiveEntity);
void editDirective(CareDirectiveEntity careDirectiveEntity);
void deleteDirective(CareDirectiveEntity careDirectiveEntity);
List<DirectiveOrderEntity> queryFuture(CareDirectiveEntity dto);

2
nursing-unit-services/nu-services-biz/src/main/java/com/nu/modules/biz/order/mapper/DirectiveOrderMapper.java
View File

@ -50,6 +50,8 @@ public interface DirectiveOrderMapper extends BaseMapper<DirectiveOrder> {
List<DirectiveOrderEntity> queryOrderList(@Param("entity") DirectiveOrderEntity entity);
List<DirectiveOrderEntity> queryServOrderList(@Param("entity") DirectiveOrderEntity entity);
DirectiveOrderEntity queryOrderNeedDirectiveInfo(@Param("dto") DirectiveOrderEntity entity);
DirectiveOrderEntity queryOrderNeedBaseInfo(@Param("dto") DirectiveOrderEntity entity);
}

87
nursing-unit-services/nu-services-biz/src/main/java/com/nu/modules/biz/order/mapper/xml/DirectiveOrderMapper.xml
View File

@ -554,7 +554,10 @@
t.tplink_down_count,
CASE WHEN t.emp_start_time IS NULL THEN 'N' ELSE 'Y' END AS iz_start,
CASE WHEN t.emp_end_time IS NULL THEN 'N' ELSE 'Y' END AS iz_finish,
dire.preview_file
dire.preview_file,
dire.service_content,
dire.mp3_file,
dire.mp4_file
FROM nu_biz_directive_order t
LEFT JOIN nu_config_service_directive dire on t.directive_id = dire.id
WHERE t.nu_id = #{entity.nuId}
@ -581,19 +584,87 @@
AND t.serv_end_time <![CDATA[ < ]]> NOW()
AND t.emp_start_time IS NULL
</when>
<when test='entity.workType == "5"'>
AND (
( t.serv_end_time >= NOW()
AND t.emp_end_time IS NULL)
OR (t.emp_start_time IS NOT NULL AND t.emp_end_time IS NULL)
)
</when>
</choose>
ORDER BY t.serv_start_time ASC,
CASE WHEN t.service_attribute = 'ds' THEN 0 ELSE 1 END,
CASE WHEN CAST(t.service_duration AS UNSIGNED) = 0 THEN 999999 ELSE CAST(t.service_duration AS UNSIGNED) END
</select>
<select id="queryServOrderList" resultType="com.nu.entity.DirectiveOrderEntity">
SELECT t.id,
t.nu_id,
t.nu_name,
t.elder_id,
t.elder_name,
t.body_tag_ids,
t.body_tag_names,
t.body_tag_price,
t.emotion_tag_ids,
t.emotion_tag_names,
t.emotion_tag_price,
t.employee_id,
t.employee_name,
t.opt_type,
t.employee_ids,
t.employee_names,
t.instruction_id,
t.instruction_name,
t.category_id,
t.category_name,
t.type_id,
t.type_name,
t.directive_id,
t.directive_name,
t.service_attribute,
t.service_duration,
t.toll_price,
t.com_price,
t.serv_start_time,
t.serv_end_time,
t.emp_start_time,
t.emp_end_time,
t.order_start_time,
t.order_end_time,
t.order_status,
t.create_by,
t.create_time,
t.update_by,
t.update_time,
t.del_flag,
t.iz_multi,
t.tplink_path,
t.manually_pic_path,
t.manually_mp4_path,
t.tplink_task_id,
t.tplink_process,
t.tplink_md5,
t.tplink_result_code,
t.tplink_down_count,
dire.preview_file,
dire.service_content,
dire.mp3_file,
dire.mp4_file
FROM nu_biz_directive_order t
INNER JOIN (SELECT DISTINCT sub.serv_start_time
FROM nu_biz_directive_order sub
WHERE sub.nu_id = #{entity.nuId}
AND (
(sub.employee_ids IS NOT NULL AND
SUBSTRING_INDEX(sub.employee_ids, ',', 1) = #{entity.employeeId})
OR (sub.employee_ids IS NULL AND sub.employee_id = #{entity.employeeId})
)
AND (
(sub.serv_end_time >= NOW() AND sub.emp_end_time IS NULL)
OR (sub.emp_start_time IS NOT NULL AND sub.emp_end_time IS NULL)
)) tmp ON t.serv_start_time = tmp.serv_start_time
LEFT JOIN nu_config_service_directive dire on t.directive_id = dire.id
ORDER BY t.serv_start_time ASC,
CASE WHEN t.service_attribute = 'ds' THEN 0 ELSE 1 END,
CASE
WHEN CAST(t.service_duration AS UNSIGNED) = 0 THEN 999999
ELSE CAST(t.service_duration AS UNSIGNED) END
</select>
<select id="queryOrderNeedDirectiveInfo" resultType="com.nu.entity.DirectiveOrderEntity">
SELECT directive.instruction_tag_id as instructionId,
inst.instruction_name,

128
nursing-unit-services/nu-services-biz/src/main/java/com/nu/modules/biz/order/service/impl/DirectiveOrderPadServiceImpl.java
View File

@ -29,6 +29,7 @@ import org.jeecg.common.system.vo.LoginUser;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
@ -75,20 +76,64 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
}
/**
* @param pageNo
* @param pageSize
* @param directiveOrderEntity
* @param req
* @return
*/
@Override
public List<DirectiveOrderEntity> queryOrderList(DirectiveOrderEntity directiveOrderEntity, HttpServletRequest req) {
// 查询原始数据
List<DirectiveOrderEntity> list = baseMapper.queryOrderList(directiveOrderEntity);
List<DirectiveOrderEntity> list = new ArrayList<>();
if (!"5".equals(directiveOrderEntity.getWorkType())) {
list = baseMapper.queryOrderList(directiveOrderEntity);
} else {
//首页工单查询
list = baseMapper.queryServOrderList(directiveOrderEntity);
}
if (CollectionUtils.isEmpty(list)) {
return List.of();
}
// 处理数据，将指令集合并
List<DirectiveOrderEntity> result = mergeDirectiveSet(list);
//单独处理处理一遍指令集的izStart 和 izFinish给前端用
result.stream().forEach(item -> {
if ("Y".equals(item.getIzMulti()) && !CollectionUtils.isEmpty(item.getDirectiveList())) {
List<DirectiveOrderEntity> directiveList = item.getDirectiveList();
if (directiveList.get(0).getEmpStartTime() != null) {
//服务指令集点击开始时是统一开始 所以判断指令集中任一指令 有员工开始时间 就说明都已经开始了
directiveList.stream().forEach(d -> {
d.setIzStart("Y");
});
} else {
//基于if中的说明 指令集中任一指令没开始 就是都没开始 这时需要找到其中最晚的结束时间 用于判断是否超时 没超时就都能开始
Optional<Date> max = directiveList.stream().map(DirectiveOrderEntity::getServEndTime).max(Date::compareTo);
String izStart = "";
if (max.get().before(new Date())) {
//超时 不显示开始 izStart是Y（已经开始）
izStart = "Y";
} else {
//可以点开始 - izStart是N
izStart = "N";
}
for (int i = 0; i < directiveList.size(); i++) {
directiveList.get(i).setIzStart(izStart);
}
}
//处理服务指令是否可以点击结束（查出来的所有数据都是符合点击结束条件的 查的是没超时（或指令集中有未超时）没点结束 或 点了开始没点结束的（这种超时也可以点结束））
//↑↑↑↑所以只需要判断有没有结束时间就行
for (int i = 0; i < directiveList.size(); i++) {
if (directiveList.get(i).getEmpEndTime() != null) {
directiveList.get(i).setIzFinish("Y");
} else {
directiveList.get(i).setIzFinish("N");
}
}
}
});
return result;
}
@ -134,6 +179,16 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
mainEntity.getDirectiveList().add(entity);
} else {
// 非指令集，直接添加到结果中
if (entity.getEmpStartTime() != null) {
entity.setIzStart("Y");
} else {
entity.setIzStart("N");
}
if (entity.getEmpEndTime() != null) {
entity.setIzFinish("Y");
} else {
entity.setIzFinish("N");
}
result.add(entity);
}
}
@ -188,23 +243,39 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
//服务指令集统一开始
DirectiveOrder directiveOrder = baseMapper.selectById(directiveOrderEntity.getId());
//如果已到服务结束时间 不允许点击开始
if (directiveOrder.getServEndTime().before(new Date())) {
if ("N".equals(directiveOrder.getIzMulti()) && directiveOrder.getServEndTime().before(new Date())) {
map.put("success", false);
map.put("message", "当前服务已超时，不可执行");
return map;
} else {
QueryWrapper<DirectiveOrder> qw = new QueryWrapper<>();
qw.eq("nu_id",directiveOrder.getNuId());
qw.eq("serv_start_time", directiveOrder.getServStartTime());
List<DirectiveOrder> list = baseMapper.selectList(qw);
Optional<Date> max = list.stream().map(DirectiveOrder::getServEndTime).max(Date::compareTo);
if (max.get().before(new Date())) {
map.put("success", false);
map.put("message", "当前服务已超时，不可执行");
return map;
}
}
UpdateWrapper<DirectiveOrder> uw = new UpdateWrapper<>();
uw.eq("serv_start_time", directiveOrder.getServStartTime());
directiveOrder.setEmpStartTime(new Date());
DirectiveOrder upData = new DirectiveOrder();
upData.setEmpStartTime(new Date());
if (StringUtils.isEmpty(directiveOrder.getEmployeeIds())) {
//如果未进行转单、协助等操作，此时实际执行人字段都为空 需将实际执行人设置为派单时派发的员工
directiveOrder.setEmployeeIds(directiveOrder.getEmployeeId());
directiveOrder.setEmployeeNames(directiveOrder.getEmployeeNames());
upData.setEmployeeIds(directiveOrder.getEmployeeId());
upData.setEmployeeNames(directiveOrder.getEmployeeNames());
}
baseMapper.update(directiveOrder, uw);
baseMapper.update(upData, uw);
// QueryWrapper<DirectiveOrderInfo> queryWrapper = new QueryWrapper<>();
// List<DirectiveOrderInfo> list = directiveOrderInfoMapper.selectList(queryWrapper);
@ -217,13 +288,19 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
@Override
public Map<String, Object> endOrder(DirectiveOrderEntity directiveOrderEntity) {
Map<String, Object> map = new HashMap<>();
DirectiveOrder directiveOrder = baseMapper.selectById(directiveOrderEntity.getId());
if (directiveOrder.getEndTime() != null) {
map.put("success", false);
map.put("message", "服务已结束");
return map;
}
directiveOrder.setEmpEndTime(new Date());
baseMapper.updateById(directiveOrder);
// List<DirectiveOrderInfo> list = directiveOrderInfoMapper.selectList(new QueryWrapper<DirectiveOrderInfo>().eq("main_id", directiveOrder.getId()));
Map<String, Object> map = new HashMap<>();
map.put("success", true);
map.put("message", "操作成功");
// map.put("directiveOrder", directiveOrder);
@ -332,13 +409,25 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
DirectiveOrder beforeData = baseMapper.selectById(dto.getId());
//如果已点击开始 不允许转单
if (beforeData.getEmpStartTime() != null) {
return Result.error("当前服务已开始，不可转单");
}
if (beforeData.getServEndTime().before(new Date())) {
return Result.error("当前服务已超时，不可协助执行");
if ("N".equals(beforeData.getIzMulti()) && beforeData.getServEndTime().before(new Date())) {
return Result.error("当前服务已超时，不可转单");
} else {
QueryWrapper<DirectiveOrder> qw = new QueryWrapper<>();
qw.eq("nu_id",beforeData.getNuId());
qw.eq("serv_start_time", beforeData.getServStartTime());
List<DirectiveOrder> list = baseMapper.selectList(qw);
Optional<Date> max = list.stream().map(DirectiveOrder::getServEndTime).max(Date::compareTo);
if (max.get().before(new Date())) {
return Result.error("当前服务已超时，不可转单");
}
}
UpdateWrapper<DirectiveOrder> uw = new UpdateWrapper<>();
@ -382,8 +471,19 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
return Result.error("当前服务已开始，不可协助执行");
}
if (beforeData.getServEndTime().before(new Date())) {
if ("N".equals(beforeData.getIzMulti()) && beforeData.getServEndTime().before(new Date())) {
return Result.error("当前服务已超时，不可协助执行");
} else {
QueryWrapper<DirectiveOrder> qw = new QueryWrapper<>();
qw.eq("nu_id",beforeData.getNuId());
qw.eq("serv_start_time", beforeData.getServStartTime());
List<DirectiveOrder> list = baseMapper.selectList(qw);
Optional<Date> max = list.stream().map(DirectiveOrder::getServEndTime).max(Date::compareTo);
if (max.get().before(new Date())) {
return Result.error("当前服务已超时，不可协助执行");
}
}
UpdateWrapper<DirectiveOrder> uw = new UpdateWrapper<>();
@ -425,7 +525,7 @@ public class DirectiveOrderPadServiceImpl extends ServiceImpl<DirectiveOrderMapp
*/
@Override
public Result<String> generateOrdersInstant(DirectiveOrderEntity directiveOrderEntity) {
String empId = "2028395421069524993";//王伟东
String empId = "2026167502440022019";//王伟东
Date startTime = new Date();
String nuId = directiveOrderEntity.getNuId();

209
nursing-unit-services/nu-services-biz/src/main/java/com/nu/modules/biz/plan/care/service/impl/CareDirectivePlanServiceImpl.java
View File

@ -4,6 +4,7 @@ import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.nu.entity.*;
import com.nu.modules.biz.datapool.service.ICareDataPoolService;
import com.nu.modules.biz.order.entity.DirectiveOrder;
import com.nu.modules.biz.plan.care.entity.DirectivePlanChangeStatus;
import com.nu.modules.biz.plan.care.service.IDirectivePlanChangeStatusService;
import com.nu.modules.biz.plan.care.service.IDirectivePlanLogService;
@ -13,6 +14,7 @@ import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.vo.LoginUser;
import org.springframework.beans.BeanUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@ -92,7 +94,6 @@ public class CareDirectivePlanServiceImpl extends ServiceImpl<CareDirectivePlanM
resMap.put("serviceList", planList);//服务指令计划
//即时指令
careDirectiveEntity.setQueryType("instant");
careDirectiveEntity.setInstructionTagId(null);
List<CareDirectivePlan> instantList = baseMapper.list(careDirectiveEntity);
resMap.put("instantList", instantList);
ElderTagPlan elderTag = new ElderTagPlan();
@ -137,7 +138,20 @@ public class CareDirectivePlanServiceImpl extends ServiceImpl<CareDirectivePlanM
}
@Override
public CareDirectiveEntity addDirective(CareDirectiveEntity careDirectiveEntity) {
public Result<?> addDirective(CareDirectiveEntity careDirectiveEntity) {
//同一个单元格不允许添加相同服务指令
{
QueryWrapper<CareDirectivePlan> qw = new QueryWrapper<>();
qw.eq("nu_id", careDirectiveEntity.getNuId());
qw.eq("start_time", careDirectiveEntity.getStartTime());
qw.eq("instruction_tag_id", careDirectiveEntity.getInstructionTagId());
qw.eq("directive_id", careDirectiveEntity.getDirectiveId());
List<CareDirectivePlan> list = baseMapper.selectList(qw);
if (!CollectionUtils.isEmpty(list)) {
return Result.error("请勿添加相同的服务指令");
}
}
CareDirectivePlan careDirectivePlan = new CareDirectivePlan();
BeanUtils.copyProperties(careDirectiveEntity, careDirectivePlan);
if ("5".equals(careDirectivePlan.getCycleTypeId()) && StringUtils.isBlank(careDirectivePlan.getCycleValue())) {
@ -230,7 +244,7 @@ public class CareDirectivePlanServiceImpl extends ServiceImpl<CareDirectivePlanM
// directivePlanLogService.batchInsert(new Date(), sysUser, list);
// }
return careDirectiveEntity;
return Result.ok();
//单一指令生成到数据池
// dataPoolServiceImpl.generateDataPool(careDirectivePlan);
@ -242,97 +256,116 @@ public class CareDirectivePlanServiceImpl extends ServiceImpl<CareDirectivePlanM
CareDirectivePlan careDirectivePlan = new CareDirectivePlan();
BeanUtils.copyProperties(careDirectiveEntity, careDirectivePlan);
CareDirectivePlan entity = baseMapper.selectById(careDirectiveEntity.getId());
baseMapper.deleteByIdPhysic(careDirectiveEntity.getId());
if ("5".equals(careDirectivePlan.getCycleTypeId()) && StringUtils.isBlank(careDirectivePlan.getCycleValue())) {
//临时一次 需要处理 执行时间（定时更新快照任务处理的服务指令最近时间（目前是6分钟） + 5秒） 如果当前时间比startTime+执行时间早 则今天执行 否则明天执行
String startTime = careDirectivePlan.getStartTime(); // 格式：01:55
//需要先判断是挪动 还是其它
//挪动的话会修改
if (!entity.getPositioning().equals(careDirectiveEntity.getPositioning()) || !entity.getPositioningLong().equals(careDirectiveEntity.getPositioningLong())) {
CareDirectivePlan upData = new CareDirectivePlan();
upData.setPositioning(careDirectiveEntity.getPositioning());
upData.setPositioningLong(careDirectiveEntity.getPositioningLong());
// 获取当前时间
Date now = new Date();
Calendar nowCalendar = Calendar.getInstance();
nowCalendar.setTime(now);
// 解析 startTime
String[] timeParts = startTime.split(":");
int startHour = Integer.parseInt(timeParts[0]);
int startMinute = Integer.parseInt(timeParts[1]);
// 创建一个今天 startTime 的时间点
Calendar startCalendar = Calendar.getInstance();
startCalendar.set(Calendar.HOUR_OF_DAY, startHour);
startCalendar.set(Calendar.MINUTE, startMinute);
startCalendar.set(Calendar.SECOND, 0);
startCalendar.set(Calendar.MILLISECOND, 0);
// 将 startTime 往前推6分钟5秒
startCalendar.add(Calendar.MINUTE, -6);
startCalendar.add(Calendar.SECOND, -5);
// 获取往前推后的时间点
Date targetTime = startCalendar.getTime();
// 比较当前时间与目标时间
Date optTime;
if (now.before(targetTime)) {
// 当前时间小于目标时间，设置为当前时间
optTime = now;
} else {
// 否则设置为第二天（当前时间的第二天）
Calendar tomorrowCalendar = Calendar.getInstance();
tomorrowCalendar.setTime(now);
tomorrowCalendar.add(Calendar.DAY_OF_MONTH, 1);
optTime = tomorrowCalendar.getTime();
}
careDirectivePlan.setOptTime(optTime);
}
baseMapper.insert(careDirectivePlan);
//如果nuId+分类标签+单元格坐标下是否已有数据 需要将所有数据改为指令集 否则设置为非指令集
//处理旧的单元格
{
QueryWrapper<CareDirectivePlan> qw = new QueryWrapper<>();
qw.eq("nu_id", careDirectivePlan.getNuId());
qw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
qw.eq("positioning", entity.getPositioning());
qw.eq("positioning_long", entity.getPositioningLong());
List<CareDirectivePlan> list = baseMapper.selectList(qw);
UpdateWrapper<CareDirectivePlan> uw = new UpdateWrapper<>();
uw.eq("nu_id", careDirectivePlan.getNuId());
uw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
uw.eq("nu_id", careDirectiveEntity.getNuId());
uw.eq("instruction_tag_id", careDirectiveEntity.getInstructionTagId());
uw.eq("positioning", entity.getPositioning());
uw.eq("positioning_long", entity.getPositioningLong());
CareDirectivePlan upData = new CareDirectivePlan();
if (CollectionUtils.isEmpty(list) || list.size() == 1) {
upData.setIzMulti("N");
baseMapper.update(upData, uw);
} else {
upData.setIzMulti("Y");
baseMapper.update(upData, uw);
}
}
//处理新的单元格
{
QueryWrapper<CareDirectivePlan> qw = new QueryWrapper<>();
qw.eq("nu_id", careDirectivePlan.getNuId());
qw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
qw.eq("positioning", careDirectivePlan.getPositioning());
qw.eq("positioning_long", careDirectivePlan.getPositioningLong());
List<CareDirectivePlan> list = baseMapper.selectList(qw);
UpdateWrapper<CareDirectivePlan> uw = new UpdateWrapper<>();
uw.eq("nu_id", careDirectivePlan.getNuId());
uw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
uw.eq("positioning", careDirectivePlan.getPositioning());
uw.eq("positioning_long", careDirectivePlan.getPositioningLong());
CareDirectivePlan upData = new CareDirectivePlan();
if (CollectionUtils.isEmpty(list) || list.size() == 1) {
upData.setIzMulti("N");
baseMapper.update(upData, uw);
} else {
upData.setIzMulti("Y");
baseMapper.update(upData, uw);
baseMapper.update(upData, uw);
} else {
baseMapper.deleteByIdPhysic(careDirectiveEntity.getId());
if ("5".equals(careDirectivePlan.getCycleTypeId()) && StringUtils.isBlank(careDirectivePlan.getCycleValue())) {
//临时一次 需要处理 执行时间（定时更新快照任务处理的服务指令最近时间（目前是6分钟） + 5秒） 如果当前时间比startTime+执行时间早 则今天执行 否则明天执行
String startTime = careDirectivePlan.getStartTime(); // 格式：01:55
// 获取当前时间
Date now = new Date();
Calendar nowCalendar = Calendar.getInstance();
nowCalendar.setTime(now);
// 解析 startTime
String[] timeParts = startTime.split(":");
int startHour = Integer.parseInt(timeParts[0]);
int startMinute = Integer.parseInt(timeParts[1]);
// 创建一个今天 startTime 的时间点
Calendar startCalendar = Calendar.getInstance();
startCalendar.set(Calendar.HOUR_OF_DAY, startHour);
startCalendar.set(Calendar.MINUTE, startMinute);
startCalendar.set(Calendar.SECOND, 0);
startCalendar.set(Calendar.MILLISECOND, 0);
// 将 startTime 往前推6分钟5秒
startCalendar.add(Calendar.MINUTE, -6);
startCalendar.add(Calendar.SECOND, -5);
// 获取往前推后的时间点
Date targetTime = startCalendar.getTime();
// 比较当前时间与目标时间
Date optTime;
if (now.before(targetTime)) {
// 当前时间小于目标时间，设置为当前时间
optTime = now;
} else {
// 否则设置为第二天（当前时间的第二天）
Calendar tomorrowCalendar = Calendar.getInstance();
tomorrowCalendar.setTime(now);
tomorrowCalendar.add(Calendar.DAY_OF_MONTH, 1);
optTime = tomorrowCalendar.getTime();
}
careDirectivePlan.setOptTime(optTime);
}
baseMapper.insert(careDirectivePlan);
}
//这个单元格内所有一起挪动 只能挪到空单元格 所以不需要考虑这个逻辑↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
//如果nuId+分类标签+单元格坐标下是否已有数据 需要将所有数据改为指令集 否则设置为非指令集
// {
// //处理旧的单元格
// {
// QueryWrapper<CareDirectivePlan> qw = new QueryWrapper<>();
// qw.eq("nu_id", careDirectivePlan.getNuId());
// qw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
// qw.eq("positioning", entity.getPositioning());
// qw.eq("positioning_long", entity.getPositioningLong());
// List<CareDirectivePlan> list = baseMapper.selectList(qw);
// UpdateWrapper<CareDirectivePlan> uw = new UpdateWrapper<>();
// uw.eq("nu_id", careDirectivePlan.getNuId());
// uw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
// uw.eq("positioning", entity.getPositioning());
// uw.eq("positioning_long", entity.getPositioningLong());
// CareDirectivePlan upData = new CareDirectivePlan();
// if (CollectionUtils.isEmpty(list) || list.size() == 1) {
// upData.setIzMulti("N");
// baseMapper.update(upData, uw);
// } else {
// upData.setIzMulti("Y");
// baseMapper.update(upData, uw);
// }
// }
// //处理新的单元格
// {
// QueryWrapper<CareDirectivePlan> qw = new QueryWrapper<>();
// qw.eq("nu_id", careDirectivePlan.getNuId());
// qw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
// qw.eq("positioning", careDirectivePlan.getPositioning());
// qw.eq("positioning_long", careDirectivePlan.getPositioningLong());
// List<CareDirectivePlan> list = baseMapper.selectList(qw);
// UpdateWrapper<CareDirectivePlan> uw = new UpdateWrapper<>();
// uw.eq("nu_id", careDirectivePlan.getNuId());
// uw.eq("instruction_tag_id", careDirectivePlan.getInstructionTagId());
// uw.eq("positioning", careDirectivePlan.getPositioning());
// uw.eq("positioning_long", careDirectivePlan.getPositioningLong());
// CareDirectivePlan upData = new CareDirectivePlan();
// if (CollectionUtils.isEmpty(list) || list.size() == 1) {
// upData.setIzMulti("N");
// baseMapper.update(upData, uw);
// } else {
// upData.setIzMulti("Y");
// baseMapper.update(upData, uw);
// }
// }
// }
//调用方法先删除数据池中的数据，再生成数据池中的数据
// dataPoolServiceImpl.editDataPool(entity);

2
nursing-unit-services/nu-services-biz/src/main/java/com/nu/modules/biz/plan/care/service/impl/DirectivePlanDateServiceImpl.java
View File

@ -47,7 +47,7 @@ public class DirectivePlanDateServiceImpl extends ServiceImpl<DirectivePlanDateM
@Override
public void generateOrder(DirectivePlanDateEntity queryParam) {
String empId = "2028395421069524993";
String empId = "2026167502440022019";
//所有要派发的数据（查对应时间点数据 所有护理单元所有分类的数据）
List<DirectivePlanDate> diretiveList = baseMapper.queryAllTaskByDateTime(queryParam);