From 694b9483c7a551626244cbc222c602ea9ff74094 Mon Sep 17 00:00:00 2001
From: sean.zhou <sean.zhou@dji.com>
Date: Tue, 25 Apr 2023 21:44:00 +0800
Subject: [PATCH] What's new? 1. Wayline management: added `pause wayline task` and `recover wayline task`. 2. Added command flight function. 3. Fixed some issues.
---
src/main/java/com/dji/sample/wayline/service/impl/WaylineJobServiceImpl.java | 330 ++++++++++++++++++++++++++++++++++++++++--------------
1 files changed, 241 insertions(+), 89 deletions(-)
diff --git a/src/main/java/com/dji/sample/wayline/service/impl/WaylineJobServiceImpl.java b/src/main/java/com/dji/sample/wayline/service/impl/WaylineJobServiceImpl.java
index acbeabe..4d4cbb2 100644
--- a/src/main/java/com/dji/sample/wayline/service/impl/WaylineJobServiceImpl.java
+++ b/src/main/java/com/dji/sample/wayline/service/impl/WaylineJobServiceImpl.java
@@ -12,7 +12,14 @@
import com.dji.sample.component.mqtt.service.IMessageSenderService;
import com.dji.sample.component.redis.RedisConst;
import com.dji.sample.component.redis.RedisOpsUtils;
+import com.dji.sample.control.model.param.DrcModeParam;
+import com.dji.sample.control.service.IDrcService;
import com.dji.sample.manage.model.dto.DeviceDTO;
+import com.dji.sample.manage.model.enums.DeviceModeCodeEnum;
+import com.dji.sample.manage.model.enums.DockModeCodeEnum;
+import com.dji.sample.manage.model.receiver.OsdDockReceiver;
+import com.dji.sample.manage.model.receiver.OsdSubDeviceReceiver;
+import com.dji.sample.manage.service.IDeviceRedisService;
import com.dji.sample.manage.service.IDeviceService;
import com.dji.sample.media.model.MediaFileCountDTO;
import com.dji.sample.media.model.MediaMethodEnum;
@@ -20,12 +27,15 @@
import com.dji.sample.wayline.dao.IWaylineJobMapper;
import com.dji.sample.wayline.model.dto.*;
import com.dji.sample.wayline.model.entity.WaylineJobEntity;
+import com.dji.sample.wayline.model.enums.WaylineErrorCodeEnum;
import com.dji.sample.wayline.model.enums.WaylineJobStatusEnum;
import com.dji.sample.wayline.model.enums.WaylineMethodEnum;
import com.dji.sample.wayline.model.enums.WaylineTaskTypeEnum;
import com.dji.sample.wayline.model.param.CreateJobParam;
+import com.dji.sample.wayline.model.param.UpdateJobParam;
import com.dji.sample.wayline.service.IWaylineFileService;
import com.dji.sample.wayline.service.IWaylineJobService;
+import com.dji.sample.wayline.service.IWaylineRedisService;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
@@ -37,6 +47,7 @@
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
import java.net.URL;
import java.sql.SQLException;
@@ -72,6 +83,15 @@
@Autowired
private IFileService fileService;
+ @Autowired
+ private IDrcService drcService;
+
+ @Autowired
+ private IDeviceRedisService deviceRedisService;
+
+ @Autowired
+ private IWaylineRedisService waylineRedisService;
+
private Optional<WaylineJobDTO> insertWaylineJob(WaylineJobEntity jobEntity) {
int id = mapper.insert(jobEntity);
if (id <= 0) {
@@ -96,8 +116,8 @@
.beginTime(beginTime)
.endTime(endTime)
.status(WaylineJobStatusEnum.PENDING.getVal())
- .taskType(param.getTaskType())
- .waylineType(param.getWaylineType())
+ .taskType(param.getTaskType().getVal())
+ .waylineType(param.getWaylineType().getVal())
.outOfControlAction(param.getOutOfControlAction())
.rthAltitude(param.getRthAltitude())
.mediaCount(0)
@@ -123,24 +143,107 @@
return this.insertWaylineJob(jobEntity);
}
+ /**
+ * For immediate tasks, the server time shall prevail.
+ * @param param
+ */
+ private void fillImmediateTime(CreateJobParam param) {
+ if (WaylineTaskTypeEnum.IMMEDIATE != param.getTaskType()) {
+ return;
+ }
+ long now = System.currentTimeMillis() / 1000;
+ if (CollectionUtils.isEmpty(param.getTaskDays())) {
+ param.setTaskDays(List.of(now));
+ }
+ if (CollectionUtils.isEmpty(param.getTaskPeriods())) {
+ param.setTaskPeriods(List.of(List.of(now)));
+ }
+ }
+
@Override
public ResponseResult publishFlightTask(CreateJobParam param, CustomClaim customClaim) throws SQLException {
- if (WaylineTaskTypeEnum.IMMEDIATE.getVal() == param.getTaskType()) {
- param.setExecuteTime(System.currentTimeMillis());
- }
- Optional<WaylineJobDTO> waylineJobOpt = this.createWaylineJob(param,
- customClaim.getWorkspaceId(), customClaim.getUsername(),
- param.getExecuteTime(), param.getExecuteTime());
- if (waylineJobOpt.isEmpty()) {
- throw new SQLException("Failed to create wayline job.");
- }
- WaylineJobDTO waylineJob = waylineJobOpt.get();
+ fillImmediateTime(param);
- boolean isOnline = deviceService.checkDeviceOnline(waylineJob.getDockSn());
+ for (Long taskDay : param.getTaskDays()) {
+ LocalDate date = LocalDate.ofInstant(Instant.ofEpochSecond(taskDay), ZoneId.systemDefault());
+ for (List<Long> taskPeriod : param.getTaskPeriods()) {
+ long beginTime = LocalDateTime.of(date, LocalTime.ofInstant(Instant.ofEpochSecond(taskPeriod.get(0)), ZoneId.systemDefault()))
+ .atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
+ long endTime = taskPeriod.size() > 1 ?
+ LocalDateTime.of(date, LocalTime.ofInstant(Instant.ofEpochSecond(taskPeriod.get(1)), ZoneId.systemDefault()))
+ .atZone(ZoneId.systemDefault()).toInstant().toEpochMilli() : beginTime;
+ Optional<WaylineJobDTO> waylineJobOpt = this.createWaylineJob(param, customClaim.getWorkspaceId(), customClaim.getUsername(), beginTime, endTime);
+ if (waylineJobOpt.isEmpty()) {
+ throw new SQLException("Failed to create wayline job.");
+ }
+
+ WaylineJobDTO waylineJob = waylineJobOpt.get();
+ // If it is a conditional task type, add conditions to the job parameters.
+ addConditions(waylineJob, param, beginTime, endTime);
+
+ return this.publishOneFlightTask(waylineJob);
+ }
+ }
+ return ResponseResult.error();
+ }
+
+ private void addConditions(WaylineJobDTO waylineJob, CreateJobParam param, Long beginTime, Long endTime) {
+ if (WaylineTaskTypeEnum.CONDITION != param.getTaskType()) {
+ return;
+ }
+
+ waylineJob.setConditions(
+ WaylineTaskConditionDTO.builder()
+ .executableConditions(Objects.nonNull(param.getMinStorageCapacity()) ?
+ WaylineTaskExecutableConditionDTO.builder().storageCapacity(param.getMinStorageCapacity()).build() : null)
+ .readyConditions(WaylineTaskReadyConditionDTO.builder()
+ .batteryCapacity(param.getMinBatteryCapacity())
+ .beginTime(beginTime)
+ .endTime(endTime)
+ .build())
+ .build());
+
+ waylineRedisService.setConditionalWaylineJob(waylineJob);
+ // key: wayline_job_condition, value: {workspace_id}:{dock_sn}:{job_id}
+ boolean isAdd = waylineRedisService.addPrepareConditionalWaylineJob(waylineJob);
+ if (!isAdd) {
+ throw new RuntimeException("Failed to create conditional job.");
+ }
+ }
+
+ public ResponseResult publishOneFlightTask(WaylineJobDTO waylineJob) throws SQLException {
+
+ boolean isOnline = deviceRedisService.checkDeviceOnline(waylineJob.getDockSn());
if (!isOnline) {
throw new RuntimeException("Dock is offline.");
}
+ boolean isSuccess = this.prepareFlightTask(waylineJob);
+ if (!isSuccess) {
+ return ResponseResult.error("Failed to prepare job.");
+ }
+
+ // Issue an immediate task execution command.
+ if (WaylineTaskTypeEnum.IMMEDIATE.getVal() == waylineJob.getTaskType()) {
+ if (!executeFlightTask(waylineJob.getWorkspaceId(), waylineJob.getJobId())) {
+ return ResponseResult.error("Failed to execute job.");
+ }
+ }
+
+ if (WaylineTaskTypeEnum.TIMED.getVal() == waylineJob.getTaskType()) {
+ // key: wayline_job_timed, value: {workspace_id}:{dock_sn}:{job_id}
+ boolean isAdd = RedisOpsUtils.zAdd(RedisConst.WAYLINE_JOB_TIMED_EXECUTE,
+ waylineJob.getWorkspaceId() + RedisConst.DELIMITER + waylineJob.getDockSn() + RedisConst.DELIMITER + waylineJob.getJobId(),
+ waylineJob.getBeginTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
+ if (!isAdd) {
+ return ResponseResult.error("Failed to create scheduled job.");
+ }
+ }
+
+ return ResponseResult.success();
+ }
+
+ private Boolean prepareFlightTask(WaylineJobDTO waylineJob) throws SQLException {
// get wayline file
Optional<WaylineFileDTO> waylineFile = waylineFileService.getWaylineByWaylineId(waylineJob.getWorkspaceId(), waylineJob.getFileId());
if (waylineFile.isEmpty()) {
@@ -163,17 +266,16 @@
.build())
.build();
- String topic = TopicConst.THING_MODEL_PRE + TopicConst.PRODUCT +
- waylineJob.getDockSn() + TopicConst.SERVICES_SUF;
- CommonTopicResponse<Object> response = CommonTopicResponse.builder()
- .tid(UUID.randomUUID().toString())
- .bid(waylineJob.getJobId())
- .timestamp(System.currentTimeMillis())
- .data(flightTask)
- .method(WaylineMethodEnum.FLIGHT_TASK_PREPARE.getMethod())
- .build();
+ if (WaylineTaskTypeEnum.CONDITION.getVal() == waylineJob.getTaskType()) {
+ if (Objects.isNull(waylineJob.getConditions())) {
+ throw new IllegalArgumentException();
+ }
+ flightTask.setReadyConditions(waylineJob.getConditions().getReadyConditions());
+ flightTask.setExecutableConditions(waylineJob.getConditions().getExecutableConditions());
+ }
- ServiceReply serviceReply = messageSender.publishWithReply(topic, response);
+ ServiceReply serviceReply = messageSender.publishServicesTopic(
+ waylineJob.getDockSn(), WaylineMethodEnum.FLIGHT_TASK_PREPARE.getMethod(), flightTask, waylineJob.getJobId());
if (ResponseResult.CODE_SUCCESS != serviceReply.getResult()) {
log.info("Prepare task ====> Error code: {}", serviceReply.getResult());
this.updateJob(WaylineJobDTO.builder()
@@ -183,26 +285,9 @@
.status(WaylineJobStatusEnum.FAILED.getVal())
.completedTime(LocalDateTime.now())
.code(serviceReply.getResult()).build());
- return ResponseResult.error("Prepare task ====> Error code: " + serviceReply.getResult());
+ return false;
}
-
- // Issue an immediate task execution command.
- if (WaylineTaskTypeEnum.IMMEDIATE.getVal() == waylineJob.getTaskType()) {
- if (!executeFlightTask(waylineJob.getWorkspaceId(), waylineJob.getJobId())) {
- return ResponseResult.error("Failed to execute job.");
- }
- }
-
- if (WaylineTaskTypeEnum.TIMED.getVal() == waylineJob.getTaskType()) {
- boolean isAdd = RedisOpsUtils.zAdd(RedisConst.WAYLINE_JOB_TIMED_EXECUTE,
- waylineJob.getWorkspaceId() + RedisConst.DELIMITER + waylineJob.getDockSn() + RedisConst.DELIMITER + waylineJob.getJobId(),
- waylineJob.getBeginTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
- if (!isAdd) {
- return ResponseResult.error("Failed to create scheduled job.");
- }
- }
-
- return ResponseResult.success();
+ return true;
}
@Override
@@ -213,7 +298,7 @@
throw new IllegalArgumentException("Job doesn't exist.");
}
- boolean isOnline = deviceService.checkDeviceOnline(waylineJob.get().getDockSn());
+ boolean isOnline = deviceRedisService.checkDeviceOnline(waylineJob.get().getDockSn());
if (!isOnline) {
throw new RuntimeException("Dock is offline.");
}
@@ -221,17 +306,8 @@
WaylineJobDTO job = waylineJob.get();
WaylineTaskCreateDTO flightTask = WaylineTaskCreateDTO.builder().flightId(jobId).build();
- String topic = TopicConst.THING_MODEL_PRE + TopicConst.PRODUCT +
- job.getDockSn() + TopicConst.SERVICES_SUF;
- CommonTopicResponse<Object> response = CommonTopicResponse.builder()
- .tid(UUID.randomUUID().toString())
- .bid(jobId)
- .timestamp(System.currentTimeMillis())
- .data(flightTask)
- .method(WaylineMethodEnum.FLIGHT_TASK_EXECUTE.getMethod())
- .build();
-
- ServiceReply serviceReply = messageSender.publishWithReply(topic, response);
+ ServiceReply serviceReply = messageSender.publishServicesTopic(
+ job.getDockSn(), WaylineMethodEnum.FLIGHT_TASK_EXECUTE.getMethod(), flightTask, jobId);
if (ResponseResult.CODE_SUCCESS != serviceReply.getResult()) {
log.info("Execute job ====> Error code: {}", serviceReply.getResult());
this.updateJob(WaylineJobDTO.builder()
@@ -240,6 +316,11 @@
.status(WaylineJobStatusEnum.FAILED.getVal())
.completedTime(LocalDateTime.now())
.code(serviceReply.getResult()).build());
+ // The conditional task fails and enters the blocking status.
+ if (WaylineTaskTypeEnum.CONDITION.getVal() == job.getTaskType()
+ && WaylineErrorCodeEnum.find(serviceReply.getResult()).isBlock()) {
+ waylineRedisService.setBlockedWaylineJob(job.getDockSn(), jobId);
+ }
return false;
}
@@ -248,9 +329,7 @@
.executeTime(LocalDateTime.now())
.status(WaylineJobStatusEnum.IN_PROGRESS.getVal())
.build());
- RedisOpsUtils.setWithExpire(RedisConst.WAYLINE_JOB_RUNNING_PREFIX + job.getDockSn(),
- EventsReceiver.<WaylineTaskProgressReceiver>builder().bid(jobId).sn(job.getDockSn()).build(),
- RedisConst.DEVICE_ALIVE_SECOND * RedisConst.DEVICE_ALIVE_SECOND);
+ waylineRedisService.setRunningWaylineJob(job.getDockSn(), EventsReceiver.<WaylineTaskProgressReceiver>builder().bid(jobId).sn(job.getDockSn()).build());
return true;
}
@@ -262,8 +341,7 @@
// Check if the task status is correct.
boolean isErr = !jobIds.removeAll(waylineJobIds) || !jobIds.isEmpty() ;
if (isErr) {
- throw new IllegalArgumentException("These tasks have an incorrect status and cannot be canceled. "
- + Arrays.toString(jobIds.toArray()));
+ throw new IllegalArgumentException("These tasks have an incorrect status and cannot be canceled. " + Arrays.toString(jobIds.toArray()));
}
// Group job id by dock sn.
@@ -275,21 +353,13 @@
}
public void publishCancelTask(String workspaceId, String dockSn, List<String> jobIds) {
- boolean isOnline = deviceService.checkDeviceOnline(dockSn);
+ boolean isOnline = deviceRedisService.checkDeviceOnline(dockSn);
if (!isOnline) {
throw new RuntimeException("Dock is offline.");
}
- String topic = TopicConst.THING_MODEL_PRE + TopicConst.PRODUCT + dockSn + TopicConst.SERVICES_SUF;
- CommonTopicResponse<Object> response = CommonTopicResponse.builder()
- .tid(UUID.randomUUID().toString())
- .bid(UUID.randomUUID().toString())
- .timestamp(System.currentTimeMillis())
- .data(Map.of(MapKeyConst.FLIGHT_IDS, jobIds))
- .method(WaylineMethodEnum.FLIGHT_TASK_CANCEL.getMethod())
- .build();
-
- ServiceReply serviceReply = messageSender.publishWithReply(topic, response);
+ ServiceReply serviceReply = messageSender.publishServicesTopic(
+ dockSn, WaylineMethodEnum.FLIGHT_TASK_CANCEL.getMethod(), Map.of(MapKeyConst.FLIGHT_IDS, jobIds));
if (ResponseResult.CODE_SUCCESS != serviceReply.getResult()) {
log.info("Cancel job ====> Error code: {}", serviceReply.getResult());
throw new RuntimeException("Failed to cancel the wayline job of " + dockSn);
@@ -366,8 +436,11 @@
String topic = headers.get(MqttHeaders.RECEIVED_TOPIC).toString() + TopicConst._REPLY_SUF;
- DeviceDTO device = (DeviceDTO) RedisOpsUtils.get(RedisConst.DEVICE_ONLINE_PREFIX + receiver.getGateway());
- Optional<WaylineJobDTO> waylineJobOpt = this.getJobByJobId(device.getWorkspaceId(), jobId);
+ Optional<DeviceDTO> deviceOpt = deviceRedisService.getDeviceOnline(receiver.getGateway());
+ if (deviceOpt.isEmpty()) {
+ return;
+ }
+ Optional<WaylineJobDTO> waylineJobOpt = this.getJobByJobId(deviceOpt.get().getWorkspaceId(), jobId);
if (waylineJobOpt.isEmpty()) {
builder.data(RequestsReply.error(CommonErrorEnum.ILLEGAL_ARGUMENT));
messageSender.publish(topic, builder.build());
@@ -415,19 +488,12 @@
String dockSn = jobOpt.get().getDockSn();
String key = RedisConst.MEDIA_HIGHEST_PRIORITY_PREFIX + dockSn;
- if (RedisOpsUtils.checkExist(key) &&
- jobId.equals(((MediaFileCountDTO) RedisOpsUtils.get(key)).getJobId())) {
+ if (RedisOpsUtils.checkExist(key) && jobId.equals(((MediaFileCountDTO) RedisOpsUtils.get(key)).getJobId())) {
return;
}
- ServiceReply reply = messageSender.publishWithReply(TopicConst.THING_MODEL_PRE + TopicConst.PRODUCT + dockSn + TopicConst.SERVICES_SUF,
- CommonTopicResponse.builder()
- .tid(UUID.randomUUID().toString())
- .bid(UUID.randomUUID().toString())
- .timestamp(System.currentTimeMillis())
- .method(MediaMethodEnum.UPLOAD_FLIGHT_TASK_MEDIA_PRIORITIZE.getMethod())
- .data(Map.of(MapKeyConst.FLIGHT_ID, jobId))
- .build());
+ ServiceReply reply = messageSender.publishServicesTopic(
+ dockSn, MediaMethodEnum.UPLOAD_FLIGHT_TASK_MEDIA_PRIORITIZE.getMethod(), Map.of(MapKeyConst.FLIGHT_ID, jobId));
if (ResponseResult.CODE_SUCCESS != reply.getResult()) {
throw new RuntimeException("Failed to set media job upload priority. Error Code: " + reply.getResult());
}
@@ -467,6 +533,91 @@
.build();
}
+ @Override
+ public void updateJobStatus(String workspaceId, String jobId, UpdateJobParam param) {
+ Optional<WaylineJobDTO> waylineJobOpt = this.getJobByJobId(workspaceId, jobId);
+ if (waylineJobOpt.isEmpty()) {
+ throw new RuntimeException("The job does not exist.");
+ }
+ WaylineJobDTO waylineJob = waylineJobOpt.get();
+ WaylineJobStatusEnum statusEnum = this.getWaylineState(waylineJob.getDockSn());
+ if (statusEnum.getEnd() || WaylineJobStatusEnum.PENDING == statusEnum) {
+ throw new RuntimeException("The wayline job status does not match, and the operation cannot be performed.");
+ }
+
+ switch (param.getStatus()) {
+ case PAUSE:
+ pauseJob(workspaceId, waylineJob.getDockSn(), jobId, statusEnum);
+ break;
+ case RESUME:
+ resumeJob(workspaceId, waylineJob.getDockSn(), jobId, statusEnum);
+ break;
+ }
+
+ }
+
+ public WaylineJobStatusEnum getWaylineState(String dockSn) {
+ Optional<DeviceDTO> dockOpt = deviceRedisService.getDeviceOnline(dockSn);
+ if (dockOpt.isEmpty() || !StringUtils.hasText(dockOpt.get().getChildDeviceSn())) {
+ return WaylineJobStatusEnum.UNKNOWN;
+ }
+ Optional<OsdDockReceiver> dockOsdOpt = deviceRedisService.getDeviceOsd(dockSn, OsdDockReceiver.class);
+ Optional<OsdSubDeviceReceiver> deviceOsdOpt = deviceRedisService.getDeviceOsd(dockOpt.get().getChildDeviceSn(), OsdSubDeviceReceiver.class);
+ if (dockOsdOpt.isEmpty() || deviceOsdOpt.isEmpty() || DockModeCodeEnum.WORKING != dockOsdOpt.get().getModeCode()) {
+ return WaylineJobStatusEnum.UNKNOWN;
+ }
+
+ OsdSubDeviceReceiver osdDevice = deviceOsdOpt.get();
+ if (DeviceModeCodeEnum.WAYLINE == osdDevice.getModeCode()
+ || DeviceModeCodeEnum.MANUAL == osdDevice.getModeCode()
+ || DeviceModeCodeEnum.TAKEOFF_AUTO == osdDevice.getModeCode()) {
+ if (StringUtils.hasText(waylineRedisService.getPausedWaylineJobId(dockSn))) {
+ return WaylineJobStatusEnum.PAUSED;
+ }
+ if (waylineRedisService.getRunningWaylineJob(dockSn).isPresent()) {
+ return WaylineJobStatusEnum.IN_PROGRESS;
+ }
+ }
+ return WaylineJobStatusEnum.UNKNOWN;
+ }
+
+ private void pauseJob(String workspaceId, String dockSn, String jobId, WaylineJobStatusEnum statusEnum) {
+ if (WaylineJobStatusEnum.PAUSED == statusEnum && jobId.equals(waylineRedisService.getPausedWaylineJobId(dockSn))) {
+ waylineRedisService.setPausedWaylineJob(dockSn, jobId);
+ return;
+ }
+
+ ServiceReply reply = messageSender.publishServicesTopic(
+ dockSn, WaylineMethodEnum.FLIGHT_TASK_PAUSE.getMethod(), "", jobId);
+ if (ResponseResult.CODE_SUCCESS != reply.getResult()) {
+ throw new RuntimeException("Failed to pause wayline job. Error Code: " + reply.getResult());
+ }
+ waylineRedisService.delRunningWaylineJob(dockSn);
+ waylineRedisService.setPausedWaylineJob(dockSn, jobId);
+ }
+
+ private void resumeJob(String workspaceId, String dockSn, String jobId, WaylineJobStatusEnum statusEnum) {
+ Optional<EventsReceiver<WaylineTaskProgressReceiver>> runningDataOpt = waylineRedisService.getRunningWaylineJob(dockSn);
+ if (WaylineJobStatusEnum.IN_PROGRESS == statusEnum && jobId.equals(runningDataOpt.map(EventsReceiver::getSn).get())) {
+ waylineRedisService.setRunningWaylineJob(dockSn, runningDataOpt.get());
+ return;
+ }
+ ServiceReply reply = messageSender.publishServicesTopic(
+ dockSn, WaylineMethodEnum.FLIGHT_TASK_RESUME.getMethod(), "", jobId);
+ if (ResponseResult.CODE_SUCCESS != reply.getResult()) {
+ throw new RuntimeException("Failed to resume wayline job. Error Code: " + reply.getResult());
+ }
+
+ runningDataOpt.ifPresent(runningData -> waylineRedisService.setRunningWaylineJob(dockSn, runningData));
+ waylineRedisService.delPausedWaylineJob(dockSn);
+
+ if (deviceService.checkDockDrcMode(dockSn)) {
+ drcService.deviceDrcExit(workspaceId, DrcModeParam.builder().dockSn(dockSn)
+ .clientId(drcService.getDrcModeInRedis(dockSn)).build());
+ }
+
+ }
+
private WaylineJobDTO entity2Dto(WaylineJobEntity entity) {
if (entity == null) {
return null;
@@ -484,8 +635,8 @@
.username(entity.getUsername())
.workspaceId(entity.getWorkspaceId())
.status(WaylineJobStatusEnum.IN_PROGRESS.getVal() == entity.getStatus() &&
- RedisOpsUtils.checkExist(RedisConst.WAYLINE_JOB_PAUSED_PREFIX + entity.getJobId()) ?
- WaylineJobStatusEnum.PAUSED.getVal() : entity.getStatus())
+ entity.getJobId().equals(waylineRedisService.getPausedWaylineJobId(entity.getDockSn())) ?
+ WaylineJobStatusEnum.PAUSED.getVal() : entity.getStatus())
.code(entity.getErrorCode())
.beginTime(LocalDateTime.ofInstant(Instant.ofEpochMilli(entity.getBeginTime()), ZoneId.systemDefault()))
.endTime(Objects.nonNull(entity.getEndTime()) ?
@@ -503,11 +654,12 @@
if (Objects.nonNull(entity.getEndTime())) {
builder.endTime(LocalDateTime.ofInstant(Instant.ofEpochMilli(entity.getEndTime()), ZoneId.systemDefault()));
}
- if (WaylineJobStatusEnum.IN_PROGRESS.getVal() == entity.getStatus() && RedisOpsUtils.getExpire(entity.getJobId()) > 0) {
- EventsReceiver<WaylineTaskProgressReceiver> taskProgress = (EventsReceiver<WaylineTaskProgressReceiver>) RedisOpsUtils.get(RedisConst.WAYLINE_JOB_RUNNING_PREFIX + entity.getDockSn());
- if (Objects.nonNull(taskProgress.getOutput()) && Objects.nonNull(taskProgress.getOutput().getProgress())) {
- builder.progress(taskProgress.getOutput().getProgress().getPercent());
- }
+ if (WaylineJobStatusEnum.IN_PROGRESS.getVal() == entity.getStatus()) {
+ builder.progress(waylineRedisService.getRunningWaylineJob(entity.getDockSn())
+ .map(EventsReceiver::getOutput)
+ .map(WaylineTaskProgressReceiver::getProgress)
+ .map(WaylineTaskProgress::getPercent)
+ .orElse(null));
}
if (entity.getMediaCount() == 0) {
--
Gitblit v1.9.3