qinyanlei
/
inspect
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
Browse Source

手动点位修改

master
lijiuwei 8 months ago
parent
37c4d8990b
commit
2afa7232f0
3 changed files with 53 additions and 890 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +7
    -7
      inspect-base/inspect-base-core/src/main/java/com/inspect/base/core/constant/RedisConst.java
  2. +23
    -0
      inspect-base/inspect-base-redis/src/main/java/com/inspect/base/redis/service/RedisService.java
  3. +23
    -883
      inspect-job/src/main/java/com/inspect/job/task/JobMainTask.java

+ 7
- 7
inspect-base/inspect-base-core/src/main/java/com/inspect/base/core/constant/RedisConst.java View File

@ -1,16 +1,16 @@
package com.inspect.base.core.constant;
public class RedisConst {
public static final String TASK_PATROL_ID = "TASK_PATROL_ID";
public static final String TASK_PATROL_ID_EX = "TASK+PATROL+ID@";
public static final String TASK_PATROL_STOP = "PATROL_TASK_STOP";//没有获取该key的地方
public static final String TASK_CODE_EX = "TASK_CODE@*";//查询匹配用
public static final String TASK_PATROL_ID = "TASK_PATROL_ID";//已经和taskcode关联
public static final String TASK_CODE = "TASK_CODE@";//已经和taskcode关联
public static final String REQUEST_UUID = "REQUEST_UUID@";//已经和uuid关联
public static final String TASK_PATROL_STATE = "TASK_PATROL_STATE";
public static final String TASK_PATROL_STOP = "PATROL_TASK_STOP";
public static final String TASK_CODE = "TASK_CODE@";
public static final String TASK_CODE_EX = "TASK_CODE@*";
public static final String TASK_RECORD_CNT = "TASK_RECORD_CNT";
public static final String TASK_CURRENT_CODE = "TASK_CURRENT_CODE@";
public static final String TASK_REPEAT_CODE = "TASK_REPEAT_CODE@";
public static final String TASK_TIMER_CLOCK = "TASK_TIMER_CLOCK";
public static final String IMMEDIATELY_EXEC_TASK_TIME = "IMMEDIATELY_EXEC_TASK_TIME";
public static final String REQUEST_UUID = "REQUEST_UUID@";
}

+ 23
- 0
inspect-base/inspect-base-redis/src/main/java/com/inspect/base/redis/service/RedisService.java View File

