package com.qianwen.smartman.modules.mdc.service.impl;
|
|
import java.io.Serializable;
|
import java.sql.Timestamp;
|
import java.time.LocalDate;
|
import java.time.ZoneId;
|
import java.time.chrono.ChronoLocalDate;
|
import java.time.chrono.ChronoLocalDateTime;
|
import java.time.temporal.ChronoUnit;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
import java.util.stream.Stream;
|
|
import javax.annotation.Resource;
|
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.qianwen.core.cache.utils.CacheUtil;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.support.BaseEntityWrapper;
|
import com.qianwen.core.mp.support.Condition;
|
import com.qianwen.core.mp.support.Query;
|
import com.qianwen.core.redis.lock.RedisLockClient;
|
import com.qianwen.core.secure.utils.AuthUtil;
|
import com.qianwen.core.tool.utils.DateUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.common.constant.ExtCacheConstant;
|
import com.qianwen.smartman.common.enums.GlobalWcsTypeEnum;
|
import com.qianwen.smartman.common.utils.Lambda;
|
import com.qianwen.smartman.modules.cps.entity.Employee;
|
import com.qianwen.smartman.modules.cps.entity.Workstation;
|
import com.qianwen.smartman.modules.cps.service.IEmployeeService;
|
import com.qianwen.smartman.modules.cps.service.IGlobalWcsService;
|
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
|
import com.qianwen.smartman.modules.mdc.convert.StatusRecordConvert;
|
import com.qianwen.smartman.modules.mdc.dto.GroupFeedbackCacheDTO;
|
import com.qianwen.smartman.modules.mdc.dto.WorkstationEndAndStartImmediateFeedBackDTO;
|
import com.qianwen.smartman.modules.mdc.dto.WorkstationEndImmediateFeedBackDTO;
|
import com.qianwen.smartman.modules.mdc.dto.WorkstationImmediateFeedBackDTO;
|
import com.qianwen.smartman.modules.mdc.dto.WorkstationNoImmediateFeedBackDTO;
|
import com.qianwen.smartman.modules.mdc.entity.WorkstationFeedback;
|
import com.qianwen.smartman.modules.mdc.enums.FeedbackStatus;
|
import com.qianwen.smartman.modules.mdc.enums.FeedbackType;
|
import com.qianwen.smartman.modules.mdc.mapper.WorkstationFeedbackMapper;
|
import com.qianwen.smartman.modules.mdc.service.IWorkstationFeedbackDetailService;
|
import com.qianwen.smartman.modules.mdc.service.IWorkstationFeedbackService;
|
import com.qianwen.smartman.modules.mdc.vo.StatusRecordVO;
|
import com.qianwen.smartman.modules.mdc.vo.WorkstationFeedbackInfoVO;
|
import com.qianwen.smartman.modules.mdc.wrapper.WorkstationFeedbackWrapper;
|
|
import cn.hutool.core.collection.ListUtil;
|
|
@Service
|
public class WorkstationFeedbackServiceImpl extends ServiceImpl<WorkstationFeedbackMapper, WorkstationFeedback> implements IWorkstationFeedbackService {
|
static final String GROUP_FEEDBACK_CACHE_KEY = "group:feedback:list:";
|
@Resource
|
private IWorkstationService workstationService;
|
@Resource
|
@Lazy
|
private IWorkstationFeedbackDetailService feedbackDetailService;
|
@Resource
|
private IGlobalWcsService globalWcsService;
|
@Resource
|
private RedisLockClient redisLockClient;
|
@Resource
|
@Lazy
|
private IWorkstationFeedbackService selfService;
|
@Resource
|
private IEmployeeService employeeService;
|
|
|
@Override
|
public IPage<WorkstationFeedbackInfoVO> workstationPage(Query query, boolean excludeImmediate) {
|
final List<WorkstationFeedback> immediateFeedback = this.selfService.getImmediateFeedback();
|
final List<Long> workstationList = immediateFeedback.stream().map((v0) -> {
|
return v0.getWorkstationId();
|
}).collect(Collectors.toList());
|
IPage<Workstation> page = this.workstationService.page(Condition.getPage(query), Lambda.notIn(excludeImmediate && Func.isNotEmpty(immediateFeedback), (v0) -> {
|
return v0.getId();
|
}, workstationList));
|
return new BaseEntityWrapper<Workstation, WorkstationFeedbackInfoVO>() {
|
public WorkstationFeedbackInfoVO entityVO(Workstation entity) {
|
WorkstationFeedbackInfoVO vo = new WorkstationFeedbackInfoVO();
|
vo.setWorkstationId(entity.getId());
|
vo.setWorkstationName(entity.getName());
|
vo.setWorkstationCode(entity.getCode());
|
vo.setWorkstationAvatar(entity.getAvatar());
|
if (workstationList.contains(entity.getId())) {
|
immediateFeedback.stream().filter(item -> {
|
return item.getWorkstationId().equals(entity.getId());
|
}).findFirst().ifPresent(feedback -> {
|
vo.setLastImmediateFeedbackTime(feedback.getStartTime());
|
vo.setFeedbackId(feedback.getId());
|
Optional.ofNullable(WorkstationFeedbackServiceImpl.this.globalWcsService.getByCode(feedback.getWcs(), GlobalWcsTypeEnum.FEEDBACK)).ifPresent(globalWcs -> {
|
vo.setWcsColor(globalWcs.getColor());
|
vo.setWcsDesc(globalWcs.getName());
|
});
|
});
|
vo.setToDayHaveFeedback(true);
|
} else {
|
vo.setToDayHaveFeedback(Boolean.valueOf(WorkstationFeedbackServiceImpl.this.feedbackDetailService.toDayHaveFeedbackCount(entity.getId()) != 0));
|
}
|
return vo;
|
}
|
}.pageVO(page);
|
}
|
|
@Override
|
public List<WorkstationFeedback> getImmediateFeedback() {
|
return list(Lambda.eq(WorkstationFeedback::getFeedbackType, Integer.valueOf(FeedbackType.IMMEDIATE.getValue()))
|
.isNull(WorkstationFeedback::getEndTime));
|
/*
|
return list((Wrapper) Lambda.eq((v0) -> {
|
return v0.getFeedbackType();
|
}, Integer.valueOf(FeedbackType.IMMEDIATE.getValue())).isNull((v0) -> {
|
return v0.getEndTime();
|
}));*/
|
}
|
|
@Override
|
public WorkstationFeedback getImmediateFeedback(Serializable workstationId) {
|
return getOne(Lambda.eq(WorkstationFeedback::getWorkstationId, workstationId)
|
.eq(WorkstationFeedback::getFeedbackType, Integer.valueOf(FeedbackType.IMMEDIATE.getValue()))
|
.isNull(WorkstationFeedback::getEndTime));
|
/*
|
return (WorkstationFeedback) getOne((Wrapper) ((ExtraLambdaQueryWrapper) Lambda.eq((v0) -> {
|
return v0.getWorkstationId();
|
}, workstationId).eq((v0) -> {
|
return v0.getFeedbackType();
|
}, Integer.valueOf(FeedbackType.IMMEDIATE.getValue()))).isNull((v0) -> {
|
return v0.getEndTime();
|
}));*/
|
}
|
|
@Override
|
@Transactional
|
public boolean startFeedbackByImmediate(WorkstationImmediateFeedBackDTO dto) {
|
Date now = new Date();
|
for (String workstationId : dto.getWorkstationIds()) {
|
this.redisLockClient.lockFair(ExtCacheConstant.WORK_FEEDBACK.concat(":".concat(workstationId)), 30L, 100L, () -> {
|
WorkstationFeedback oldFeedback = this.selfService.getImmediateFeedback(workstationId);
|
if (oldFeedback != null && oldFeedback.getWcs().equals(dto.getWcs())) {
|
return false;
|
}
|
if (oldFeedback != null) {
|
oldFeedback.setEndTime(now);
|
updateById(oldFeedback);
|
}
|
WorkstationFeedback addFeedback = new WorkstationFeedback();
|
addFeedback.setWorkstationId(Long.valueOf(Long.parseLong(workstationId)));
|
addFeedback.setStartTime(now);
|
addFeedback.setFeedbackTime(now);
|
if (Func.isNotEmpty(dto.getFeedUser())) {
|
addFeedback.setFeedUser(Long.valueOf(Long.parseLong(dto.getFeedUser())));
|
} else {
|
addFeedback.setFeedUser(getEmployeeById().getId());
|
}
|
addFeedback.setFeedbackType(Integer.valueOf(FeedbackType.IMMEDIATE.getValue()));
|
addFeedback.setStatus(FeedbackStatus.WAIT_SYNC.getValue());
|
addFeedback.setRemark(dto.getDescription());
|
addFeedback.setWcs(dto.getWcs());
|
save(addFeedback);
|
CacheUtil.evict(ExtCacheConstant.WORK_FEEDBACK, "immediate:workstationId:", workstationId, false);
|
return true;
|
});
|
}
|
evictFeedback(now, now, dto.getWorkstationIds());
|
return true;
|
}
|
|
@Override
|
@Transactional
|
public boolean startFeedbackByNoImmediate(final WorkstationNoImmediateFeedBackDTO dto) {
|
if (dto.getEndTime().compareTo(new Date()) > 0) {
|
dto.setEndTime(new Date());
|
}
|
for (String workstationId : dto.getWorkstationIds()) {
|
this.redisLockClient.lockFair(ExtCacheConstant.WORK_FEEDBACK.concat(":").concat(workstationId), 30L, 100L, () -> {
|
existTimeOverImmediateFeedbackException(dto);
|
WorkstationFeedback addFeedback = new WorkstationFeedback();
|
addFeedback.setWorkstationId(Long.valueOf(Long.parseLong(workstationId)));
|
addFeedback.setStartTime(dto.getStartTime());
|
addFeedback.setEndTime(dto.getEndTime());
|
addFeedback.setFeedbackTime(new Date());
|
if (Func.isNotEmpty(dto.getFeedUser())) {
|
addFeedback.setFeedUser(Long.valueOf(Long.parseLong(dto.getFeedUser())));
|
addFeedback.setEndFeedUser(Long.valueOf(Long.parseLong(dto.getFeedUser())));
|
} else {
|
addFeedback.setFeedUser(getEmployeeById().getId());
|
addFeedback.setEndFeedUser(getEmployeeById().getId());
|
}
|
addFeedback.setFeedbackType(Integer.valueOf(FeedbackType.TIME_RANGE.getValue()));
|
addFeedback.setStatus(FeedbackStatus.WAIT_SYNC.getValue());
|
addFeedback.setRemark(dto.getDescription());
|
addFeedback.setWcs(dto.getWcs());
|
return Boolean.valueOf(save(addFeedback));
|
});
|
}
|
evictFeedback(dto.getStartTime(), dto.getEndTime(), dto.getWorkstationIds());
|
return true;
|
}
|
|
private void evictFeedback(final Date startTime, final Date endTime, List<String> workstationIds) {
|
LocalDate start = startTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
LocalDate end = endTime.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
workstationIds.forEach(id -> {
|
evictFeedback(start, end, id);
|
});
|
}
|
|
private void evictFeedback(final LocalDate start, final LocalDate end, final Serializable workstationId) {
|
long distance = ChronoUnit.DAYS.between(start, end);
|
Stream.iterate(start, d -> {
|
return d.plusDays(1L);
|
}).limit(distance + 1).forEach(date -> {
|
String key = String.valueOf(workstationId).concat(":").concat(Func.formatDate(date));
|
CacheUtil.evict(IWorkstationFeedbackService.WORK_FEEDBACK_EXP3, GROUP_FEEDBACK_CACHE_KEY, key, false);
|
});
|
}
|
|
private void existTimeOverImmediateFeedbackException(WorkstationNoImmediateFeedBackDTO dto) {
|
if (dto.getWorkstationIds().stream().map(this.selfService::getImmediateFeedback).filter(Objects::nonNull).anyMatch(feedback ->
|
(dto.getStartTime().getTime() >= feedback.getStartTime().getTime() || dto.getEndTime().getTime() >= feedback.getStartTime().getTime())))
|
throw new ServiceException("存在正在反馈的状态，请先结束当前反馈再提交。");
|
/*
|
|
Stream<String> stream = dto.getWorkstationIds().stream();
|
IWorkstationFeedbackService iWorkstationFeedbackService = this.selfService;
|
iWorkstationFeedbackService.getClass();
|
if (stream.map((v1) -> {
|
return r1.getImmediateFeedback(v1);
|
}).filter((v0) -> {
|
return Objects.nonNull(v0);
|
}).anyMatch(feedback -> {
|
return dto.getStartTime().getTime() >= feedback.getStartTime().getTime() || dto.getEndTime().getTime() >= feedback.getStartTime().getTime();
|
})) {
|
throw new ServiceException("存在正在反馈的状态，请先结束当前反馈再提交。");
|
}*/
|
}
|
|
private Employee getEmployeeById() {
|
Employee employee = this.employeeService.cachedById(AuthUtil.getUserId());
|
if (employee == null) {
|
employee = this.employeeService.getByUserId(AuthUtil.getUserId());
|
}
|
if (employee == null) {
|
throw new ServiceException("没有查询到员工信息");
|
}
|
return employee;
|
}
|
|
@Override
|
@Transactional
|
public boolean endFeedback(WorkstationEndImmediateFeedBackDTO dto) {
|
WorkstationFeedback feedback = this.selfService.cachedById(dto.getFeedbackId());
|
if (dto.getEndTime() == null) {
|
dto.setEndTime(new Date());
|
}
|
if (feedback == null || feedback.getEndTime() != null) {
|
return false;
|
}
|
if (feedback.getStartTime().compareTo(dto.getEndTime()) >= 0) {
|
throw new ServiceException("开始时间必须小于结束时间");
|
}
|
Date now = new Date();
|
feedback.setEndTime(dto.getEndTime().compareTo(new Date()) > 0 ? now : dto.getEndTime());
|
if (Func.isNotEmpty(dto.getFeedUser())) {
|
feedback.setEndFeedUser(Long.valueOf(Long.parseLong(dto.getFeedUser())));
|
} else {
|
feedback.setFeedUser(getEmployeeById().getId());
|
}
|
evictFeedback(feedback.getStartTime(), feedback.getEndTime(), Collections.singletonList(feedback.getWorkstationId() + ""));
|
return updateById(feedback);
|
}
|
|
@Override
|
@Transactional
|
public boolean endAndStartAgainFeedback(WorkstationEndAndStartImmediateFeedBackDTO dto) {
|
WorkstationEndImmediateFeedBackDTO endImmediateFeedBackDTO = new WorkstationEndImmediateFeedBackDTO();
|
endImmediateFeedBackDTO.setEndTime(dto.getEndTime());
|
endImmediateFeedBackDTO.setFeedbackId(dto.getEndFeedbackId());
|
endImmediateFeedBackDTO.setWorkstationId(dto.getWorkstationId());
|
endImmediateFeedBackDTO.setFeedUser(dto.getFeedUser());
|
boolean success = endFeedback(endImmediateFeedBackDTO);
|
if (success) {
|
WorkstationImmediateFeedBackDTO start = new WorkstationImmediateFeedBackDTO();
|
start.setWorkstationIds(ListUtil.toList(new String[]{dto.getWorkstationId()}));
|
start.setWcs(dto.getWcs());
|
start.setDescription(dto.getDesc());
|
start.setFeedUser(dto.getFeedUser());
|
boolean success2 = startFeedbackByImmediate(start);
|
return success2;
|
}
|
return false;
|
}
|
|
private List<WorkstationFeedback> allFeedbackByWorkstationId(final LocalDate statusTime, final Serializable workstationId) {
|
return Stream.concat(
|
Stream.<Serializable>of(workstationId).map(this.selfService::getImmediateFeedback)
|
.filter(Objects::nonNull)
|
.filter(feedback -> (statusTime == null || DateUtil.formatDate(feedback.getStartTime()).equals(statusTime.toString()))),
|
list(Lambda.eq(WorkstationFeedback::getWorkstationId, workstationId)
|
.dayBetween(statusTime, WorkstationFeedback::getStartTime, WorkstationFeedback::getEndTime))
|
.stream()
|
.filter(Objects::nonNull))
|
.collect(Collectors.toList());
|
/*
|
Stream of = Stream.of(workstationId);
|
IWorkstationFeedbackService iWorkstationFeedbackService = this.selfService;
|
iWorkstationFeedbackService.getClass();
|
return (List) Stream.concat(of.map(this::getImmediateFeedback).filter((v0) -> {
|
return Objects.nonNull(v0);
|
}).filter(feedback -> {
|
return statusTime == null || DateUtil.formatDate(feedback.getStartTime()).equals(statusTime.toString());
|
}), list(Lambda.eq((v0) -> {
|
return v0.getWorkstationId();
|
}, workstationId).dayBetween(statusTime, (v0) -> {
|
return v0.getStartTime();
|
}, (v0) -> {
|
return v0.getEndTime();
|
})).stream().filter((v0) -> {
|
return Objects.nonNull(v0);
|
})).collect(Collectors.toList());*/
|
}
|
|
@Override
|
public List<StatusRecordVO> groupStatusRecordWithFeedbackCache(final LocalDate statusTime, final Long workstationId, final List<StatusRecordVO> recordList) {
|
List<StatusRecordVO> statusRecordList = recordList == null ? new ArrayList<>() : recordList;
|
List<StatusRecordVO> cancelList = this.feedbackDetailService.cancelFeedback(statusTime, workstationId).stream().map(feedback -> {
|
StatusRecordVO t = new StatusRecordVO();
|
t.setStartTime(new Timestamp(feedback.getStartTime().getTime()));
|
t.setEndTime(new Timestamp(feedback.getEndTime().getTime()));
|
t.setHumanFeedback(true);
|
t.setFeedbackTime(feedback.getCancelTime() == null ? null : new Timestamp(feedback.getCancelTime().getTime()));
|
t.setWcs(-1);
|
return t;
|
}).collect(Collectors.toList());
|
String key = String.join(":", workstationId + "", statusTime.toString());
|
if (statusTime.compareTo((ChronoLocalDate) LocalDate.now()) == 0) {
|
List<StatusRecordVO> statusRecordVOList = groupStatusRecordWithFeedback(statusTime, workstationId, statusRecordList, cancelList);
|
return filterDateStatusRecord(statusRecordVOList, statusTime);
|
}
|
GroupFeedbackCacheDTO statusData = CacheUtil.get(IWorkstationFeedbackService.WORK_FEEDBACK_EXP3, GROUP_FEEDBACK_CACHE_KEY, key, () -> {
|
GroupFeedbackCacheDTO dto = new GroupFeedbackCacheDTO();
|
List<StatusRecordVO> list = groupStatusRecordWithFeedback(statusTime, workstationId, statusRecordList, cancelList);
|
dto.setRecordList(list);
|
dto.setStatusNum(statusRecordList.size());
|
dto.setCancelNum(cancelList.size());
|
return dto;
|
}, false);
|
|
//assert statusData != null;
|
if (statusData.getStatusNum() != statusRecordList.size() || statusData.getCancelNum() != cancelList.size()) {
|
//CacheUtil.evict("blade:feedback#259200", "group:feedback:list:", key, Boolean.valueOf(false));
|
CacheUtil.evict(IWorkstationFeedbackService.WORK_FEEDBACK_EXP3, GROUP_FEEDBACK_CACHE_KEY, key, false);
|
return groupStatusRecordWithFeedbackCache(statusTime, workstationId, statusRecordList);
|
}
|
return filterDateStatusRecord(statusData.getRecordList(), statusTime);
|
|
/*
|
if ($assertionsDisabled || statusData != null) {
|
if (statusData.getStatusNum() != statusRecordList.size() || statusData.getCancelNum() != cancelList.size()) {
|
CacheUtil.evict(IWorkstationFeedbackService.WORK_FEEDBACK_EXP3, GROUP_FEEDBACK_CACHE_KEY, key, false);
|
return groupStatusRecordWithFeedbackCache(statusTime, workstationId, statusRecordList);
|
}
|
return filterDateStatusRecord(statusData.getRecordList(), statusTime);
|
}
|
throw new AssertionError();
|
*/
|
}
|
|
private List<StatusRecordVO> groupStatusRecordWithFeedback(final LocalDate statusTime, final Long workstationId, final List<StatusRecordVO> statusRecordList, final List<StatusRecordVO> cancelList) {
|
List<StatusRecordVO> sourceList = Stream.concat(allFeedbackByWorkstationId(statusTime, workstationId).stream().map(WorkstationFeedbackWrapper::entityRecordVO), cancelList.stream()).sorted(Comparator.comparing((v0) -> {
|
return v0.getFeedbackTime();
|
})).collect(Collectors.toList());
|
List<StatusRecordVO> feedbackList = groupStatusRecordWithFeedback(sourceList, statusTime);
|
List<StatusRecordVO> sourceList2 = Stream.concat(statusRecordList.stream().peek(status -> {
|
status.setFeedbackTime(status.getStartTime());
|
}), feedbackList.stream()).sorted(Comparator.comparing((v0) -> {
|
return v0.getFeedbackTime();
|
})).collect(Collectors.toList());
|
return groupStatusRecordWithFeedback(sourceList2, statusTime);
|
}
|
|
private List<StatusRecordVO> groupStatusRecordWithFeedback(final List<StatusRecordVO> sourceList, final LocalDate statusTime) {
|
List<StatusRecordVO> targetList = new ArrayList<>();
|
Stream.concat(sourceList.stream().map((v0) -> {
|
return v0.getStartTime();
|
}), sourceList.stream().map((v0) -> {
|
return v0.getEndTime();
|
})).distinct().sorted(Comparator.comparing((v0) -> {
|
return v0.getTime();
|
})).reduce((first, second) -> {
|
Optional<StatusRecordVO> reduce = sourceList.stream().filter(item -> {
|
return first.getTime() - item.getStartTime().getTime() >= 0 && item.getEndTime().getTime() - second.getTime() >= 0;
|
}).reduce((a, b) -> {
|
if (!b.isHumanFeedback() && a.isHumanFeedback()) {
|
return a;
|
}
|
return b;
|
});
|
//StatusRecordConvert statusRecordConvert = StatusRecordConvert.INSTANCE;
|
//statusRecordConvert.getClass();
|
reduce.map(StatusRecordConvert.INSTANCE::convert).ifPresent(record -> {
|
record.setStartTime(first);
|
record.setEndTime(second);
|
System.out.println(first + " -> " + second + " wcs=" + record.getWcs());
|
StatusRecordVO latest = targetList.size() == 0 ? null : (StatusRecordVO) targetList.get(targetList.size() - 1);
|
if (latest != null && !record.isPoint() && latest.getWcs().equals(record.getWcs()) && latest.getEndTime().getTime() == record.getStartTime().getTime() && latest.getFeedUserId() != null && record.getFeedUserId() != null && latest.getFeedUserId().equals(record.getFeedUserId())) {
|
latest.setEndTime(record.getEndTime());
|
} else {
|
targetList.add(record);
|
}
|
});
|
return second;
|
});
|
return targetList.stream().filter(item -> {
|
return !item.getWcs().equals(-1) && item.getEndTime().getTime() - item.getStartTime().getTime() >= 1000 && item.getStartTime().toLocalDateTime().toLocalDate().compareTo((ChronoLocalDate) statusTime) <= 0 && item.getEndTime().toLocalDateTime().toLocalDate().compareTo((ChronoLocalDate) statusTime) >= 0;
|
}).collect(Collectors.toList());
|
}
|
|
private List<StatusRecordVO> filterDateStatusRecord(final List<StatusRecordVO> list, final LocalDate statusTime) {
|
if (list.size() > 0) {
|
StatusRecordVO startRecord = list.get(0);
|
StatusRecordVO endRecord = list.get(list.size() - 1);
|
if (startRecord.getStartTime().toLocalDateTime().compareTo((ChronoLocalDateTime<?>) statusTime.atStartOfDay()) < 0) {
|
startRecord.setStartTime(Timestamp.valueOf(statusTime.atStartOfDay()));
|
}
|
if (endRecord.getEndTime().toLocalDateTime().toLocalDate().compareTo((ChronoLocalDate) statusTime) > 0) {
|
endRecord.setEndTime(Timestamp.valueOf(statusTime.atTime(23, 59, 59)));
|
}
|
if (endRecord.isPoint()) {
|
endRecord.setEndTime(new Timestamp(System.currentTimeMillis()));
|
}
|
}
|
return list;
|
}
|
}
|