@ -31,11 +31,23 @@ public class RedisService {
redisTemplate.opsForValue().set(key, value);
}
public <T> void setCacheObjectOfTask(String key, String taskCode, T value) {
//logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject key: {}" + Color.END, key);
redisTemplate.opsForValue().set(key + taskCode, value);
logger.info("RedisService.trace setCacheObjectOfTask: {}", key + taskCode);
}
public <T> void setCacheObject(String key, T value, Long timeout, TimeUnit timeUnit) {
//logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject2 key: {}" + Color.END, key);
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
public <T> void setCacheObjectOfTask(String key, String taskCode, T value, Long timeout, TimeUnit timeUnit) {
//logger.info(Color.MAGENTA + "[GABRIEL] setCacheObject2 key: {}" + Color.END, key);
redisTemplate.opsForValue().set(key + taskCode, value, timeout, timeUnit);
logger.info("RedisService.trace setCacheObjectOfTask2: {}", key + taskCode);
}
public boolean expire(String key, long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
@ -57,10 +69,21 @@ public class RedisService {
return operation.get(key);
}
public <T> T getCacheObjectOfTask(String key, String taskCode) {
ValueOperations<String, T> operation = redisTemplate.opsForValue();
logger.info("RedisService.trace getCacheObjectOfTask: {}", key + taskCode);
return operation.get(key + taskCode);
}
public boolean deleteObject(String key) {
return redisTemplate.delete(key).booleanValue();
}
public boolean deleteObjectOfTask(String key, String taskCode) {
logger.info("RedisService.trace deleteObjectOfTask: {}", key + taskCode);
return redisTemplate.delete(key + taskCode).booleanValue();
}
public long deleteObject(Collection collection) {
return redisTemplate.delete(collection).longValue();
}


+ 23
- 883
inspect-job/src/main/java/com/inspect/job/task/JobMainTask.java View File

@ -121,207 +121,6 @@ public class JobMainTask {
this.sftpClient = sftpClient;
}
@SuppressWarnings({"unused"})
public void generalTask() {
if (shaoXinBigModel.isSwitchStatus()) {
log.info("[GABRIEL][BIG-MODEL] gathering temporary handling, need to close nacos bigSwitch");
redisService.redisTemplate.opsForValue().set(this.BIG_FILE_POINT, -1);
}
boolean isCycle = false;
boolean isInterval = false;
String[] cycleExecuteTime = new String[3];
String currentWeek = getWeekOfDate(new Date());
Calendar now = Calendar.getInstance();
int day = DateUtils.getDayInt();
int hour = DateUtils.getHourInt();
int minute = DateUtils.getMinuteInt();
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
try {
List<PatrolTask> patrolTaskList = taskExecClient.selectTaskList(PatrolTask.builder().isEnable(TASK_ENABLE).build());
log.info(Color.GREEN + "[GABRIEL] {inspect-main} selectTaskList task count: {}" + Color.END, patrolTaskList.size());
for (PatrolTask task : patrolTaskList) {
if (TASK_TYPE_SILENCE.equals(task.getType()) || TASK_TYPE_LINKAGE.equals(task.getType())) {
continue;
}
List<PatrolTaskExecRecord> patrolTaskExecRecordList =
taskExecClient.selectCameraPatrolTaskExecRecordList(task.getDevNo(), Collections.singletonList(TaskStatus.RUNNING.getCode()));
if (!patrolTaskExecRecordList.isEmpty()) {
String time = "";
String[] intervalExecuteTime;
if (isCycle) {
int i;
String[] cycleExecuteTimes;
String week;
if (StringUtils.isNotEmpty(task.getCycleMonth())) {
intervalExecuteTime = task.getCycleMonth().split(StringUtils.COMMA);
cycleExecuteTimes = task.getCycleMonth().split(StringUtils.COMMA);
for (i = 0; i < intervalExecuteTime.length; ++i) {
week = intervalExecuteTime[i];
time = cycleExecuteTimes[i].replaceAll(StringUtils.COLON, StringUtils.EMPTY);
if (day == Integer.parseInt(week) && task.getCycleExecuteTime() != null) {
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
}
} else if (StringUtils.isNotEmpty(task.getCycleWeek())) {
intervalExecuteTime = task.getCycleWeek().split(StringUtils.COMMA);
cycleExecuteTimes = task.getCycleExecuteTime().split(StringUtils.COMMA);
for (i = 0; i < intervalExecuteTime.length; ++i) {
week = intervalExecuteTime[i];
time = cycleExecuteTimes[i].replaceAll(StringUtils.COLON, StringUtils.EMPTY);
if (currentWeek.equals(week)) {
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
}
}
} else if (isInterval) {
intervalExecuteTime = task.getIntervalExecuteTime().split(StringUtils.COLON);
int j;
if ("1".equals(task.getIntervalType())) {
for (j = 0; j < task.getIntervalNumber(); ++j) {
if (j != 0) {
intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
}
time = hour + minute + cycleExecuteTime[2];
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
} else if ("2".equals(task.getIntervalType())) {
for (j = 0; j < task.getIntervalNumber(); ++j) {
if (j != 0) {
intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
}
redisService.setCacheObject(RedisConst.TASK_PATROL_ID_EX + task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d) + time, task);
}
}
}
} else {
long current = 0L;
long fixedStart = 1L;
patrolTaskExecRecordList = taskExecClient.selectCameraPatrolTaskExecRecordList(task.getDevNo(), Arrays.asList(TaskStatus.DONE.getCode(), TaskStatus.PAUSED.getCode()));
if (!patrolTaskExecRecordList.isEmpty()) {
PatrolTaskExecRecord patrolTaskExecRecord = patrolTaskExecRecordList.get(patrolTaskExecRecordList.size() - 1);
current = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
fixedStart = TimeUnit.MILLISECONDS.toMinutes(patrolTaskExecRecord.getStartTime().getTime());
}
if (current != fixedStart) {
PatrolPresetPos patrolPresetPos = new PatrolPresetPos();
PatrolPresetAction patrolPresetAction = new PatrolPresetAction();
PatrolTaskInfo patrolTaskInfo = new PatrolTaskInfo();
patrolTaskInfo.setTaskMajorId(String.valueOf(task.getTaskId()));
patrolTaskInfo.setDevNo(task.getDevNo());
if (task.getFixedStartTime() != null
&& ExecStatus.REGULAR.getCode().equals(task.getExecutionStatus())) {
isCycle = false;
isInterval = false;
long currentMinutes = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
long fixedStartMinutes = TimeUnit.MILLISECONDS.toMinutes(task.getFixedStartTime().getTime());
if (currentMinutes == fixedStartMinutes) {
try {
Thread.sleep(200L);
} catch (InterruptedException interruptedException) {
interruptedException.printStackTrace();
}
startThread(patrolTaskInfo, patrolPresetPos, patrolPresetAction, task);
}
} else {
String[] intervalExecuteTime;
if (StringUtils.isNotEmpty(task.getCycleExecuteTime())
&& task.getCycleStartTime() != null
&& Integer.parseInt(sdf.format(d)) >= Integer.parseInt(sdf.format(task.getCycleStartTime()))
&& Integer.parseInt(sdf.format(d)) <= Integer.parseInt(sdf.format(task.getCycleEndTime()))
&& ExecStatus.PERIODIC.getCode().equals(task.getExecutionStatus())) {
isCycle = true;
isInterval = false;
int i;
String month;
String[] cycleExecuteTimes;
if (StringUtils.isNotEmpty(task.getCycleWeek())) {
intervalExecuteTime = task.getCycleWeek().split(StringUtils.COMMA);
cycleExecuteTimes = task.getCycleExecuteTime().split(StringUtils.COMMA);
for (i = 0; i < intervalExecuteTime.length; ++i) {
month = intervalExecuteTime[i];
if (currentWeek.equals(month)) {
cycleExecuteTime = cycleExecuteTimes[i].split(StringUtils.COLON);
startThread(patrolTaskInfo,
patrolPresetPos,
patrolPresetAction,
hour,
minute,
task,
cycleExecuteTime,
true);
}
}
} else if (StringUtils.isNotEmpty(task.getCycleMonth())) {
intervalExecuteTime = task.getCycleMonth().split(StringUtils.COMMA);
cycleExecuteTimes = task.getCycleExecuteTime().split(StringUtils.COMMA);
for (i = 0; i < intervalExecuteTime.length; ++i) {
month = intervalExecuteTime[i];
if (day == Integer.parseInt(month) && task.getCycleExecuteTime() != null) {
cycleExecuteTime = cycleExecuteTimes[i].split(StringUtils.COLON);
startThread(patrolTaskInfo,
patrolPresetPos,
patrolPresetAction,
hour,
minute,
task,
cycleExecuteTime,
true);
}
}
}
} else if (StringUtils.isNotEmpty(task.getIntervalExecuteTime())
&& task.getIntervalStartTime() != null
&& Integer.parseInt(sdf.format(d)) >= Integer.parseInt(sdf.format(task.getIntervalStartTime()))
&& Integer.parseInt(sdf.format(d)) <= Integer.parseInt(sdf.format(task.getIntervalEndTime()))
&& ExecStatus.INTERVAL.getCode().equals(task.getExecutionStatus())) {
isCycle = false;
isInterval = true;
intervalExecuteTime = task.getIntervalExecuteTime().split(StringUtils.COLON);
if ("1".equals(task.getIntervalType())) {
for (int j = 0; j < task.getIntervalNumber(); ++j) {
if (j != 0) {
intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
}
startThread(patrolTaskInfo, patrolPresetPos, patrolPresetAction, hour, minute, task, intervalExecuteTime, false);
}
} else if ("2".equals(task.getIntervalType())) {
for (int j = 0; j < task.getIntervalNumber(); ++j) {
if (j != 0) {
intervalExecuteTime[0] = String.valueOf(Integer.parseInt(intervalExecuteTime[0]) + 1);
}
startThread(patrolTaskInfo,
patrolPresetPos,
patrolPresetAction,
hour,
minute,
task,
intervalExecuteTime,
false);
}
}
}
}
}
}
}
} catch (Exception e) {
if (e instanceof RetryableException)
log.warn(Color.YELLOW + "[GABRIEL] {inspect-main} selectTaskList is not online!" + Color.END);
else
e.printStackTrace();
}
}
private void startThread(
final PatrolTaskInfo patrolTaskInfo,
final PatrolPresetPos patrolPresetPos,
@ -825,23 +624,6 @@ public class JobMainTask {
}
}
private String calcTotalProgress(PatrolTaskExecRecord taskExecRecord) {
//从patrol_task_info表中查询任务taskCode比如1220下所有的点位
List<PatrolTaskInfo> patrolTaskInfoList =
taskExecClient.selectTaskInfoList(PatrolTaskInfo.builder().taskMajorId(taskExecRecord.getTaskId().toString()).build());
List<PatrolTaskInfo> patrolTaskInfoListTemp = patrolTaskInfoMaintainAreaRemove(patrolTaskInfoList);
//从patrol_task_point_exec_record表中查询当前任务已经执行的点位信息
List<PatrolTaskPointExecRecord> patrolTaskPointExecRecordList
= taskExecClient.selectPatrolTaskPointExecRecordList(PatrolTaskPointExecRecord.builder()
.taskCode(taskExecRecord.getTaskCode())
.oldTaskPatrolledId(taskExecRecord.getOldTaskPatrolId())
.build());
log.info("[JOB] calcTotalProgress patrolTaskPointExecRecordList size: {}, patrolTaskInfoListTemp size: {}", patrolTaskPointExecRecordList.size(), patrolTaskInfoListTemp.size());
String taskProgress = decimalFormatNum(patrolTaskPointExecRecordList.size(), patrolTaskInfoListTemp.size());
log.info("[JOB] calcTotalProgress progress: {}, taskName: {}, taskCode: {}, OldTaskPatrolledId: {}", taskProgress, taskExecRecord.getTaskName(), taskExecRecord.getTaskCode(), taskExecRecord.getOldTaskPatrolId());
return taskProgress;
}
private int addCursorNumber(String taskPatrolId, boolean bPointFinished, boolean bOk) {
PatrolTaskExecRecord taskExecRecord = taskExecClient.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolId);
@ -881,18 +663,6 @@ public class JobMainTask {
return cursor;
}
// private int addFinishNumber(String taskPatrolId) {
// PatrolTaskExecRecord execRecord = taskExecClient.selectPatrolTaskExecRecordByTaskPatrolId(taskPatrolId);
// int finish = execRecord.getFinishNumber();
// int total = execRecord.getTotalNumber();
// int value = finish + 1;
// log.debug("[JOB] addFinishNumber finish: {}, total: {}", value, total);
// execRecord.setFinishNumber(value);
// execRecord.setTaskProgress(decimalFormatNum(finish, total));
// taskExecClient.updatePatrolTaskExecRecord(execRecord);
// return value;
// }
private void resetTaskTimerClock() {
redisService.setCacheObject(RedisConst.TASK_TIMER_CLOCK, System.currentTimeMillis());
}
@ -956,58 +726,31 @@ public class JobMainTask {
log.info(Color.MAGENTA + "RECORD ROUND, patrolId: {}, recordCounter: {}, redisRecCnt: {}" + Color.END, taskPatrolId, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) { // 最后一个record
resetRecordCounter();
final String repeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
if (StringUtils.isEmpty(repeatCode)) {
//所有的records都完美的执行成功, 要把redis标记清除，不然以后的任务如何执行？
resetRedisCurrentCode();
}
String redisImmediatelyExecTaskTime = redisService.getCacheObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
if (!StringUtils.isEmpty(redisImmediatelyExecTaskTime)) {
redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
}
resetRedisCurrentCode();
redisService.deleteObject(RedisConst.IMMEDIATELY_EXEC_TASK_TIME);
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
} else { // 该record下的点没有全部执行成功，设置下一轮执行标记
int times = execRecord.getRebootTimes();
if (times > 0) {
times--;
execRecord.setRebootTimes(times);
execRecord.setCursorNumber(0);
final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.MAGENTA + "[JOB] TIMES > 0, taskPatrolId: {}, execRecordCounter: {}, redisRecCnt: {}" + Color.END, taskPatrolId, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) {//最后一个record, 复位
resetRecordCounter();
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
final String repeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
if (StringUtils.isEmpty(repeatCode)) {
log.info(Color.MAGENTA + "[JOB] SET REPEAT FLAG patrolId: {}" + Color.END, taskPatrolId);
String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
redisService.setCacheObject(RedisConst.TASK_REPEAT_CODE, taskRepeatCode);
}
} else if (times == 0) {//一个record的尝试次数为0，其它的record正在执行中
//设置本record的执行状态为终止
execRecord.setTaskState(TaskStatus.HALTED.getCode());
List<PatrolTaskInfo> totalInfos = getInfosByTaskCode(execRecord);
List<PatrolTaskPointExecRecord> finishedInfos = taskExecClient.selectPatrolTaskPointExecRecordList(PatrolTaskPointExecRecord.builder().oldTaskPatrolledId(execRecord.getOldTaskPatrolId()).build());
String totalProgress = decimalFormatNum(finishedInfos.size(), totalInfos.size());
log.info("[JOB] 1 totalProgress: {}, finish: {}, total: {}", totalProgress, finishedInfos.size(), totalInfos.size());
callRemoteSendMsgRunMode(
execRecord.getTaskCode(),
execRecord.getTaskName(),
execRecord.getTaskPatrolId(),
totalProgress,
TaskStatus.DONE.getCode()
);
//在不知道其它record是否执行完毕的情况下，不能把TASK_CURRENT_CODE锁删除
final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.MAGENTA + "[JOB] TIMES 0, execRecordCounter: {}, redisRecCnt: {}" + Color.END, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) {
resetRecordCounter();
resetRedisCurrentCode();
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
} else { // 该record下的点没有全部执行成功
//设置本record的执行状态为终止
execRecord.setTaskState(TaskStatus.HALTED.getCode());
List<PatrolTaskInfo> totalInfos = getInfosByTaskCode(execRecord);
List<PatrolTaskPointExecRecord> finishedInfos = taskExecClient.selectPatrolTaskPointExecRecordList(PatrolTaskPointExecRecord.builder().oldTaskPatrolledId(execRecord.getOldTaskPatrolId()).build());
String totalProgress = decimalFormatNum(finishedInfos.size(), totalInfos.size());
log.info("[JOB] 1 totalProgress: {}, finish: {}, total: {}", totalProgress, finishedInfos.size(), totalInfos.size());
callRemoteSendMsgRunMode(
execRecord.getTaskCode(),
execRecord.getTaskName(),
execRecord.getTaskPatrolId(),
totalProgress,
TaskStatus.DONE.getCode()
);
//在不知道其它record是否执行完毕的情况下，不能把TASK_CURRENT_CODE锁删除
final int redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.MAGENTA + "[JOB] TIMES 0, execRecordCounter: {}, redisRecCnt: {}" + Color.END, execRecordCounter, redisRecCnt);
if (execRecordCounter == redisRecCnt) {
resetRecordCounter();
resetRedisCurrentCode();
calcExecCostTime(execRecord.getOldTaskPatrolId());
}
}
}
@ -1069,106 +812,6 @@ public class JobMainTask {
}
@SuppressWarnings({"unused"})
private void prePointExceSilenceControl(PatrolTask task, List<PatrolTaskInfo> patrolTaskInfoList, SimpleDateFormat sdf) {
if (patrolTaskInfoList != null && !patrolTaskInfoList.isEmpty()) {
PatrolTaskInfo patrolTaskInfo = patrolTaskInfoList.get(0);
try {
PatrolPresetPos patrolPresetPos = new PatrolPresetPos();
patrolPresetPos.setPresetPosCode(patrolTaskInfo.getPresetCode());
patrolPresetPos.setIsEnable("1");
List<PatrolPresetPos> patrolPresetPosList = this.taskExecClient.selectPatrolPresetPosList(patrolPresetPos);
if (patrolPresetPosList != null) {
patrolPresetPos = patrolPresetPosList.get(0);
}
Date d = new Date();
int year = DateUtils.getYearInt();
int month = DateUtils.getMonthInt() + 1;
int day = DateUtils.getDayInt();
String basePath;
try {
basePath = "serial=" + patrolPresetPos.getVideoNvrCode() + "&command=goto&preset=" + patrolPresetPos.getPresetPosCode() + "&code=" + patrolPresetPos.getChannelCode();
this.log.info("预置点转到接口 ：{}", "任务编号 ：" + task.getTaskCode() + " " + this.liveIVS_URL + this.API_CONTROL_PRESET + basePath);
HttpClientUtils.get(this.liveIVS_URL + this.API_CONTROL_PRESET, basePath);
} catch (Exception e) {
e.printStackTrace();
}
basePath = (task.getStationCode() == null ? this.stationCode : task.getStationCode()) + "/" + year + "/" + month + "/" + day + "/" + task.getTaskCode() + "/";
String param = "?serial=" + patrolPresetPos.getVideoNvrCode() + "&realtime=true&code=" + patrolPresetPos.getChannelCode();
String channelsnap = "/api/v1/device/channelsnap";
FtpResult ftpResult = this.saveFile(this.liveIVS_URL + channelsnap + param, patrolPresetPos.getPatrolPointId() + "_" + task.getDevNo() + "_" + sdf.format(d) + ".jpg", basePath);
this.log.info("通道拍照接口 ：{}", this.liveIVS_URL + this.API_CONTROL_PRESET + param);
PatrolPresetParam patrolPresetParam = new PatrolPresetParam();
patrolPresetParam.setPresetPosId(Long.parseLong(patrolPresetPos.getPresetPosId()));
List<PatrolPresetParam> patrolPresetParams = this.taskExecClient.selectPatrolPresetParamList(patrolPresetParam);
StringBuffer rectangles = new StringBuffer();
if (patrolPresetParams != null) {
for (PatrolPresetParam presetParam : patrolPresetParams) {
rectangles.append(presetParam.getCoordinate()).append(";");
}
}
SilenceTaskPointExecRecord silenceTaskPointExecRecord = new SilenceTaskPointExecRecord();
silenceTaskPointExecRecord.setDeviceId(patrolTaskInfo.getDeviceId());
silenceTaskPointExecRecord.setFilePath(ftpResult.getFilepath());
silenceTaskPointExecRecord.setFileType("2");
silenceTaskPointExecRecord.setPatrolDeviceCode(task.getDevNo());
silenceTaskPointExecRecord.setPatrolDeviceName("");
silenceTaskPointExecRecord.setTaskCode(task.getTaskCode());
silenceTaskPointExecRecord.setTaskName(task.getTaskName());
silenceTaskPointExecRecord.setPatrolPointId(Long.parseLong(patrolTaskInfo.getDeviceId()));
silenceTaskPointExecRecord.setTaskPatrolledId(task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d));
silenceTaskPointExecRecord.setRecognitionType(patrolPresetPos.getAlgSubtypeCode());
silenceTaskPointExecRecord.setRectangle(rectangles.toString());
taskExecClient.addSilenceTaskPointExecRecord(silenceTaskPointExecRecord);
log.info("文件保存路径 filePath ：{}", ftpResult.getFilepath());
log.info("发通知，向巡检任务分析接口中发送静默任务执行信息，静默任务信息发送到智能分析进行分析 开始 ：Type 61");
PatrolResultData patrolResultData = new PatrolResultData();
patrolResultData.setType(StaEnum.CtlModel.getCode());
patrolResultData.setReceiveCode("");
patrolResultData.setSendCode("");
List<PatrolResult> patrolResults = new ArrayList<>();
PatrolResult patrolResult = new PatrolResult();
patrolResult.setTaskPatrolledId(silenceTaskPointExecRecord.getTaskPatrolledId());
patrolResult.setDeviceId(silenceTaskPointExecRecord.getDeviceId());
patrolResult.setDeviceName(silenceTaskPointExecRecord.getDeviceName());
patrolResult.setFilePath(silenceTaskPointExecRecord.getFilePath());
patrolResult.setFileType(silenceTaskPointExecRecord.getFileType());
patrolResult.setPatrolDeviceCode(silenceTaskPointExecRecord.getPatrolDeviceCode());
patrolResult.setPatrolDeviceName(silenceTaskPointExecRecord.getPatrolDeviceName());
patrolResult.setRectangle(silenceTaskPointExecRecord.getRectangle());
patrolResult.setTaskCode(silenceTaskPointExecRecord.getTaskCode());
patrolResult.setTaskName(silenceTaskPointExecRecord.getTaskName());
String recognitionType = algMapping(silenceTaskPointExecRecord.getPatrolPointId());
log.info("算法识别类型对应关系 recognition_type ：{}", patrolResult.getRecognitionType());
patrolResult.setRecognitionType(recognitionType);
sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
patrolResult.setTime(sdf.format(new Date()));
patrolResult.setUnit("");
patrolResult.setValid("1");
patrolResult.setValue("");
patrolResult.setValueType("");
patrolResult.setValueUnit("");
patrolResults.add(patrolResult);
patrolResultData.setItems(patrolResults);
Object obj = JSONArray.toJSON(patrolResultData);
log.info("调用任务结果接口 开始 type = 61 json 内容 ：{} ", obj.toString());
taskExecClient.getInfo(StaEnum.CtlModel.getCode(), obj.toString());
log.info("调用任务结果接口结束 type = 61 发通知，向巡检任务分析接口中发送静默任务执行信息，静默任务信息发送到智能分析进行分析 结束 ");
} catch (Exception e) {
e.printStackTrace();
log.error("向巡检任务分析接口中发送静默任务执行信息异常 Exception: ", e);
}
}
}
private String algMapping(Long patrolPointId) {
String dictValue = StringUtils.EMPTY;
DBPatrolPoint dbPatrolPoint = taskExecClient.selectBasedataPatrolPointByPatrolPointId(patrolPointId);
@ -1199,49 +842,6 @@ public class JobMainTask {
return dictValue;
}
private void prePointContinueExec(PatrolTaskExecRecord patrolTaskExecRecord) {
PatrolTaskInfo patrolTaskInfo = PatrolTaskInfo.builder()
.devNo(patrolTaskExecRecord.getDevNo())
.taskMajorId(patrolTaskExecRecord.getTaskCode())
.build();
List<PatrolTaskInfo> patrolTaskInfoList = taskExecClient.selectTaskInfoList(patrolTaskInfo);
/**
* 从当前正在维修表maintain_region表中查询当前正在维修的点位，
* 并把这些点位排除出巡检任务
*/
List<PatrolTaskInfo> patrolTaskInfoListTemp = patrolTaskInfoMaintainAreaRemove(patrolTaskInfoList);
boolean bContinue = false;
int size = patrolTaskInfoListTemp.size();
/**
* 该任务下面的patrol_task_info中的设备点一个都没有执行(patrol_task_point_exec_record查不到任何该任务点的执行记录)
* 这种情况下当前点一定要执行prePointExec，否则就会遗漏该点
*/
for (PatrolTaskInfo taskInfo : patrolTaskInfoListTemp) {
final String deviceIdOfInfo = taskInfo.getDeviceId();
if (!bContinue) {
final String deviceIdOfRecord = patrolTaskExecRecord.getDeviceId();
//log.info("[JOB] devId: {}, devId2: {}", deviceIdOfRecord, deviceIdOfInfo);
if (deviceIdOfInfo.equals(deviceIdOfRecord)) {
Long execPointId = patrolTaskExecRecord.getExecPointId();
log.info("[JOB] TASK RESUMED, LOCK IT! {}", "POINT=" + execPointId + ", NAME=" + patrolTaskExecRecord.getTaskName() + ", ID=" + patrolTaskExecRecord.getTaskPatrolId());
patrolTaskExecRecord.setDeviceId("-1");
patrolTaskExecRecord.setExecPointId(-1L);
taskExecClient.updatePatrolTaskExecRecord(patrolTaskExecRecord);
bContinue = true;
/**
* 该任务下面的patrol_task_info中的设备点一个都没有执行(patrol_task_point_exec_record查不到任何该任务点的执行记录)
* 这种情况下当前点一定要执行prePointExec，否则就会遗漏该点
*/
if (execPointId == 0L) {
prePointExec(patrolTaskExecRecord, taskInfo, size);
}
}
} else {
prePointExec(patrolTaskExecRecord, taskInfo, size);
}
}
}
public static String getWeekOfDate(Date date) {
String[] weekDays = new String[]{"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
Calendar cal = Calendar.getInstance();
@ -1254,135 +854,6 @@ public class JobMainTask {
return weekDays[w];
}
@SuppressWarnings({"unused"})
public void continueTask() {
try {
/**
* select from patrol_task_exec_record where task_state=2(running)
*/
List<PatrolTaskExecRecord> execRecords
= taskExecClient.selectAbeyancePatrolTaskExecRecordList(PatrolTaskExecRecord.builder().build());
for (PatrolTaskExecRecord execRecord : execRecords) {
threadPool.submit(() -> {
final String deviceId = execRecord.getDeviceId();
if (!StringUtils.isEmpty(deviceId)) {
log.info(Color.GREEN + "[JOB] RESUME devNo: {}, taskId: {}, deviceId: {}" + Color.END, execRecord.getDevNo(), execRecord.getTaskId(), deviceId);
prePointContinueExec(execRecord);
}
});
}
} catch (Exception e) {
if (e instanceof RetryableException) {
log.warn(Color.YELLOW + "[GABRIEL] inspect-main is not online!" + Color.END);
} else {
log.warn(Color.YELLOW + "[GABRIEL] other exception!" + Color.END);
}
}
}
@SuppressWarnings({"unused"})
public void silenceTask() {
PatrolTask patrolTask = new PatrolTask();
patrolTask.setType(TASK_TYPE_SILENCE);
patrolTask.setIsEnable(TASK_ENABLE);
Set<String> noRunDevices = new HashSet();
List<PatrolTask> patrolTaskList = taskExecClient.selectTaskList(patrolTask);
List<String> taskStates = new ArrayList<>();
taskStates.add(TASK_STATUS_RUN);
taskStates.add(TASK_STATUS_STOP);
Iterator<PatrolTask> iterator = patrolTaskList.iterator();
while (iterator.hasNext()) {
PatrolTask task = iterator.next();
List<PatrolTaskExecRecord> patrolTaskExecRecordList = taskExecClient.selectCameraPatrolTaskExecRecordList(task.getDevNo(), taskStates);
String key = REDIS_TASK_SILENCE_DEVICE + task.getDevNo();
if (patrolTaskExecRecordList.isEmpty()) {
if (!redisService.hasKey(key)) {
log.info("[GABRIEL] key1: {}", key);
redisService.setCacheObject(key, new Date());
} else {
Date deviceStopTime = this.redisService.getCacheObject(key);
if (CalendarUtil.expire(deviceStopTime, task.getIntervalNumber())) {
redisService.deleteObject(key);
this.log.info("silenceTask 静默任务开始执行 任务编号 ：{}", task.getTaskCode());
PatrolTaskInfo patrolTaskInfo = new PatrolTaskInfo();
patrolTaskInfo.setTaskMajorId(task.getTaskId().toString());
patrolTaskInfo.setDevNo(task.getDevNo());
this.startThread(patrolTaskInfo, new PatrolPresetPos(), new PatrolPresetAction(), task);
}
}
} else if (!TASK_TYPE_SILENCE.equals((patrolTaskExecRecordList.get(0)).getTaskType())) {
noRunDevices.add(task.getDevNo());
}
}
if (!noRunDevices.isEmpty()) {
noRunDevices.forEach((devNo) -> {
redisService.deleteObject(REDIS_TASK_SILENCE_DEVICE + devNo);
});
}
}
@SuppressWarnings({"unused"})
public void linkageTask() {
PatrolTask patrolTask = new PatrolTask();
patrolTask.setType(TASK_TYPE_LINKAGE);
patrolTask.setLinkageState("1");
PatrolTaskInfo patrolTaskInfo = new PatrolTaskInfo();
PatrolPresetPos patrolPresetPos = new PatrolPresetPos();
PatrolPresetAction patrolPresetAction = new PatrolPresetAction();
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
List<PatrolTask> patrolTaskList = taskExecClient.selectTaskList(patrolTask);
for (PatrolTask task : patrolTaskList) {
Date d = new Date();
PatrolTaskExecRecord patrolTaskExecRecord = new PatrolTaskExecRecord();
patrolTaskExecRecord.setTaskPatrolId(task.getDevNo() + "_" + task.getTaskCode() + "_" + sdf.format(d));
patrolTaskExecRecord.setOldTaskPatrolId(task.getTaskCode() + "_" + sdf.format(d));
patrolTaskExecRecord.setTaskName(task.getTaskName());
patrolTaskExecRecord.setTaskCode(task.getTaskCode());
patrolTaskExecRecord.setTaskState(TASK_STATUS_RUN);
patrolTaskExecRecord.setPlanStartTime(task.getCycleStartTime());
patrolTaskExecRecord.setStartTime(new Date());
patrolTaskExecRecord.setTaskProgress("");
patrolTaskExecRecord.setEndTime(task.getCycleEndTime());
patrolTaskExecRecord.setDescription("");
patrolTaskExecRecord.setDevNo(task.getDevNo());
patrolTaskExecRecord.setTaskType(task.getType());
patrolTaskExecRecord.setTaskPriority(task.getPriority());
patrolTaskExecRecord.setTaskId(task.getTaskId());
patrolTaskExecRecord.setStationName(task.getStationName());
patrolTaskExecRecord.setStationCode(task.getStationCode());
log.info("linkageTask 联动任务执行 任务编号 ：{}", task.getTaskCode());
taskExecClient.addPatrolTaskExecRecord(patrolTaskExecRecord);
log.info("添加 联动任务执行 主表信息 完成 ：{}", "任务执行id TaskPatrolledId ：" + patrolTaskExecRecord.getTaskPatrolId());
patrolTaskInfo.setTaskMajorId(task.getTaskId().toString());
patrolTaskInfo.setDevNo(task.getDevNo());
List<PatrolTaskInfo> patrolTaskInfoList = taskExecClient.selectTaskInfoList(patrolTaskInfo);
linkagePrePointExceControl(patrolTaskExecRecord, patrolPresetPos, patrolPresetAction, patrolTaskInfoList);
task.setLinkageState("2");
taskExecClient.updatePatrolTask(task);
}
}
private void linkagePrePointExceControl(PatrolTaskExecRecord patrolTaskExecRecord, PatrolPresetPos patrolPresetPos, PatrolPresetAction patrolPresetAction, List<PatrolTaskInfo> patrolTaskInfoList) {
PatrolTaskExecRecord taskExecRecord = this.taskExecClient.selectPatrolTaskExecRecordByTaskPatrolId(patrolTaskExecRecord.getTaskPatrolId());
if (taskExecRecord != null && TASK_STATUS_RUN.equals(taskExecRecord.getTaskState())) {
boolean continueExce = true;
int patrolTaskInfoListSize = patrolTaskInfoList.size();
for (int ii = 0; ii < patrolTaskInfoListSize; ++ii) {
PatrolTaskInfo taskInfo = patrolTaskInfoList.get(ii);
taskExecRecord = this.taskExecClient.selectPatrolTaskExecRecordByTaskPatrolId(patrolTaskExecRecord.getTaskPatrolId());
if (taskExecRecord != null && (TASK_STATUS_STOP.equals(taskExecRecord.getTaskState()) || "4".equals(taskExecRecord.getTaskState()))) {
continueExce = false;
}
log.info("联动任务执行预置位 信息 ：{}", "DeviceId ：" + taskInfo.getDeviceId() + ",DevNo:" + taskInfo.getDevNo());
prePointExec(taskExecRecord, taskInfo, patrolTaskInfoListSize);
}
}
}
@PostMapping({"/immediatelyExecTask"})
public void immediatelyExecTask(@RequestBody PatrolTask patrolTask) {
String taskCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
@ -1477,103 +948,10 @@ public class JobMainTask {
}
}
private void incrementRedisRecordCounter() {
Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
if (redisRecCnt == null) {
redisRecCnt = 1;
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, redisRecCnt);
} else {
redisRecCnt++;
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, redisRecCnt);
}
log.info(Color.GREEN + "[JOB] redisRecCnt: {}" + Color.END, redisRecCnt);
}
private void setRedisRecordCount(final int size) {
redisService.setCacheObject(RedisConst.TASK_RECORD_CNT, size);
}
private String getTaskPatrolId(final PatrolTask patrolTask) {
String time = DateUtils.format(DateUtils.yyyyMMddHHmmss, patrolTask.getFixedStartTime());
return patrolTask.getDevNo() + "_" + patrolTask.getTaskCode() + "_" + time;
}
private String getOldTaskPatrolId(final PatrolTask patrolTask) {
String time = DateUtils.format(DateUtils.yyyyMMddHHmmss, patrolTask.getFixedStartTime());
return patrolTask.getTaskCode() + "_" + time + "_" + time;
}
public void execEveryDayTask(List<PatrolTask> patrolTaskList) {
setRedisRecordCount(patrolTaskList.size());
for (PatrolTask patrolTask : patrolTaskList) {
List<PatrolTaskInfo> taskInfos = getInfosByRecord(PatrolTaskExecRecord.builder().devNo(patrolTask.getDevNo()).taskId(patrolTask.getTaskId()).build());
final String taskPatrolId = getTaskPatrolId(patrolTask);
final String oldTaskPatrolId = getOldTaskPatrolId(patrolTask);
log.info(Color.GREEN + "[JOB] NEW EXEC RECORD: {}, OLD: {}" + Color.END, taskPatrolId, oldTaskPatrolId);
PatrolTaskExecRecord patrolTaskExecRecord = PatrolTaskExecRecord.builder()
.taskPatrolId(taskPatrolId)
.oldTaskPatrolId(oldTaskPatrolId)
.taskName(patrolTask.getTaskName())
.taskCode(patrolTask.getTaskCode())
.taskState(TaskStatus.RUNNING.getCode())
.planStartTime(patrolTask.getCycleStartTime())
.startTime(new Date())
.taskProgress("0")
.endTime(patrolTask.getCycleEndTime())
.description("")
.devNo(patrolTask.getDevNo())
.taskType(patrolTask.getType())
.taskPriority(patrolTask.getPriority())
.taskId(patrolTask.getTaskId())
.stationName(patrolTask.getStationName())
.stationCode(patrolTask.getStationCode())
.deviceId("0")
.execPointId(0L)
.totalNumber(taskInfos.isEmpty() ? 1 : taskInfos.size())
.build();
try {
taskExecClient.addPatrolTaskExecRecord(patrolTaskExecRecord);
taskExecClient.updatePatrolTaskStatus(patrolTask);
} catch (Exception e) {
e.printStackTrace();
}
threadPool.submit(() -> {
log.info(Color.MAGENTA + "[JOB] THREAD START devNo: {}, taskId: {}" + Color.END, patrolTaskExecRecord.getDevNo(), patrolTaskExecRecord.getTaskId());
prePointExecImmediate(patrolTaskExecRecord);
log.info(Color.MAGENTA + "[JOB] THREAD END devNo: {}, taskId: {}" + Color.END, patrolTaskExecRecord.getDevNo(), patrolTaskExecRecord.getTaskId());
});
}
}
public void execRepeatDayTask(List<PatrolTask> patrolTaskList) {
for (PatrolTask patrolTask : patrolTaskList) {
final String taskPatrolId = getTaskPatrolId(patrolTask);
final String oldTaskPatrolId = getOldTaskPatrolId(patrolTask);
log.info(Color.GREEN + "[JOB] REPEAT EXEC RECORD: {}, OLD: {}" + Color.END, taskPatrolId, oldTaskPatrolId);
List<PatrolTaskExecRecord> taskExecRecords =
taskExecClient.selectPatrolTaskExecRecordList(PatrolTaskExecRecord.builder()
.taskPatrolId(taskPatrolId)
.oldTaskPatrolId(oldTaskPatrolId)
.build());
if (taskExecRecords.isEmpty()) continue;
PatrolTaskExecRecord execRecord = taskExecRecords.get(0);//理论上来说只能有一条
int finish = execRecord.getFinishNumber();
int total = execRecord.getTotalNumber();
int times = execRecord.getRebootTimes();
if (finish < total) {
log.info(Color.GREEN + "[JOB] REPEAT EXEC RECORD: id: {}, finish: {}, total: {}, times: {}, progress: {}" + Color.END, execRecord.getTaskPatrolId(), finish, total, times, execRecord.getTaskProgress());
incrementRedisRecordCounter();
threadPool.submit(() -> {
log.info(Color.MAGENTA + "[JOB] REPEAT START devNo: {}, taskId: {}" + Color.END, execRecord.getDevNo(), execRecord.getTaskId());
prePointExecImmediate(execRecord);
log.info(Color.MAGENTA + "[JOB] REPEAT END devNo: {}, taskId: {}" + Color.END, execRecord.getDevNo(), execRecord.getTaskId());
});
}
}
}
private void assembleVideoTask(List<PatrolTask> patrolTaskList, List<PatrolTask> cameraPatrolTasks) {
if (patrolTaskList != null) {
for (PatrolTask task : patrolTaskList) {
@ -1674,45 +1052,6 @@ public class JobMainTask {
return resList;
}
public static void main(String[] args) throws ParseException {
List<String> textList = null;
for (String text : textList) {
System.out.println("text: " + text);
}
Calendar now = Calendar.getInstance();
System.out.println("年：" + now.get(1));
System.out.println("月：" + (now.get(2) + 1));
System.out.println("日：" + now.get(5));
System.out.println("时：" + now.get(11));
System.out.println("分：" + now.get(12));
System.out.println("秒：" + now.get(13));
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
System.out.println("当前时间：" + (Integer.parseInt(sdf.format(d)) <= Integer.parseInt("20220429")));
System.out.println(System.currentTimeMillis());
long milliseconds = System.currentTimeMillis();
long minutes = TimeUnit.MILLISECONDS.toMinutes(milliseconds);
long seconds = TimeUnit.MILLISECONDS.toSeconds(milliseconds);
System.out.format("%d 毫秒 = %d 分钟\n", new Object[]{milliseconds, minutes});
System.out.println("Or");
System.out.format("%d 毫秒 = %d 秒", new Object[]{milliseconds, seconds});
System.out.println();
System.out.println(getWeekOfDate(new Date()));
sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis()));
System.out.println(TimeUnit.MILLISECONDS.toMinutes(sdf.parse("2022-05-24 10:25:26").getTime()));
DecimalFormat nf = new DecimalFormat("#");
double dd = 1234.0D;
nf.setMaximumIntegerDigits(3);
for (int i = 0; i < 6; ++i) {
float percentage = (float) (i + 1) / 6.0F;
System.out.println(nf.format((double) (percentage * 100.0F)));
}
}
public FtpResult saveFile(String url, String fileName, String fileTypeDir) {
try {
log.info(Color.GREEN + "[JOB] saveFile STREAM url: {}" + Color.END, url);
@ -1751,117 +1090,6 @@ public class JobMainTask {
}
}
public static InputStream doGetRequestForInputStream(String urlStr) {
String DEFAULT_CHARSET = "utf-8";
int DEFAULT_TIME_OUT = 1;
InputStream is = null;
Object os = null;
try {
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestProperty("Content-Type", "plain/text;charset=" + DEFAULT_CHARSET);
conn.setRequestProperty("charset", DEFAULT_CHARSET);
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setRequestMethod("GET");
conn.connect();
is = conn.getInputStream();
} catch (IOException e) {
e.printStackTrace();
}
return is;
}
public static byte[] doGetRequestForFile(String urlStr) {
String DEFAULT_CHARSET = "utf-8";
int DEFAULT_TIME_OUT = 5000;
InputStream is = null;
ByteArrayOutputStream os = null;
byte[] buff = new byte[1024];
try {
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestProperty("Content-Type", "plain/text;charset=" + DEFAULT_CHARSET);
conn.setRequestProperty("charset", DEFAULT_CHARSET);
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setRequestMethod("GET");
conn.setReadTimeout(DEFAULT_TIME_OUT);
conn.connect();
is = conn.getInputStream();
os = new ByteArrayOutputStream();
int len;
while ((len = is.read(buff)) != -1) {
os.write(buff, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return os.toByteArray();
}
public static void byteArrayToFile(byte[] src, String filePath) {
File dest = new File(filePath);
ByteArrayInputStream is = new ByteArrayInputStream(src);
FileOutputStream os = null;
try {
os = new FileOutputStream(dest);
byte[] flush = new byte[5];
boolean var6 = true;
int len;
while ((len = is.read(flush)) != -1) {
os.write(flush, 0, len);
}
os.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (os != null) {
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String percentage(int current, int all) {
NumberFormat nt = NumberFormat.getPercentInstance();
nt.setMinimumFractionDigits(0);
float percentage = (float) (current + 1) / (float) all;
System.out.println(nt.format((double) percentage));
return nt.format((double) percentage);
}
private String decimalFormatNum(int current, int all) {
DecimalFormat nf = new DecimalFormat("#");
nf.setMaximumIntegerDigits(3);
@ -1872,94 +1100,6 @@ public class JobMainTask {
return nf.format(decimalFormatNum * 100.0F);
}
@SuppressWarnings({"unused"})
public void execEveryDayTask() {
if (isTaskSlotEmpty()) {
Collection<String> redisKeys = redisService.keys(RedisConst.TASK_CODE_EX);
for (String redisKey : redisKeys) {
String[] keywords = StringUtils.split(redisKey, StringUtils.AT);
if (keywords.length == 3) {
String taskCode = keywords[1];
String fixedStartTime = keywords[2];
long currentDays = TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
long fixedDays = TimeUnit.MILLISECONDS.toDays(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, fixedStartTime).getTime());
long currentMinutes = TimeUnit.MILLISECONDS.toMinutes(System.currentTimeMillis());
long fixedStartMinutes = TimeUnit.MILLISECONDS.toMinutes(DateUtils.parse(DateUtils.yyyyMMddHHmmss2, fixedStartTime).getTime());
if (currentDays == fixedDays && currentMinutes >= fixedStartMinutes) {
//if ("1220".equals(taskCode))
{
//log.info("[GABRIEL] key: {}, curMin: {}, fixedMin:{}\n , curDay: {}, fixedDay:{}!", key, currentMinutes, fixedStartMinutes, currentDays, fixedDays);
extractRedisTask(redisKey);
}
}
}
}
} else {
// log.info(Color.YELLOW + "[JOB] CUR: [{}] IS TAKEN, REPEAT: {}, redisRecCnt: {}" + Color.END,
// redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE),
// redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE),
// redisService.getCacheObject(RedisConst.TASK_RECORD_CNT));
}
}
private boolean isTaskSlotEmpty() {
String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE); //repeat空了就不执行
Integer redisRecCnt = redisService.getCacheObject(RedisConst.TASK_RECORD_CNT);
log.info(Color.YELLOW + "[JOB] TASK_CURRENT_CODE@: [{}] TAKEN, TASK_REPEAT_CODE@: {}, TASK_RECORD_CNT: {}" + Color.END, taskCurrentCode, taskRepeatCode, redisRecCnt);
return StringUtils.isEmpty(taskCurrentCode) ||
!StringUtils.isEmpty(taskCurrentCode) && !StringUtils.isEmpty(taskRepeatCode) && (redisRecCnt == null || redisRecCnt == 0);
}
private boolean isTaskRunning() {
final String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
return StringUtils.isNotEmpty(taskCurrentCode);
}
private boolean isTaskRepeatPending() {
final String taskCurrentCode = redisService.getCacheObject(RedisConst.TASK_CURRENT_CODE);
final String taskRepeatCode = redisService.getCacheObject(RedisConst.TASK_REPEAT_CODE);
return StringUtils.isNotEmpty(taskCurrentCode)
&& StringUtils.isNotEmpty(taskRepeatCode)
&& taskCurrentCode.equals(taskRepeatCode);
}
private void clearRepeatTask() {
redisService.deleteObject(RedisConst.TASK_REPEAT_CODE);
}
synchronized private void extractRedisTask(String redisKey) {
if (!isTaskRunning()) {/*执行新任务*/
List<PatrolTask> patrolTaskList = JSON.parseArray(redisService.getCacheObject(redisKey), PatrolTask.class);
if (patrolTaskList != null && !patrolTaskList.isEmpty()) {
log.info(Color.GREEN + "[JOB] ADD NEW TASK [{}], TASK LIST SIZE: {}" + Color.END, redisKey, patrolTaskList.size());
redisService.setCacheObject(RedisConst.TASK_CURRENT_CODE, redisKey);
taskStartInitialize();
execEveryDayTask(patrolTaskList);
}
}
if (isTaskRunning() && isTaskRepeatPending()) {/*执行需要再次执行的任务*/
clearRepeatTask();
log.info(Color.GREEN + "[JOB] REPEAT TASK [{}]" + Color.END, redisKey);
List<PatrolTask> patrolTaskList = JSON.parseArray(redisService.getCacheObject(redisKey), PatrolTask.class);
if (patrolTaskList != null && !patrolTaskList.isEmpty()) {
taskStartInitialize();
execRepeatDayTask(patrolTaskList);
}
}
}
@SuppressWarnings({"unused"})
public void makeEveryDayTask() {
try {
taskExecClient.makeCurrentDayTask();
} catch (Exception e) {
log.info("[JOB] makeCurrentDayTask: {}", e.getMessage());
}
}
private boolean isRunningState(final String patrolId) {
PatrolTaskExecRecord record = taskExecClient.selectPatrolTaskExecRecordByTaskPatrolId(patrolId);
log.debug("[JOB] STATE: {}", record);


Write Preview
Loading…
Cancel
Save