新增 虚拟机工具类,exe执行代码

segment2.0
linrf 2 years ago
parent 90d5743c35
commit 8800a7e07a

@ -1,30 +0,0 @@
package com.docus.server.common;
import com.docus.infrastructure.redis.listener.RedisKeyExpirationListener;
import com.docus.server.service.impl.RedisKeyExpirationService;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
public class RedisCollectorTaskKeyExpirationListener extends RedisKeyExpirationListener {
@Resource
private RedisKeyExpirationService redisKeyExpirationService;
public RedisCollectorTaskKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
super(listenerContainer);
}
@Override
protected void processExpireKey(String expireKey) {
redisKeyExpirationService.expired(expireKey);
}
@Override
protected boolean validExpireKey(String expireKey) {
return expireKey.startsWith("schCollectorRecord:noRetryTask:expireKey:")
|| expireKey.startsWith("schCollectorRecord:isRetryTask:expireKey:");
}
}

@ -1,439 +0,0 @@
package com.docus.server.common;
import com.docus.core.util.DateUtil;
import com.docus.core.util.Func;
import com.docus.core.util.json.JSON;
import com.docus.infrastructure.redis.service.RedisOps;
import com.docus.server.api.taskdistribute.TaskDistributeApi;
import com.docus.server.common.netty.CommMsg;
import com.docus.server.common.netty.server.ChannelRepository;
import com.docus.server.dto.scheduling.management.schcollector.task.ReportDownTwoDTO;
import com.docus.server.dto.scheduling.management.schcollector.task.ReportTaskTwoDTO;
import com.docus.server.dto.scheduling.management.schcollector.task.SchCollectorTaskDTO;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import com.docus.server.entity.scheduling.management.SchCollector;
import com.docus.server.enums.BusyStateEnum;
import com.docus.server.enums.RetryTaskEnum;
import com.docus.server.service.ISchCollectRecordRetryLogService;
import com.docus.server.service.ISchCollectRecordService;
import com.docus.server.service.ISchCollectorService;
import com.docus.server.service.ISchTerminatorService;
import com.google.common.collect.Lists;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.util.CharsetUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
@Component
@Slf4j
public class SchCollectorTask {
@Resource
private ChannelRepository channelRepository;
@Resource
private TaskDistributeApi taskDistributeApi;
@Resource
private ISchCollectRecordService iSchCollectRecordService;
@Resource
private ISchCollectRecordRetryLogService iSchCollectRecordRetryLogService;
@Resource
private ISchTerminatorService iSchTerminatorService;
@Resource
private ISchCollectorService iSchCollectorService;
@Resource
private RedisOps redisOps;
private BlockingQueue<ReportDownTwoDTO> retryTaskQueue = new LinkedBlockingQueue<>();
//定时任务
// 5 * * * * ? 在每分钟的5秒执行
@Scheduled(cron = "0/1 * * * * ?")
public void runTask() {
try {
log.info("定时任务: 开始执行");
//在线并且空闲的终端
List<NettyTerminatorDTO> terminalList = channelRepository.getAvailTerminator();
//没有可用的通道
if (Func.isEmpty(terminalList)) {
return;
}
//:todo 任务平台需要修改发布任务策略
List<ReportDownTwoDTO> reportDownTwoDTOList = getTask(terminalList.size());
if (Func.isEmpty(reportDownTwoDTOList) || Func.isBlank(reportDownTwoDTOList.get(0).getPatientId())) {
return;
}
//只采集,有优先级的
for (NettyTerminatorDTO terminal : terminalList) {
for (ReportDownTwoDTO report : reportDownTwoDTOList) {
//先找出有只采集的任务。
ReportTaskTwoDTO reportTaskTwoDto = report.getTasks().get(0);
if (!CollectionUtils.isEmpty(terminal.getOnlyCollectorIds()) && terminal.getOnlyCollectorIds().contains(reportTaskTwoDto.getCollectorId())
&& BusyStateEnum.IDLE.equals(terminal.getBusyState())) {
//把这个任务派给这个终端,并且把这个终端设置成繁忙
if (!CollectionUtils.isEmpty(terminal.getPriorityCollectorIds()) && terminal.getPriorityCollectorIds().contains(reportTaskTwoDto.getCollectorId())) {
//把这个任务派给这个终端
terminal.setBusyState(BusyStateEnum.BUSY);
iSchTerminatorService.saveOrUpdate(terminal.getTerminatorIp(), terminal);
tcpToClient(terminal, report);
}
return;
}
}
}
//只采集没有优先级
for (NettyTerminatorDTO terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (BusyStateEnum.BUSY.equals(terminal.getBusyState())) {
continue;
}
for (ReportDownTwoDTO report : reportDownTwoDTOList) {
//先找出有只采集的任务。
ReportTaskTwoDTO reportTaskTwoDto = report.getTasks().get(0);
if (!CollectionUtils.isEmpty(terminal.getOnlyCollectorIds()) && terminal.getOnlyCollectorIds().contains(reportTaskTwoDto.getCollectorId())
&& BusyStateEnum.IDLE.equals(terminal.getBusyState())) {
//把这个任务派给这个终端,并且把这个终端设置成繁忙
terminal.setBusyState(BusyStateEnum.BUSY);
iSchTerminatorService.saveOrUpdate(terminal.getTerminatorIp(), terminal);
tcpToClient(terminal, report);
return;
}
}
}
//无只采集,有优先级
for (NettyTerminatorDTO terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (BusyStateEnum.BUSY.equals(terminal.getBusyState())) {
continue;
}
for (ReportDownTwoDTO report : reportDownTwoDTOList) {
//先找出有只采集的任务。
ReportTaskTwoDTO reportTaskTwoDto = report.getTasks().get(0);
if (!CollectionUtils.isEmpty(terminal.getPriorityCollectorIds()) && terminal.getPriorityCollectorIds().contains(reportTaskTwoDto.getCollectorId())
&& BusyStateEnum.IDLE.equals(terminal.getBusyState())) {
//把这个任务派给这个终端
terminal.setBusyState(BusyStateEnum.BUSY);
iSchTerminatorService.saveOrUpdate(terminal.getTerminatorIp(), terminal);
tcpToClient(terminal, report);
return;
}
}
}
//无只采集,无优先级
for (NettyTerminatorDTO terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (BusyStateEnum.BUSY.equals(terminal.getBusyState())) {
continue;
}
for (ReportDownTwoDTO report : reportDownTwoDTOList) {
//先找出有只采集的任务。
//把这个任务派给这个终端
ReportTaskTwoDTO reportTaskTwoDto = report.getTasks().get(0);
terminal.setBusyState(BusyStateEnum.BUSY);
iSchTerminatorService.saveOrUpdate(terminal.getTerminatorIp(), terminal);
tcpToClient(terminal, report);
return;
}
}
//只采集,空闲的。
//获取只采集的任务,并且进行分配。
for (NettyTerminatorDTO terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (BusyStateEnum.BUSY.equals(terminal.getBusyState())) {
continue;
}
List<ReportDownTwoDTO> onlyTaskInfos = getOnlyTaskInfos(terminal.getOnlyCollectorIds());
if (CollectionUtils.isEmpty(onlyTaskInfos) || Func.isBlank(onlyTaskInfos.get(0).getPatientId())) {
return;
}
for (ReportDownTwoDTO report : onlyTaskInfos) {
//将这条任务分配这个这个终端
//下发
terminal.setBusyState(BusyStateEnum.BUSY);
iSchTerminatorService.saveOrUpdate(terminal.getTerminatorIp(), terminal);
tcpToClient(terminal, report);
return;
}
}
log.info("定时任务: 执行完毕");
} catch (
Exception e) {
log.error("定时任务执行出错", e);
}
}
private void tcpToClient(NettyTerminatorDTO terminal, ReportDownTwoDTO reportDownTwoDTO) {
Channel channel = channelRepository.get(terminal.getTerminatorIp());
Map<String, Object> params = reportDownTwoDTO.getParams();
SchCollectorTaskDTO messageContent = new SchCollectorTaskDTO();
if (CollectionUtils.isEmpty(params)) {
//不是重试任务
SchCollectRecord schCollectRecord = iSchCollectRecordService.saveOrUpdateRecord(terminal, reportDownTwoDTO);
messageContent.setCollectorRecordId(schCollectRecord.getId());
messageContent.setIsRetry(String.valueOf(RetryTaskEnum.NO_RETRY_TASK.getValue()));
messageContent.setTaskInfo(reportDownTwoDTO);
} else {
//重试任务
SchCollectRecordRetryLog schCollectRecordRetryLog = iSchCollectRecordRetryLogService.saveOrUpdateRecordRetryLog(terminal, reportDownTwoDTO);
messageContent.setCollectorRecordId(schCollectRecordRetryLog.getId());
messageContent.setIsRetry(String.valueOf(RetryTaskEnum.RETRY_TASK.getValue()));
messageContent.setTaskInfo(reportDownTwoDTO);
}
CommMsg commMsg = CommMsg.builder()
.messageType(MsgConstants.SCH_DISTRIBUTE_TASKS)
.messageTime(DateUtil.formatDateTime(new Date()))
.content(JSON.toJSON(messageContent))
.build();
//tcp 下发任务到终端
if (channel != null) {
channel.writeAndFlush(Unpooled.copiedBuffer(JSON.toJSON(commMsg), CharsetUtil.UTF_8));
}
String isRetry = messageContent.getIsRetry();
Long collectorRecordId = messageContent.getCollectorRecordId();
String collectorId = messageContent.getTaskInfo().getTasks().get(0).getCollectorId();
SchCollector schCollector = iSchCollectorService.findByCollectorId(collectorId);
if (RetryTaskEnum.NO_RETRY_TASK.equals(isRetry)) {
redisOps.setEx(String.format("schCollectorRecord:noRetryTask:expireKey:%s", collectorRecordId), String.valueOf(collectorRecordId), schCollector.getTaskTimeout());
} else {
redisOps.setEx(String.format("schCollectorRecord:isRetryTask:expireKey:%s", collectorRecordId), String.valueOf(collectorRecordId), schCollector.getTaskTimeout());
}
}
public void addRetryTask(ReportDownTwoDTO reportDownTwoDTO) {
this.retryTaskQueue.add(reportDownTwoDTO);
}
//根据有效终端一次获取一批任务例如10个终端获取10个不同类型任务
public List<ReportDownTwoDTO> getTask(int size) throws InterruptedException {
// return taskDistributeApi.getTask(String.valueOf(size));
//mock
String collectorId1 = "{\n" +
" \"createTime\": \"2022-12-03 12:39:30\",\n" +
" \"hospitals\": [\n" +
" {\n" +
" \"admissDate\": \"2023-12-31 01:01:01\",\n" +
" \"admissId\": \"amid_999901\",\n" +
" \"admissTimes\": 1,\n" +
" \"disDate\": \"2023-12-31 01:01:01\",\n" +
" \"disDeptName\": \"22222\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" }\n" +
" ],\n" +
" \"jzh\": \"jzh_999901\",\n" +
" \"patient\": {\n" +
" \"inpatientNo\": \"999901\",\n" +
" \"name\": \"ceshi\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" },\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"recordType\": \"1\",\n" +
" \"tasks\": [\n" +
" {\n" +
" \"collectorId\": \"1\",\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"taskId\": 834292710565826560\n" +
" }\n" +
" ]\n" +
"}";
ReportDownTwoDTO reportDownTwoDTO1 = JSON.fromJSON(collectorId1, ReportDownTwoDTO.class);
String collectorId2 = "{\n" +
" \"createTime\": \"2022-12-03 12:39:30\",\n" +
" \"hospitals\": [\n" +
" {\n" +
" \"admissDate\": \"2023-12-31 01:01:01\",\n" +
" \"admissId\": \"amid_999901\",\n" +
" \"admissTimes\": 1,\n" +
" \"disDate\": \"2023-12-31 01:01:01\",\n" +
" \"disDeptName\": \"22222\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" }\n" +
" ],\n" +
" \"jzh\": \"jzh_999901\",\n" +
" \"patient\": {\n" +
" \"inpatientNo\": \"999901\",\n" +
" \"name\": \"ceshi\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" },\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"recordType\": \"1\",\n" +
" \"tasks\": [\n" +
" {\n" +
" \"collectorId\": \"2\",\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"taskId\": 834292712465846272\n" +
" }\n" +
" ]\n" +
"}";
ReportDownTwoDTO reportDownTwoDTO2 = JSON.fromJSON(collectorId2, ReportDownTwoDTO.class);
String collectorId3 = "{\n" +
" \"createTime\": \"2023-01-09 19:26:11\",\n" +
" \"hospitals\": [\n" +
" {\n" +
" \"admissDate\": \"2023-12-31 01:01:01\",\n" +
" \"admissId\": \"amid_297974\",\n" +
" \"admissTimes\": 21,\n" +
" \"disDate\": \"2023-12-31 01:01:01\",\n" +
" \"disDeptName\": \"普外二科(甲乳胸烧伤整形)\",\n" +
" \"patientId\": \"772389719349678080\"\n" +
" }\n" +
" ],\n" +
" \"jzh\": \"jzh_297974\",\n" +
" \"patient\": {\n" +
" \"inpatientNo\": \"297974\",\n" +
" \"name\": \"曾美英\",\n" +
" \"patientId\": \"772389719349678080\"\n" +
" },\n" +
" \"patientId\": \"772389719349678080\",\n" +
" \"recordType\": \"1\",\n" +
" \"tasks\": [\n" +
" {\n" +
" \"collectorId\": \"3\",\n" +
" \"patientId\": \"772389719349678080\",\n" +
" \"taskId\": 838201379426750464\n" +
" }\n" +
" ]\n" +
"}";
ReportDownTwoDTO reportDownTwoDTO3 = JSON.fromJSON(collectorId3, ReportDownTwoDTO.class);
// List<ReportDownTwoDTO> allTaskList = Lists.newArrayList(reportDownTwoDTO1, reportDownTwoDTO2, reportDownTwoDTO3);
List<ReportDownTwoDTO> allTaskList = new ArrayList<>();
if (!CollectionUtils.isEmpty(this.retryTaskQueue)) {
ReportDownTwoDTO retryTask = (ReportDownTwoDTO) this.retryTaskQueue.take();
//重试任务
allTaskList.add(retryTask);
}
return allTaskList;
}
//根据采集器id类型一次获取一批采集器类型任务
private List<ReportDownTwoDTO> getOnlyTaskInfos(List<String> collectorIds) {
// return taskDistributeApi.getTask(collectorIds.get(0));
//mock
String collectorId2 = "{\n" +
" \"createTime\": \"2022-12-03 12:39:30\",\n" +
" \"hospitals\": [\n" +
" {\n" +
" \"admissDate\": \"2023-12-31 01:01:01\",\n" +
" \"admissId\": \"amid_999901\",\n" +
" \"admissTimes\": 1,\n" +
" \"disDate\": \"2023-12-31 01:01:01\",\n" +
" \"disDeptName\": \"22222\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" }\n" +
" ],\n" +
" \"jzh\": \"jzh_999901\",\n" +
" \"patient\": {\n" +
" \"inpatientNo\": \"999901\",\n" +
" \"name\": \"ceshi\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" },\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"recordType\": \"1\",\n" +
" \"tasks\": [\n" +
" {\n" +
" \"collectorId\": \"2\",\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"taskId\": 834292712465846272\n" +
" }\n" +
" ]\n" +
"}";
ReportDownTwoDTO reportDownTwoDTO2 = JSON.fromJSON(collectorId2, ReportDownTwoDTO.class);
String collectorId3 = "{\n" +
" \"createTime\": \"2022-12-03 12:39:30\",\n" +
" \"hospitals\": [\n" +
" {\n" +
" \"admissDate\": \"2023-12-31 01:01:01\",\n" +
" \"admissId\": \"amid_999901\",\n" +
" \"admissTimes\": 1,\n" +
" \"disDate\": \"2023-12-31 01:01:01\",\n" +
" \"disDeptName\": \"22222\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" }\n" +
" ],\n" +
" \"jzh\": \"jzh_999901\",\n" +
" \"patient\": {\n" +
" \"inpatientNo\": \"999901\",\n" +
" \"name\": \"ceshi\",\n" +
" \"patientId\": \"758878610105573376\"\n" +
" },\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"recordType\": \"1\",\n" +
" \"tasks\": [\n" +
" {\n" +
" \"collectorId\": \"3\",\n" +
" \"patientId\": \"758878610105573376\",\n" +
" \"taskId\": 834292883635392512\n" +
" }\n" +
" ]\n" +
"}";
ReportDownTwoDTO reportDownTwoDTO3 = JSON.fromJSON(collectorId3, ReportDownTwoDTO.class);
return Lists.newArrayList(reportDownTwoDTO2, reportDownTwoDTO3);
}
}

@ -1,31 +0,0 @@
package com.docus.server.common;
import com.docus.server.entity.scheduling.management.SchTerminator;
import com.docus.server.enums.BusyStateEnum;
import com.docus.server.enums.OnlineStateEnum;
import com.docus.server.service.ISchTerminatorService;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.List;
/**
*
*/
@Component
public class TerminatorListener implements ApplicationListener<ContextRefreshedEvent> {
@Resource
private ISchTerminatorService iSchTerminatorService;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
List<SchTerminator> terminators = iSchTerminatorService.findAll();
terminators.forEach(p -> {
p.setBusyState(BusyStateEnum.IDLE);
p.setOnlineState(OnlineStateEnum.OFFLINE);
});
iSchTerminatorService.batchUpdate(terminators);
}
}

@ -0,0 +1,51 @@
package com.docus.server.common.netty;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
public class ChannelAttribute<T> {
/**
*
*/
private AttributeKey<T> attributeKey;
public ChannelAttribute(String key) {
this.attributeKey = AttributeKey.valueOf(key);
}
/**
*
*
* @param ctx
* @param value
*/
public void setAttribute(ChannelHandlerContext ctx, T value) {
Attribute<T> attribute = getAttribute(ctx);
attribute.set(value);
}
/**
*
*
* @param ctx
* @return null
*/
public T getAttributeValue(ChannelHandlerContext ctx) {
Attribute<T> attribute = getAttribute(ctx);
T value = attribute.get();
return value;
}
/**
* null
*
* @param ctx channel
* @return ctx channle attribute
*/
private Attribute<T> getAttribute(ChannelHandlerContext ctx) {
return ctx.channel().attr(attributeKey);
}
}

@ -1,22 +1,12 @@
package com.docus.server.common.netty.server;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.enums.BusyStateEnum;
import com.docus.server.enums.OnlineStateEnum;
import com.docus.server.service.ISchTerminatorService;
import com.docus.server.vo.scheduling.management.schterminator.SchTerminatorVO;
import io.netty.channel.Channel;
import io.netty.util.AttributeKey;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* IP
@ -24,37 +14,22 @@ import java.util.stream.Collectors;
@Component
@Slf4j
public class ChannelRepository {
@Resource
private ISchTerminatorService iSchTerminatorService;
/**
* <IP-Channel>
* <collectorId-Channel>
*/
private final static Map<String, Channel> IP_CHANNEL_CACHE_MAP = new ConcurrentHashMap<>();
/**
* <IP-Terminator>
*/
private final static Map<String, NettyTerminatorDTO> IP_TERMINATOR_CACHE_MAP = new ConcurrentHashMap<>();
private final static Map<String, Channel> COLLECTOR_ID_CHANNEL_CACHE_MAP = new ConcurrentHashMap<>();
/**
* 线
*/
public void put(NettyTerminatorDTO nettyTerminatorDTO, Channel channel) {
//客户端上线
String terminatorIp = nettyTerminatorDTO.getTerminatorIp();
//更新数据库终端数据
SchTerminatorVO schTerminatorVO = iSchTerminatorService.saveOrUpdate(terminatorIp, nettyTerminatorDTO);
nettyTerminatorDTO.setId(schTerminatorVO.getId());
public void put(String collectorId, Channel channel) {
//缓存
IP_CHANNEL_CACHE_MAP.put(terminatorIp, channel);
IP_TERMINATOR_CACHE_MAP.put(terminatorIp, nettyTerminatorDTO);
COLLECTOR_ID_CHANNEL_CACHE_MAP.put(collectorId, channel);
AttributeKey<String> attributeKey = AttributeKey.valueOf("ip");
channel.attr(attributeKey).set(terminatorIp);
channel.attr(attributeKey).set(collectorId);
}
@ -69,38 +44,14 @@ public class ChannelRepository {
}
public Channel get(String key) {
return IP_CHANNEL_CACHE_MAP.get(key);
}
public NettyTerminatorDTO getTerminatorByIp(String key) {
return IP_TERMINATOR_CACHE_MAP.get(key);
}
public Map<String, Channel> getIpToChannelCacheMap() {
return IP_CHANNEL_CACHE_MAP;
}
public Map<String, NettyTerminatorDTO> getIpToTerminatorCacheMap() {
return IP_TERMINATOR_CACHE_MAP;
}
public List<NettyTerminatorDTO> getAvailTerminator() {
if (!CollectionUtils.isEmpty(IP_TERMINATOR_CACHE_MAP)) {
return IP_TERMINATOR_CACHE_MAP.values().stream().filter(p -> OnlineStateEnum.ONLINE.equals(p.getOnlineState())
&& BusyStateEnum.IDLE.equals(p.getBusyState())).collect(Collectors.toList());
}
return Collections.emptyList();
return COLLECTOR_ID_CHANNEL_CACHE_MAP.get(key);
}
/**
* 线
*/
public void remove(String key) {
IP_CHANNEL_CACHE_MAP.remove(key);
NettyTerminatorDTO nettyTerminatorDTO = new NettyTerminatorDTO();
nettyTerminatorDTO.setOnlineState(OnlineStateEnum.OFFLINE);
iSchTerminatorService.saveOrUpdate(key, nettyTerminatorDTO);
COLLECTOR_ID_CHANNEL_CACHE_MAP.remove(key);
}
}

@ -1,7 +1,6 @@
package com.docus.server.common.netty.server;
import com.docus.server.common.netty.server.handler.NettyBusinessHandler;
import com.docus.server.common.netty.server.handler.NettyHeartbeatHandler;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.handler.timeout.IdleStateHandler;
@ -45,7 +44,7 @@ public class NettyServerInitializer extends ChannelInitializer<Channel> {
// .addLast(new StringEncoder())
// 加载业务处理器
.addLast(new NettyHeartbeatHandler(channelRepository))
// .addLast(new NettyHeartbeatHandler(channelRepository))
.addLast(businessHandler);
// .addLast(new EchoServerHandler());
}

@ -1,28 +1,32 @@
package com.docus.server.common.netty.server.handler;
import com.docus.core.util.DateUtil;
import com.docus.core.util.Func;
import com.docus.core.util.StringUtils;
import com.docus.core.util.json.JSON;
import com.docus.server.common.MsgConstants;
import com.docus.server.common.netty.ChannelAttribute;
import com.docus.server.common.netty.CommMsg;
import com.docus.server.common.netty.server.ChannelRepository;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.enums.BusyStateEnum;
import com.docus.server.enums.OnlineStateEnum;
import com.fasterxml.jackson.core.type.TypeReference;
import com.docus.server.common.netty.state.DeviceStateContext;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.CharsetUtil;
import io.netty.util.concurrent.GlobalEventExecutor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.io.Serializable;
import java.net.InetSocketAddress;
import java.util.Date;
/**
*
@ -34,11 +38,15 @@ public class NettyBusinessHandler extends SimpleChannelInboundHandler<ByteBuf> {
private static final ChannelGroup DEFAULT_CHANNEL_GROUP = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
public static final ChannelAttribute<DeviceStateContext> session = new ChannelAttribute<>("state");
@Resource
private ChannelRepository repository;
@Override
protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf msg) throws Exception {
protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
DeviceStateContext deviceStateContext = session.getAttributeValue(ctx);
ByteBuf buf = (ByteBuf) msg;
//创建目标大小的数组
byte[] barray = new byte[buf.readableBytes()];
@ -52,35 +60,91 @@ public class NettyBusinessHandler extends SimpleChannelInboundHandler<ByteBuf> {
return;
}
CommMsg<TerminatorContent> commMsg = JSON.fromJSONWithGeneric(message, new TypeReference<CommMsg<TerminatorContent>>() {
});
CommMsg commMsg = JSON.fromJSON(message, CommMsg.class);
String messageType = commMsg.getMessageType();
String messageTime = commMsg.getMessageTime();
TerminatorContent messageContent = commMsg.getContent();
Serializable messageContent = commMsg.getContent();
if (messageType.equals(MsgConstants.ONLINE_REGISTER)) {
//===========login ok,切换到已登录状态===============
deviceStateContext.onLoginSucc("device-123", System.currentTimeMillis(), 10, "设备认证通过");
CommMsg<Serializable> login_ok = CommMsg.builder()
.messageTime(DateUtil.formatDateTime(new Date()))
.content("login ok")
.messageType("response")
.build();
ctx.writeAndFlush(Unpooled.copiedBuffer(JSON.toJSON(login_ok), CharsetUtil.UTF_8));
} else if (messageType.equals(MsgConstants.HEARTBEAT_REQUEST)) {
//============状态为上行数据=============
deviceStateContext.onHeartbeat(System.currentTimeMillis(), "设备上行了数据");
//==============处理数据================
System.out.println("收到数据:" + msg);
//============返回消息==================
CommMsg<Serializable> resp = CommMsg.builder()
.messageTime(DateUtil.formatDateTime(new Date()))
.content("HEARTBEAT_REQUEST ok")
.messageType("response HEARTBEAT_REQUEST")
.build();
ctx.writeAndFlush(Unpooled.copiedBuffer(JSON.toJSON(resp), CharsetUtil.UTF_8));
log.info("接受到【终端-采集器】客户端的心跳消息:消息类型={},消息时间={},消息内容={}", messageType, messageTime, messageContent);
InetSocketAddress ipSocket = (InetSocketAddress) ctx.channel().remoteAddress();
String clientIp = ipSocket.getAddress().getHostAddress();
if (messageType.equals(MsgConstants.TERMINATOR_RESTART)) {
log.info("【终端-采集器IP】:{},连接上线,IP地址信息:{}", clientIp, clientIp);
} else if (messageType.equals(MsgConstants.TERMINATOR_RESTART)) {
log.info("接受到终端重启命令,内容{}", messageContent);
}
if (messageType.equals(MsgConstants.COLLECTOR_RESTART)) {
} else if (messageType.equals(MsgConstants.COLLECTOR_RESTART)) {
log.info("收到采集器重启命令,内容{}", messageContent);
}
if (messageType.equals(MsgConstants.VIRTUAL_RESTART)) {
} else if (messageType.equals(MsgConstants.VIRTUAL_RESTART)) {
log.info("收到虚拟机重启命令,内容{}", messageContent);
}
if (messageType.equals(MsgConstants.UPDATE_COLLECTOR_FILE)) {
} else if (messageType.equals(MsgConstants.UPDATE_COLLECTOR_FILE)) {
log.info("收到更新采集器文件命令,内容{}", messageContent);
}
if (messageType.equals(MsgConstants.UPDATE_COLLECTOR_CONFIG)) {
} else if (messageType.equals(MsgConstants.UPDATE_COLLECTOR_CONFIG)) {
log.info("收到更新采集器配置命令,内容{}", messageContent);
}
if (messageType.equals(MsgConstants.SCH_DISTRIBUTE_TASKS)) {
} else if (messageType.equals(MsgConstants.SCH_DISTRIBUTE_TASKS)) {
log.info("收到采集调度器下发任务命令,内容{}", messageContent);
}
System.out.println("channelRead0:" + deviceStateContext.toString());
}
/**
* (-) onTimeout
*/
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
System.out.println(getClass().getSimpleName() + "." + "userEventTriggered" + ctx.channel().remoteAddress());
if (evt instanceof IdleStateEvent) {
DeviceStateContext deviceStateContext = session.getAttributeValue(ctx);
long lastUpdateTime = deviceStateContext.getLastUpdateTime();
long currentTimeMillis = System.currentTimeMillis();
long intervalTime = currentTimeMillis - lastUpdateTime;
if (intervalTime > deviceStateContext.getHeartRate()) {
//==============发生超时,进入超时状态==============
deviceStateContext.onTimeout("设备发生超时");
System.out.println("userEventTriggered:" + deviceStateContext.toString());
}
} else {
//不是超时事件,进行传递
super.userEventTriggered(ctx, evt);
}
}
@ -91,20 +155,22 @@ public class NettyBusinessHandler extends SimpleChannelInboundHandler<ByteBuf> {
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelRegistered();
//链接成功
DeviceStateContext deviceStateContext = new DeviceStateContext(ctx.channel(), true);
//===========设置设备状态为 未登录=================
deviceStateContext.onConnect(System.currentTimeMillis(), "设备 active");
//更新添加 state 属性
session.setAttribute(ctx, deviceStateContext);
System.out.println("channelActive:" + deviceStateContext.toString());
//===========设置设备状态为 未登录=================
InetSocketAddress ipSocket = (InetSocketAddress) ctx.channel().remoteAddress();
String clientIp = ipSocket.getAddress().getHostAddress();
log.info("【采集器-终端IP】:{},连接上线,IP地址信息:{}", clientIp, clientIp);
String clientId = repository.getClientKey(ctx.channel());
if (Func.isBlank(clientId)) {
log.info("【终端-采集器IP】:{},连接上线,IP地址信息:{}", clientIp, clientIp);
NettyTerminatorDTO nettyTerminatorDTO = new NettyTerminatorDTO();
nettyTerminatorDTO.setTerminatorIp(clientIp);
nettyTerminatorDTO.setBusyState(BusyStateEnum.IDLE);
nettyTerminatorDTO.setOnlineState(OnlineStateEnum.OFFLINE);
if (Func.isNotBlank(clientIp)) {
repository.put(nettyTerminatorDTO, ctx.channel());
repository.put(clientIp, ctx.channel());
}
DEFAULT_CHANNEL_GROUP.add(ctx.channel());
@ -125,6 +191,11 @@ public class NettyBusinessHandler extends SimpleChannelInboundHandler<ByteBuf> {
if (clientId != null) {
repository.remove(clientId);
}
//================设置为断开================
DeviceStateContext deviceStateContext = session.getAttributeValue(ctx);
deviceStateContext.onDisconnect("设备 inactive");
System.out.println("channelInactive:" + deviceStateContext.toString());
}
/**
@ -132,12 +203,23 @@ public class NettyBusinessHandler extends SimpleChannelInboundHandler<ByteBuf> {
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
//==============发生异常切换到断开模式===============
System.out.println("exceptionCaught:" + cause.getMessage());
DeviceStateContext deviceStateContext = session.getAttributeValue(ctx);
deviceStateContext.onDisconnect(cause.getMessage());
System.out.println("exceptionCaught:" + deviceStateContext.toString());
cause.printStackTrace();
Channel channel = ctx.channel();
if (channel.isActive()) {
String clientId = repository.getClientKey(ctx.channel());
log.error("通道发生异常,终端连接:{}", clientId);
//移除终端,终端离线
if (clientId != null) {
repository.remove(clientId);
}
if (ctx.channel().isActive()) {
ctx.close();
}
super.exceptionCaught(ctx, cause);
}

@ -1,104 +1,97 @@
package com.docus.server.common.netty.server.handler;
import com.docus.core.util.Func;
import com.docus.core.util.StringUtils;
import com.docus.core.util.json.JSON;
import com.docus.server.common.MsgConstants;
import com.docus.server.common.netty.CommMsg;
import com.docus.server.common.netty.server.ChannelRepository;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.enums.BusyStateEnum;
import com.docus.server.enums.OnlineStateEnum;
import com.fasterxml.jackson.core.type.TypeReference;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;
import java.net.InetSocketAddress;
/**
*
*/
@Slf4j
@ChannelHandler.Sharable
public class NettyHeartbeatHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
//创建目标大小的数组
byte[] barray = new byte[buf.readableBytes()];
//把数据从bytebuf转移到byte[]
buf.getBytes(0, barray);
//将byte[]转成字符串用于打印
String message = new String(barray);
//空消息不处理
if (!StringUtils.hasText(message)) {
return;
}
CommMsg<TerminatorContent> commMsg = JSON.fromJSONWithGeneric(message, new TypeReference<CommMsg<TerminatorContent>>() {
});
String messageType = commMsg.getMessageType();
String messageTime = commMsg.getMessageTime();
TerminatorContent messageContent = commMsg.getContent();
if (messageType.equals(MsgConstants.HEARTBEAT_REQUEST)) {
log.info("接收到客户端的心跳");
log.info("接受到【采集器-终端】的心跳消息:消息类型={},消息时间={},消息内容={}", messageType, messageTime, messageContent);
InetSocketAddress ipSocket = (InetSocketAddress) ctx.channel().remoteAddress();
String clientIp = ipSocket.getAddress().getHostAddress();
log.info("【采集器-终端IP】:{},连接上线,IP地址信息:{}", clientIp, clientIp);
String clientKey = repository.getClientKey(ctx.channel());
if (Func.isNotBlank(clientKey)) {
NettyTerminatorDTO nettyTerminatorDTO = new NettyTerminatorDTO();
nettyTerminatorDTO.setTerminatorIp(clientIp);
nettyTerminatorDTO.setBusyState(BusyStateEnum.IDLE);
nettyTerminatorDTO.setOnlineState(OnlineStateEnum.ONLINE);
//将ip和channel进行映射
repository.put(nettyTerminatorDTO, ctx.channel());
}
} else {
if (ctx.channel().isOpen()) {
//触发下一个handler
ctx.fireChannelRead(msg);
}
}
}
private ChannelRepository repository;
public NettyHeartbeatHandler(ChannelRepository repository) {
this.repository = repository;
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
String clientId = repository.getClientKey(ctx.channel());
log.error("通道发生异常,终端连接:{}", clientId);
//移除终端,终端离线
if (clientId != null) {
repository.remove(clientId);
}
if (ctx.channel().isActive()) {
ctx.close();
}
super.exceptionCaught(ctx, cause);
}
}
//package com.docus.server.common.netty.server.handler;
//
//import com.docus.core.util.Func;
//import com.docus.core.util.StringUtils;
//import com.docus.core.util.json.JSON;
//import com.docus.server.common.MsgConstants;
//import com.docus.server.common.netty.CommMsg;
//import com.docus.server.common.netty.server.ChannelRepository;
//import io.netty.buffer.ByteBuf;
//import io.netty.channel.ChannelHandler;
//import io.netty.channel.ChannelHandlerContext;
//import io.netty.channel.ChannelInboundHandlerAdapter;
//import lombok.extern.slf4j.Slf4j;
//
//import java.io.Serializable;
//import java.net.InetSocketAddress;
//
///**
// * 客户端和服务端心跳
// */
//@Slf4j
//@ChannelHandler.Sharable
//public class NettyHeartbeatHandler extends ChannelInboundHandlerAdapter {
//
// @Override
// public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// ByteBuf buf = (ByteBuf) msg;
// //创建目标大小的数组
// byte[] barray = new byte[buf.readableBytes()];
// //把数据从bytebuf转移到byte[]
// buf.getBytes(0, barray);
// //将byte[]转成字符串用于打印
// String message = new String(barray);
// //空消息不处理
// if (!StringUtils.hasText(message)) {
// return;
// }
//
// CommMsg commMsg = JSON.fromJSON(message, CommMsg.class);
//
// String messageType = commMsg.getMessageType();
// String messageTime = commMsg.getMessageTime();
// Serializable messageContent = commMsg.getContent();
//
// if (messageType.equals(MsgConstants.HEARTBEAT_REQUEST)) {
//
// log.info("接收到客户端的心跳");
//
//
// log.info("接受到【采集器-终端】的心跳消息:消息类型={},消息时间={},消息内容={}", messageType, messageTime, messageContent);
//
// InetSocketAddress ipSocket = (InetSocketAddress) ctx.channel().remoteAddress();
// String clientIp = ipSocket.getAddress().getHostAddress();
//
// log.info("【采集器-终端IP】:{},连接上线,IP地址信息:{}", clientIp, clientIp);
//
// String clientKey = repository.getClientKey(ctx.channel());
//
// if (Func.isNotBlank(clientKey)) {
//
// //将ip和channel进行映射
// repository.put(clientKey, ctx.channel());
// }
//
// } else {
//
// if (ctx.channel().isOpen()) {
// //触发下一个handler
// ctx.fireChannelRead(msg);
// }
// }
//
// }
//
// private ChannelRepository repository;
//
// public NettyHeartbeatHandler(ChannelRepository repository) {
// this.repository = repository;
// }
//
//
//
// @Override
// public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
// cause.printStackTrace();
// String clientId = repository.getClientKey(ctx.channel());
// log.error("通道发生异常,终端连接:{}", clientId);
// //移除终端,终端离线
// if (clientId != null) {
// repository.remove(clientId);
// }
// if (ctx.channel().isActive()) {
// ctx.close();
// }
// super.exceptionCaught(ctx, cause);
// }
//}

@ -0,0 +1,44 @@
package com.docus.server.common.netty.state;
/**
* describe:
*/
public abstract class AbstractState implements IDeviceState {
protected DeviceStateContext stateCtx;
public AbstractState(DeviceStateContext stateCtx) {
this.stateCtx = stateCtx;
}
@Override
public void onConnect(long connectedTime, String describe) {
throw new IllegalStateException(getStateName() + " 此状态不应该进行链接动作");
}
@Override
public void onDisconnect(String describe) {
throw new IllegalStateException(getStateName() + " 此状态不应该进行断开链接动作");
}
@Override
public void onLoginSucc(String deviceId, long lastUpdateTime, long heartRate, String describe) {
throw new IllegalStateException(getStateName() + " 此状态不应该进行登录动作");
}
@Override
public void onLoginFailed(String describe) {
throw new IllegalStateException(getStateName() + " 此状态不应该进行登录失败动作");
}
@Override
public void onHeartbeat(long lastUpdateTime, String describe) {
throw new IllegalStateException(getStateName() + " 此状态不应该进行心跳动作");
}
@Override
public void onTimeout(String describe) {
throw new IllegalStateException(getStateName() + " 此状态不应该进行进入超时动作");
}
}

@ -0,0 +1,239 @@
package com.docus.server.common.netty.state;
import io.netty.channel.Channel;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* describe:
*/
public class DeviceStateContext implements IDeviceState {
/**
*
*/
boolean history;
/**
*
*/
private static class HistoryInfoDTO {
private String describe;
private String state;
public HistoryInfoDTO(String describe, String state) {
this.describe = describe;
this.state = state;
}
@Override
public String toString() {
return "HistoryInfoDTO{" +
"describe='" + describe + '\'' +
", state='" + state + '\'' +
'}';
}
}
List<HistoryInfoDTO> historyState = new ArrayList<>();
/**
*
*/
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
/**
*
*/
private Channel channel;
/**
* deviceId
*/
private String deviceId;
/**
*
*/
private long connectTime;
/**
*
*/
private long lastUpdateTime;
/**
* s
*/
private long heartRate;
/**
*
*/
private IDeviceState state;
/**
* @param channel channel
*/
public DeviceStateContext(Channel channel) {
this.channel = channel;
setState(new NoConnectedState(this), "初始化");
}
/**
* @param channel channel
* @param history true
*/
public DeviceStateContext(Channel channel, boolean history) {
this.history = history;
this.channel = channel;
setState(new NoConnectedState(this), "初始化");
}
///////////////////////////get/set////////////////////////
public Channel getChannel() {
return channel;
}
public void setChannel(Channel channel) {
this.channel = channel;
}
public String getDeviceId() {
return deviceId;
}
public void setDeviceId(String deviceId) {
this.deviceId = deviceId;
}
public long getConnectTime() {
return connectTime;
}
public void setConnectTime(long connectTime) {
this.connectTime = connectTime;
}
public long getLastUpdateTime() {
return lastUpdateTime;
}
public void setLastUpdateTime(long lastUpdateTime) {
this.lastUpdateTime = lastUpdateTime;
}
public long getHeartRate() {
return heartRate;
}
public void setHeartRate(long heartRate) {
this.heartRate = heartRate;
}
public IDeviceState getState() {
return state;
}
public void setState(IDeviceState state, String describe) {
this.state = state;
//把每次切换的状态加入到历史状态中
historyState.add(new HistoryInfoDTO(describe, state.getStateName()));
}
///////////////////////////状态切换////////////////////////
@Override
public void onConnect(long connectTime, String describe) {
lock.writeLock().lock();
try {
state.onConnect(connectTime, describe);
} finally {
lock.writeLock().unlock();
}
}
@Override
public void onDisconnect(String describe) {
lock.writeLock().lock();
try {
state.onDisconnect(describe);
} finally {
lock.writeLock().unlock();
}
}
@Override
public void onLoginSucc(String deviceId, long lastUpdateTime, long heartRate, String describe) throws IllegalStateException {
lock.writeLock().lock();
try {
state.onLoginSucc(deviceId, lastUpdateTime, heartRate, describe);
} finally {
lock.writeLock().unlock();
}
}
@Override
public void onLoginFailed(String describe) {
lock.writeLock().lock();
try {
state.onLoginFailed(describe);
} finally {
lock.writeLock().unlock();
}
}
@Override
public void onHeartbeat(long lastUpdateTime, String describe) {
lock.writeLock().lock();
try {
state.onHeartbeat(lastUpdateTime, describe);
} finally {
lock.writeLock().unlock();
}
}
@Override
public void onTimeout(String describe) {
lock.writeLock().lock();
try {
state.onTimeout(describe);
} finally {
lock.writeLock().unlock();
}
}
@Override
public String getStateName() {
return null;
}
/**
*
*/
protected void closeChannle(String describe) {
setState(new NoConnectedState(this), describe);
//关闭此 channel
this.channel.close();
}
@Override
public String toString() {
return "DeviceStateContext{" +
" state=" + state.getStateName() +
", channel=" + channel +
", deviceId='" + deviceId + '\'' +
", connectTime=" + connectTime +
", lastUpdateTime=" + lastUpdateTime +
", lock=" + lock +
", \nhistory=" + historyState +
'}';
}
}

@ -0,0 +1,58 @@
package com.docus.server.common.netty.state;
/**
* describe:
*/
public interface IDeviceState {
/**
*
*
* @param connectedTime
* @param describe
*/
void onConnect(long connectedTime, String describe);
/**
*
*
* @param describe
*/
void onDisconnect(String describe);
/**
*
*
* @param deviceId id
* @param lastUpdateTime
* @param heartRate
* @param describe
*/
void onLoginSucc(String deviceId, long lastUpdateTime, long heartRate, String describe);
/**
*
*
* @param describe
*/
void onLoginFailed(String describe);
/**
*
*
* @param lastUpdateTime
* @param describe
*/
void onHeartbeat(long lastUpdateTime, String describe);
/**
*
*
* @param describe
*/
void onTimeout(String describe);
/**
*
*/
String getStateName();
}

@ -0,0 +1,35 @@
package com.docus.server.common.netty.state;
/**
* describe:
*/
public class LoggedState extends AbstractState {
public LoggedState(DeviceStateContext stateCtx) {
super(stateCtx);
}
@Override
public void onDisconnect(String describe) {
//直接关闭链接
this.stateCtx.closeChannle(describe);
}
@Override
public void onHeartbeat(long lastUpdateTime, String describe) {
//把当前状态放进去
this.stateCtx.setState(this, describe);
//状态不变更新 lastUpdateTime
this.stateCtx.setLastUpdateTime(lastUpdateTime);
}
@Override
public void onTimeout(String describe) {
//状态模式设置为超时状态
this.stateCtx.setState(new TimeoutState(this.stateCtx), describe);
}
@Override
public String getStateName() {
return "logged";
}
}

@ -0,0 +1,26 @@
package com.docus.server.common.netty.state;
/**
* describe:
*/
public class NoConnectedState extends AbstractState {
public NoConnectedState(DeviceStateContext ctx) {
super(ctx);
}
@Override
public void onConnect(long connectedTime, String describe) {
stateCtx.setConnectTime(connectedTime);
stateCtx.setState(new NoLoginState(this.stateCtx), describe);
}
@Override
public void onDisconnect(String describe) {
this.stateCtx.closeChannle(describe);
}
@Override
public String getStateName() {
return "noConnected";
}
}

@ -0,0 +1,42 @@
package com.docus.server.common.netty.state;
/**
* describe:
*/
public class NoLoginState extends AbstractState {
public NoLoginState(DeviceStateContext ctx) {
super(ctx);
}
@Override
public void onDisconnect(String describe) {
this.stateCtx.closeChannle(describe);
}
@Override
public void onLoginSucc(String deviceId, long lastUpdateTime, long heartRate, String describe) {
//设置数据
this.stateCtx.setDeviceId(deviceId);
this.stateCtx.setLastUpdateTime(lastUpdateTime);
this.stateCtx.setHeartRate(heartRate);
//状态转移
this.stateCtx.setState(new LoggedState(this.stateCtx), describe);
}
//
// @Override
// public void onLoginFailed(String describe) {
// //为登录模式下,登录失败,直接断开链接。
// this.stateCtx.closeChannle(describe);
// }
//
// @Override
// public void onTimeout(String describe) {
// //在未登录状态下,超时无数据,直接断开链接
// this.stateCtx.closeChannle(describe);
// }
@Override
public String getStateName() {
return "noLogin";
}
}

@ -0,0 +1,45 @@
package com.docus.server.common.netty.state;
/**
* describe:
*/
public class TimeoutState extends AbstractState {
public static final int MAX_TIMEOUT = 3;
/**
* 3
*/
private int count;
public TimeoutState(DeviceStateContext stateCtx) {
super(stateCtx);
this.count = 1;
}
@Override
public void onTimeout(String describe) {
//把当前状态放进去
this.stateCtx.setState(this, describe);
this.count++;
//连续 timeout 到一定次数就关闭连接,切换到 断开链接状态
if (this.count >= MAX_TIMEOUT) {
//断开链接
this.stateCtx.closeChannle(describe);
}
}
@Override
public void onHeartbeat(long lastUpdateTime, String describe) {
//=======更新最后更新时间=========
this.stateCtx.setLastUpdateTime(lastUpdateTime);
//=======状态转换为已登录=========
this.stateCtx.setState(new LoggedState(this.stateCtx), describe);
}
@Override
public String getStateName() {
return "timeout";
}
}

@ -1,152 +0,0 @@
package com.docus.server.common.process;
import com.docus.core.util.Func;
import com.docus.log.context.TrackContext;
import com.docus.log.processor.AbstractProcessor;
import com.docus.server.common.netty.server.ChannelRepository;
import com.docus.server.dto.scheduling.management.schcollectrecord.EditSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schterminator.EditSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.enums.BusyStateEnum;
import com.docus.server.enums.RetryTaskEnum;
import com.docus.server.enums.StateEnum;
import com.docus.server.service.ISchCollectRecordRetryLogService;
import com.docus.server.service.ISchCollectRecordService;
import com.docus.server.service.ISchTerminatorService;
import com.docus.server.vo.scheduling.management.schcollectrecord.SchCollectRecordVO;
import com.docus.server.vo.scheduling.management.schcollectrecordretrylog.SchCollectRecordRetryLogVO;
import com.docus.server.vo.scheduling.management.schterminator.SchTerminatorVO;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* channel
*/
public class ChannelProcessor extends AbstractProcessor {
@Resource
private ChannelRepository channelRepository;
@Resource
private ISchTerminatorService iSchTerminatorService;
@Resource
private ISchCollectRecordService iSchCollectRecordService;
@Resource
private ISchCollectRecordRetryLogService iSchCollectRecordRetryLogService;
@Override
protected Object doProcess(TrackContext context) {
String group = context.getGroup();
switch (group) {
case "SchCollectRecordController-edit":
return doSchCollectRecordControllerEdit(context);
case "SchTerminatorController":
return doSchTerminatorController(context);
case "RedisKeyExpirationService-expired":
return doRedisKeyExpired(context);
default:
return true;
}
}
private Object doRedisKeyExpired(TrackContext context) {
boolean error = context.isError();
String expireKey = (String) context.getArgs()[0];
String recordId = expireKey.substring(expireKey.lastIndexOf(":") + 1);
if (!error) {
if (expireKey.startsWith("schCollectorRecord:isRetryTask:expireKey:")) {
retryTask(recordId);
}
if (expireKey.startsWith("schCollectorRecord:noRetryTask:expireKey:")) {
noRetryTask(recordId);
}
}
return null;
}
private boolean doSchCollectRecordControllerEdit(TrackContext context) {
return logCollectRecord(context);
}
private boolean doSchTerminatorController(TrackContext context) {
return logTerminator(context);
}
private boolean logCollectRecord(TrackContext context) {
boolean error = context.isError();
EditSchCollectRecordDTO collectRecordDTO = (EditSchCollectRecordDTO) context.getArgs()[0];
if (!error) {
if (RetryTaskEnum.NO_RETRY_TASK.equals(collectRecordDTO.getIsRetryTask())) {
noRetryTask(String.valueOf(collectRecordDTO.getId()));
} else if (RetryTaskEnum.RETRY_TASK.equals(collectRecordDTO.getIsRetryTask())) {
retryTask(String.valueOf(collectRecordDTO.getId()));
}
}
return error;
}
private void retryTask(String recordLogId) {
SchCollectRecordRetryLogVO retryLogVO = iSchCollectRecordRetryLogService.findById(recordLogId);
updateTerminatorState(retryLogVO.getTerminatorId(), retryLogVO.getTaskExecState());
}
private void noRetryTask(String recordId) {
SchCollectRecordVO schCollectRecordVO = iSchCollectRecordService.findById(recordId);
updateTerminatorState(schCollectRecordVO.getTerminatorId(), schCollectRecordVO.getTaskExecState());
}
private void updateTerminatorState(Long terminatorId, StateEnum taskExecState) {
SchTerminatorVO schTerminatorVO = iSchTerminatorService.findById(String.valueOf(terminatorId));
NettyTerminatorDTO nettyTerminatorDTO = channelRepository.getTerminatorByIp(String.valueOf(schTerminatorVO.getTerminatorIp()));
if (Func.isEmpty(nettyTerminatorDTO)) {
return;
}
List<StateEnum> stateEnums = Arrays.asList(StateEnum.values());
if (stateEnums.contains(taskExecState)) {
nettyTerminatorDTO.setBusyState(BusyStateEnum.IDLE);
}
}
private boolean logTerminator(TrackContext context) {
boolean error = context.isError();
EditSchTerminatorDTO terminatorDTO = (EditSchTerminatorDTO) context.getArgs()[0];
if (!error) {
SchTerminatorVO terminatorVO = iSchTerminatorService.findById(String.valueOf(terminatorDTO.getId()));
NettyTerminatorDTO nettyTerminatorDTO = channelRepository.getTerminatorByIp(terminatorVO.getTerminatorIp());
if (Func.isNotBlank(terminatorDTO.getOnlyCollectorIds())) {
List<String> onlyList = Arrays.stream(terminatorDTO.getOnlyCollectorIds().split(",")).map(String::valueOf).collect(Collectors.toList());
nettyTerminatorDTO.setOnlyCollectorIds(onlyList);
}
if (Func.isNotBlank(terminatorDTO.getPriorityCollectorIds())) {
List<String> priList = Arrays.stream(terminatorDTO.getPriorityCollectorIds().split(",")).map(String::valueOf).collect(Collectors.toList());
nettyTerminatorDTO.setPriorityCollectorIds(priList);
}
}
return error;
}
}

@ -1,72 +0,0 @@
package com.docus.server.common.process;
import com.docus.infrastructure.redis.service.IdService;
import com.docus.log.context.TrackContext;
import com.docus.log.processor.AbstractProcessor;
import com.docus.server.dto.scheduling.management.schcollector.UpdateSchCollectorDTO;
import com.docus.server.entity.scheduling.management.SchCollector;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import com.docus.server.entity.scheduling.management.SchCollectorVersionLog;
import com.docus.server.entity.scheduling.management.SchSystemParams;
import com.docus.server.enums.StateEnum;
import com.docus.server.infrastructure.dao.ISchCollectorDao;
import com.docus.server.infrastructure.dao.ISchCollectorVersionDao;
import com.docus.server.infrastructure.dao.ISchCollectorVersionLogDao;
import com.docus.server.infrastructure.dao.ISchSystemParamsDao;
import javax.annotation.Resource;
/**
*
*/
public class CollectorVersionProcessor extends AbstractProcessor {
@Resource
private ISchCollectorVersionLogDao iSchCollectorVersionLogDao;
@Resource
private ISchCollectorVersionDao iSchCollectorVersionDao;
@Resource
private ISchSystemParamsDao iSchSystemParamsDao;
@Resource
private ISchCollectorDao iSchCollectorDao;
@Resource
private IdService idService;
@Override
public Object beforeProcess(TrackContext context) {
super.beforeProcess(context);
UpdateSchCollectorDTO updateDTO = (UpdateSchCollectorDTO) context.getArgs()[0];
Long collectorId = updateDTO.getCollectorId();
SchCollector schCollector = iSchCollectorDao.findOneBy("collectorId", collectorId);
SchCollectorVersion preVersion = iSchCollectorVersionDao.findById(schCollector.getCollectorVersionId());
return preVersion.getCollectVersion();
}
@Override
protected Object doProcess(TrackContext context) {
logProcess(context);
return null;
}
private void logProcess(TrackContext context) {
boolean error = context.isError();
UpdateSchCollectorDTO updateDTO = (UpdateSchCollectorDTO) context.getArgs()[0];
Long collectorId = updateDTO.getCollectorId();
String preVersion = (String) context.getBeforeResult();
SchCollectorVersion curVersion = iSchCollectorVersionDao.findById(updateDTO.getCollectorVersionId());
SchSystemParams schSystemParams = iSchSystemParamsDao.findOneBy("paramValue", collectorId);
SchCollectorVersionLog log = new SchCollectorVersionLog();
log.setId(idService.getDateSeq());
log.setCollectorId(collectorId);
log.setOperationModule(context.getGroup());
log.setOperationType(context.getAction());
log.setOperationDesc(context.getDesc());
log.setOperationContent(String.format("采集器:%s上一个版本是%s更换成当前版本是%s", schSystemParams.getParamName(), preVersion, curVersion.getCollectVersion()));
log.setState(error ? StateEnum.FAIL : StateEnum.OK);
iSchCollectorVersionLogDao.save(log);
}
}

@ -1,62 +0,0 @@
package com.docus.server.common.process;
import com.docus.core.util.json.JSON;
import com.docus.log.context.TrackContext;
import com.docus.log.processor.AbstractProcessor;
import com.docus.server.common.MsgConstants;
import com.docus.server.dto.scheduling.management.schcollector.UpdateSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schterminator.CommMsgDTO;
import com.docus.server.entity.scheduling.management.SchCollectorVersionFile;
import com.docus.server.service.ICommMsgService;
import com.docus.server.service.ISchCollectorVersionFileService;
import com.docus.server.service.ISchCollectorVersionService;
import com.docus.server.vo.scheduling.management.schcollectorversion.SchCollectorVersionVO;
import com.docus.server.vo.scheduling.management.schcollectorversion.TcpSchCollectorVersionContentVO;
import com.google.common.collect.Lists;
import javax.annotation.Resource;
import java.util.List;
/**
* tcp
*/
public class TcpProcessor extends AbstractProcessor {
@Resource
private ICommMsgService iCommMsgService;
@Resource
private ISchCollectorVersionFileService iSchCollectorVersionFileService;
@Resource
private ISchCollectorVersionService iSchCollectorVersionService;
@Override
protected Object doProcess(TrackContext context) {
return logProcess(context);
}
private boolean logProcess(TrackContext context) {
boolean error = context.isError();
if (!error) {
UpdateSchCollectorDTO updateSchCollectorDTO = (UpdateSchCollectorDTO) context.getArgs()[0];
Long collectorId = updateSchCollectorDTO.getCollectorId();
Long collectorVersionId = updateSchCollectorDTO.getCollectorVersionId();
SchCollectorVersionFile schCollectorVersionFile = iSchCollectorVersionFileService.findByCollectorIdAndVersionId(collectorId, collectorVersionId);
SchCollectorVersionVO schCollectorVersionVO = iSchCollectorVersionService.findById(String.valueOf(collectorVersionId));
TcpSchCollectorVersionContentVO tcpSchCollectorVersionContentVO = new TcpSchCollectorVersionContentVO();
tcpSchCollectorVersionContentVO.setCollectorId(collectorId);
tcpSchCollectorVersionContentVO.setFilePath(schCollectorVersionFile.getFilePath());
tcpSchCollectorVersionContentVO.setCollectorVersion(schCollectorVersionVO.getCollectVersion());
List<TcpSchCollectorVersionContentVO> tcpSchCollectorVersionContentVOList = Lists.newArrayList(tcpSchCollectorVersionContentVO);
CommMsgDTO commMsgDTO = CommMsgDTO.builder()
.content(JSON.toJSON(tcpSchCollectorVersionContentVOList))
.messageType(MsgConstants.UPDATE_COLLECTOR_FILE)
.build();
iCommMsgService.clientsCommand(commMsgDTO);
}
return error;
}
}

@ -1,107 +0,0 @@
package com.docus.server.common.test;
import java.util.ArrayList;
import java.util.List;
public class DispatchService {
public void dispatch() {
//获取所有空闲的终端
List<Terminal> terminalList = new ArrayList<>();
List<TaskInfo> taskInfos = this.getTaskInfos(terminalList.size());
//只采集,有优先级的
for (Terminal terminal : terminalList) {
for (TaskInfo taskInfo : taskInfos) {
//先找出有只采集的任务。
if (terminal.getOnlyTags().contains(taskInfo.getCollectType())) {
//把这个任务派给这个终端,并且把这个终端设置成繁忙
if (terminal.getPriorityTags().contains(taskInfo.getCollectType())) {
//把这个任务派给这个终端
terminal.setState(1);
return;
}
}
}
}
//只采集没有优先级
for (Terminal terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (terminal.getState() == 1) {
continue;
}
for (TaskInfo taskInfo : taskInfos) {
//先找出有只采集的任务。
if (terminal.getOnlyTags().contains(taskInfo.getCollectType())) {
//把这个任务派给这个终端,并且把这个终端设置成繁忙
terminal.setState(1);
return;
}
}
}
//无只采集,有优先级
for (Terminal terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (terminal.getState() == 1) {
continue;
}
for (TaskInfo taskInfo : taskInfos) {
//先找出有只采集的任务。
if (terminal.getPriorityTags().contains(taskInfo.getCollectType())) {
//把这个任务派给这个终端
terminal.setState(1);
return;
}
}
}
//无只采集,无优先级
for (Terminal terminal : terminalList) {
//把刚才已经分配任务过的采集器排除
if (terminal.getState() == 1) {
continue;
}
for (TaskInfo taskInfo : taskInfos) {
//先找出有只采集的任务。
//把这个任务派给这个终端
terminal.setState(1);
return;
}
}
}
private void dispatchTask(List<TaskInfo> taskInfos, Terminal terminal) {
for (TaskInfo taskInfo : taskInfos) {
//先找出有只采集的任务。
if (terminal.getOnlyTags().contains(taskInfo.getCollectType())) {
//把这个任务派给这个终端
return;
}
if (terminal.getPriorityTags().contains(taskInfo.getCollectType())) {
//把这个任务派给这个终端
return;
}
}
}
public List<TaskInfo> getTaskInfos(int size) {
return null;
}
}

@ -1,14 +0,0 @@
package com.docus.server.common.test;
import lombok.Data;
@Data
public class TaskInfo {
private Long taskId;
private String collectType;
private String info;
}

@ -1,16 +0,0 @@
package com.docus.server.common.test;
import lombok.Data;
import java.util.List;
@Data
public class Terminal {
private String id;
private String collectType;
private List<String> priorityTags;
private List<String> onlyTags;
private Integer state;
}

@ -0,0 +1,170 @@
package com.docus.server.common.utils;
import org.springframework.stereotype.Component;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
@Component
public class StartUpExeUtils {
public static void main(String[] args) throws IOException {
// startUpExeOnly("H:\\tools\\Navicat Premium 12免安装\\Navicat Premium 12\\navicat.exe");
// killExeOnly("navicat.exe");
startUpExe("H:\\tools\\Navicat Premium 12免安装\\Navicat Premium 12\\navicat.exe", "navicat.exe");
}
private static boolean startExeStatus = true;//exe启动状态
//仅启动exe客户端不检查进程
public static void startUpExeOnly(String exePath) throws IOException {
if (exePath != "") {
Runtime.getRuntime().exec(exePath);
}
}
/**
* kill
*
* @param procName
* @throws IOException
*/
public static void killExeOnly(String procName) throws IOException {
if (procName != "") {
String command = "taskkill /F /IM " + procName;
Runtime.getRuntime().exec("cmd /c " + command);
}
}
//启动exe客户端
public static boolean startUpExe(String exePath, String procName) {
if (exePath != "" && procName != "") {
String result = checkProcess(procName);//检查exe进程
if (result.isEmpty()) {
try {
Runtime.getRuntime().exec(exePath);
} catch (Exception e) {
e.printStackTrace();
System.out.println("程序:" + exePath + "不存在!");
}
}
}
return startExeStatus;
}
//启动exe客户端,并传参
public static boolean startUpExe(String exePath, String procName, int subId, String curModeId, String riskSet1, String riskSet2, String riskSet3) {
if (exePath != "" && procName != "") {
String result = checkProcess(procName);//检查exe进程
if (result.isEmpty()) {
try {
//启动exe执行程序
String[] cmd = {exePath, subId + "", curModeId, riskSet1, riskSet2, riskSet3};
Runtime.getRuntime().exec(cmd);
} catch (Exception e) {
e.printStackTrace();
System.out.println("程序:" + exePath + "不存在!");
}
}
}
return startExeStatus;
}
/**
*
*
* @param procName
*/
public static String checkProcess(String procName) {
String result = "";
//判断是否存在进程
Boolean existProc = false;
BufferedReader bufferedReader = null;
try {
Process proc = Runtime.getRuntime().exec("tasklist -fi " + '"' + "imagename eq " + procName + '"');
bufferedReader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
String line = null;
while ((line = bufferedReader.readLine()) != null) {
if (line.contains(procName)) {
existProc = true;//存在
}
}
} catch (Exception ex) {
result = "查询程序进程异常:" + ex.getMessage();
System.out.println("查询程序进程异常:" + ex.getMessage());
return result;
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (Exception ex) {
}
}
}
// 存在,则先杀死该进程
if (existProc) {
BufferedReader br = null;
try {
if (procName != "") {
//执行cmd命令
String command = "taskkill /F /IM " + procName;
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("cmd /c " + command);
br = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8"));
String line = null;
StringBuilder build = new StringBuilder();
while ((line = br.readLine()) != null) {
build.append(line);
}
}
} catch (Exception e) {
result = "关闭程序进程异常:" + e.getMessage();
System.out.println("关闭程序进程异常:" + e.getMessage());
return result;
} finally {
if (br != null) {
try {
br.close();
} catch (Exception ex) {
}
}
}
}
return result;
}
/**
*
*
* @param procName
*/
public static boolean checkProcessOnly(String procName) {
//判断是否存在进程
Boolean existProc = false;
BufferedReader bufferedReader = null;
try {
Process proc = Runtime.getRuntime().exec("tasklist -fi " + '"' + "imagename eq " + procName + '"');
bufferedReader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
String line = null;
while ((line = bufferedReader.readLine()) != null) {
if (line.contains(procName)) {
existProc = true;//存在
}
}
} catch (Exception ex) {
System.out.println("查询程序进程异常:" + ex.getMessage());
return existProc;
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (Exception ex) {
}
}
}
return existProc;
}
}

@ -0,0 +1,313 @@
package com.docus.server.common.utils;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.GlobalMemory;
import oshi.hardware.HardwareAbstractionLayer;
import oshi.hardware.NetworkIF;
import oshi.software.os.FileSystem;
import oshi.software.os.OSFileStore;
import oshi.software.os.OperatingSystem;
import oshi.util.Util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.DecimalFormat;
import java.util.Formatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
import java.util.StringTokenizer;
/**
*
**/
public class SystemInfoUtils {
private static final int OSHI_WAIT_SECOND = 1000;
private static final int SLEEP_TIME = 2 * 1000;
private static SystemInfo systemInfo = new SystemInfo();
private static HardwareAbstractionLayer hardware = systemInfo.getHardware();
private static OperatingSystem operatingSystem = systemInfo.getOperatingSystem();
public static void main(String[] args) throws Exception {
JSONObject info = getInfo();
System.out.println(info);
}
public static JSONObject getCpuInfo() {
JSONObject cpuInfo = new JSONObject();
CentralProcessor processor = hardware.getProcessor();
// CPU信息
long[] prevTicks = processor.getSystemCpuLoadTicks();
Util.sleep(OSHI_WAIT_SECOND);
long[] ticks = processor.getSystemCpuLoadTicks();
long nice = ticks[CentralProcessor.TickType.NICE.getIndex()] - prevTicks[CentralProcessor.TickType.NICE.getIndex()];
long irq = ticks[CentralProcessor.TickType.IRQ.getIndex()] - prevTicks[CentralProcessor.TickType.IRQ.getIndex()];
long softirq = ticks[CentralProcessor.TickType.SOFTIRQ.getIndex()] - prevTicks[CentralProcessor.TickType.SOFTIRQ.getIndex()];
long steal = ticks[CentralProcessor.TickType.STEAL.getIndex()] - prevTicks[CentralProcessor.TickType.STEAL.getIndex()];
long cSys = ticks[CentralProcessor.TickType.SYSTEM.getIndex()] - prevTicks[CentralProcessor.TickType.SYSTEM.getIndex()];
long user = ticks[CentralProcessor.TickType.USER.getIndex()] - prevTicks[CentralProcessor.TickType.USER.getIndex()];
long iowait = ticks[CentralProcessor.TickType.IOWAIT.getIndex()] - prevTicks[CentralProcessor.TickType.IOWAIT.getIndex()];
long idle = ticks[CentralProcessor.TickType.IDLE.getIndex()] - prevTicks[CentralProcessor.TickType.IDLE.getIndex()];
long totalCpu = user + nice + cSys + idle + iowait + irq + softirq + steal;
//cpu核数
cpuInfo.put("cpuNum", processor.getLogicalProcessorCount());
//cpu系统使用率
cpuInfo.put("cSys", new DecimalFormat("#.##%").format(cSys * 1.0 / totalCpu));
//cpu用户使用率
cpuInfo.put("user", new DecimalFormat("#.##%").format(user * 1.0 / totalCpu));
//cpu当前等待率
cpuInfo.put("iowait", new DecimalFormat("#.##%").format(iowait * 1.0 / totalCpu));
//cpu当前使用率
cpuInfo.put("idle", new DecimalFormat("#.##%").format(1.0 - (idle * 1.0 / totalCpu)));
return cpuInfo;
}
/**
* jvm
*/
public static JSONObject getJvmInfo() {
JSONObject cpuInfo = new JSONObject();
Properties props = System.getProperties();
Runtime runtime = Runtime.getRuntime();
long jvmTotalMemoryByte = runtime.totalMemory();
long freeMemoryByte = runtime.freeMemory();
//jvm总内存
cpuInfo.put("total", formatByte(runtime.totalMemory()));
//空闲空间
cpuInfo.put("free", formatByte(runtime.freeMemory()));
//jvm最大可申请
cpuInfo.put("max", formatByte(runtime.maxMemory()));
//vm已使用内存
cpuInfo.put("user", formatByte(jvmTotalMemoryByte - freeMemoryByte));
//jvm内存使用率
cpuInfo.put("usageRate", new DecimalFormat("#.##%").format((jvmTotalMemoryByte - freeMemoryByte) * 1.0 / jvmTotalMemoryByte));
//jdk版本
cpuInfo.put("jdkVersion", props.getProperty("java.version"));
//jdk路径
cpuInfo.put("jdkHome", props.getProperty("java.home"));
return cpuInfo;
}
/**
*
*/
public static JSONObject getMemInfo() {
JSONObject cpuInfo = new JSONObject();
GlobalMemory memory = systemInfo.getHardware().getMemory();
//总内存
long totalByte = memory.getTotal();
//剩余
long acaliableByte = memory.getAvailable();
//总内存
cpuInfo.put("total", formatByte(totalByte));
//使用
cpuInfo.put("used", formatByte(totalByte - acaliableByte));
//剩余内存
cpuInfo.put("free", formatByte(acaliableByte));
//使用率
cpuInfo.put("usageRate", new DecimalFormat("#.##%").format((totalByte - acaliableByte) * 1.0 / totalByte));
return cpuInfo;
}
/**
*
*/
public static JSONArray networkIFs() throws Exception {
JSONObject cpuInfo;
JSONArray sysFiles = new JSONArray();
List<NetworkIF> networkIFs = systemInfo.getHardware().getNetworkIFs();
for (NetworkIF networkIF : networkIFs) {
String name = networkIF.getName();
long receiveBytes = networkIF.getBytesRecv();
long transmitBytes = networkIF.getBytesSent();
cpuInfo = new JSONObject();
//名称
cpuInfo.put("name", name);
//网络接收
cpuInfo.put("receiveBytes", formatNumber(receiveBytes / (1024.0 * (2 * 1000 / 1000))));
//网络发送
cpuInfo.put("transmitBytes", formatNumber(transmitBytes / (1024.0 * (2 * 1000 / 1000))));
sysFiles.add(cpuInfo);
}
return sysFiles;
}
public static JSONObject getNetWork() {
JSONObject networkInfo = new JSONObject();
Properties props = System.getProperties();
String os = props.getProperty("os.name").toLowerCase();
os = os.startsWith("win") ? "windows" : "linux";
Map<String, String> result = new HashMap<>();
Process pro = null;
Runtime r = Runtime.getRuntime();
BufferedReader input = null;
try {
String command = "windows".equals(os) ? "netstat -e" : "ifconfig";
pro = r.exec(command);
input = new BufferedReader(new InputStreamReader(pro.getInputStream()));
long result1[] = readInLine(input, os);
Thread.sleep(SLEEP_TIME);
pro.destroy();
input.close();
pro = r.exec(command);
input = new BufferedReader(new InputStreamReader(pro.getInputStream()));
long result2[] = readInLine(input, os);
String rxPercent = formatNumber((result2[0] - result1[0]) / (1024.0 * (SLEEP_TIME / 1000)));// 下行速率(kB/s)
String txPercent = formatNumber((result2[1] - result1[1]) / (1024.0 * (SLEEP_TIME / 1000)));// 上行速率(kB/s)
networkInfo.put("rxPercent", rxPercent);
networkInfo.put("txPercent", txPercent);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
Optional.ofNullable(pro).ifPresent(p -> p.destroy());
}
return networkInfo;
}
private static long[] readInLine(BufferedReader input, String osType) {
long arr[] = new long[2];
StringTokenizer tokenStat = null;
try {
if (osType.equals("linux")) { // 获取linux环境下的网口上下行速率
long rx = 0, tx = 0;
String line = null;
//RX packets:4171603 errors:0 dropped:0 overruns:0 frame:0
//TX packets:4171603 errors:0 dropped:0 overruns:0 carrier:0
while ((line = input.readLine()) != null) {
if (line.indexOf("RX packets") >= 0) {
rx += Long.parseLong(line.substring(line.indexOf("RX packets") + 11, line.indexOf(" ", line.indexOf("RX packets") + 11)));
} else if (line.indexOf("TX packets") >= 0) {
tx += Long.parseLong(line.substring(line.indexOf("TX packets") + 11, line.indexOf(" ", line.indexOf("TX packets") + 11)));
}
}
arr[0] = rx;
arr[1] = tx;
} else { // 获取windows环境下的网口上下行速率
input.readLine();
input.readLine();
input.readLine();
input.readLine();
tokenStat = new StringTokenizer(input.readLine());
tokenStat.nextToken();
arr[0] = Long.parseLong(tokenStat.nextToken());
arr[1] = Long.parseLong(tokenStat.nextToken());
}
} catch (Exception e) {
e.printStackTrace();
}
return arr;
}
private static String formatNumber(double f) {
return new Formatter().format("%.2f", f).toString();
}
/**
*
*/
public static JSONArray getSysFileInfo() {
JSONObject cpuInfo;
JSONArray sysFiles = new JSONArray();
FileSystem fileSystem = operatingSystem.getFileSystem();
List<OSFileStore> fsArray = fileSystem.getFileStores();
for (OSFileStore fs : fsArray) {
cpuInfo = new JSONObject();
//盘符路径
cpuInfo.put("dirName", fs.getMount());
//盘符类型
cpuInfo.put("sysTypeName", fs.getType());
//文件类型
cpuInfo.put("typeName", fs.getName());
//总大小
cpuInfo.put("total", formatByte(fs.getTotalSpace()));
//剩余大小
cpuInfo.put("free", formatByte(fs.getUsableSpace()));
//已经使用量
cpuInfo.put("used", formatByte(fs.getTotalSpace() - fs.getUsableSpace()));
if (fs.getTotalSpace() == 0) {
//资源的使用率
cpuInfo.put("usage", 0);
} else {
cpuInfo.put("usage", new DecimalFormat("#.##%").format((fs.getTotalSpace() - fs.getUsableSpace()) * 1.0 / fs.getTotalSpace()));
}
sysFiles.add(cpuInfo);
}
return sysFiles;
}
/**
*
*/
public static JSONObject getSysInfo() throws UnknownHostException {
JSONObject cpuInfo = new JSONObject();
Properties props = System.getProperties();
//操作系统名
cpuInfo.put("osName", props.getProperty("os.name"));
//系统架构
cpuInfo.put("osArch", props.getProperty("os.arch"));
//服务器名称
cpuInfo.put("computerName", InetAddress.getLocalHost().getHostName());
//服务器Ip
cpuInfo.put("computerIp", InetAddress.getLocalHost().getHostAddress());
//项目路径
cpuInfo.put("userDir", props.getProperty("user.dir"));
return cpuInfo;
}
/**
*
*/
public static JSONObject getInfo() throws Exception {
JSONObject info = new JSONObject();
info.put("cpuInfo", getCpuInfo());
info.put("jvmInfo", getJvmInfo());
info.put("memInfo", getMemInfo());
info.put("sysInfo", getSysInfo());
info.put("sysFileInfo", getSysFileInfo());
info.put("networkInfo", getNetWork());
return info;
}
/**
*
*/
private static String formatByte(long byteNumber) {
//换算单位
double FORMAT = 1024.0;
double kbNumber = byteNumber / FORMAT;
if (kbNumber < FORMAT) {
return new DecimalFormat("#.##KB").format(kbNumber);
}
double mbNumber = kbNumber / FORMAT;
if (mbNumber < FORMAT) {
return new DecimalFormat("#.##MB").format(mbNumber);
}
double gbNumber = mbNumber / FORMAT;
if (gbNumber < FORMAT) {
return new DecimalFormat("#.##GB").format(gbNumber);
}
double tbNumber = gbNumber / FORMAT;
return new DecimalFormat("#.##TB").format(tbNumber);
}
}

@ -1,25 +0,0 @@
package com.docus.server.controller;
import com.docus.server.api.scheduling.management.CommMsgApi;
import com.docus.server.dto.scheduling.management.schterminator.CommMsgDTO;
import com.docus.server.service.ICommMsgService;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* TCP API
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class CommMsgController implements CommMsgApi {
@Resource
private ICommMsgService iCommMsgService;
@Override
public void clientCommand(CommMsgDTO commMsgDTO) {
iCommMsgService.clientCommand(commMsgDTO);
}
}

@ -1,31 +0,0 @@
package com.docus.server.controller;
import com.docus.server.api.scheduling.management.FileApi;
import com.docus.server.service.IFileUploadService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
/**
* API
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class FileController implements FileApi {
@Resource
private IFileUploadService iFileUploadService;
@Override
public void downloadFile(String filePath, HttpServletResponse response) throws Exception {
iFileUploadService.downloadFile(filePath, response);
}
@Override
public void uploadFile(MultipartFile[] multipartFiles, String pathKey) throws Exception {
iFileUploadService.uploadFile(multipartFiles, pathKey);
}
}

@ -1,81 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchCollectErrorLogApi;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.AddSchCollectErrorLogDTO;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.DeleteSchCollectErrorLogDTO;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.EditSchCollectErrorLogDTO;
import com.docus.server.service.ISchCollectErrorLogService;
import com.docus.server.vo.scheduling.management.schcollecterrorlog.SchCollectErrorLogVO;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectErrorLogController implements SchCollectErrorLogApi {
@Resource
private ISchCollectErrorLogService iSchCollectErrorLogService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectErrorLogVO findById(String id) {
return iSchCollectErrorLogService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectErrorLogVO> search(SearchDTO searchDTO) {
return iSchCollectErrorLogService.search(searchDTO);
}
/**
*
*
* @param addSchCollectErrorLogDTO
* @return
*/
@Override
public boolean add(AddSchCollectErrorLogDTO addSchCollectErrorLogDTO, MultipartFile[] multipartFiles) throws Exception {
return iSchCollectErrorLogService.add(addSchCollectErrorLogDTO, multipartFiles);
}
/**
*
*
* @param editSchCollectErrorLogDTO
* @return
*/
@Override
public boolean edit(EditSchCollectErrorLogDTO editSchCollectErrorLogDTO) {
return iSchCollectErrorLogService.edit(editSchCollectErrorLogDTO);
}
/**
*
*
* @param deleteSchCollectErrorLogDTO
* @return
*/
@Override
public int delete(DeleteSchCollectErrorLogDTO deleteSchCollectErrorLogDTO) {
return iSchCollectErrorLogService.delete(deleteSchCollectErrorLogDTO);
}
}

@ -1,103 +0,0 @@
package com.docus.server.controller;
import com.docus.core.util.ParamsUtils;
import com.docus.core.util.json.JSON;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.log.annotation.TrackGroup;
import com.docus.server.api.scheduling.management.SchCollectRecordApi;
import com.docus.server.common.SchCollectorTask;
import com.docus.server.common.process.ChannelProcessor;
import com.docus.server.dto.scheduling.management.schcollector.task.ReportDownTwoDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.AddSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.DeleteSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.EditSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.RetrySchCollectRecordDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import com.docus.server.enums.RetryTaskEnum;
import com.docus.server.service.ISchCollectRecordService;
import com.docus.server.vo.scheduling.management.schcollectrecord.SchCollectRecordVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectRecordController implements SchCollectRecordApi {
@Resource
private ISchCollectRecordService iSchCollectRecordService;
@Resource
private SchCollectorTask schedulerTask;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectRecordVO findById(String id) {
return iSchCollectRecordService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectRecordVO> search(SearchDTO searchDTO) {
return iSchCollectRecordService.search(searchDTO);
}
/**
*
*
* @param addSchCollectRecordDTO
* @return
*/
@Override
public SchCollectRecord add(AddSchCollectRecordDTO addSchCollectRecordDTO) {
return iSchCollectRecordService.add(addSchCollectRecordDTO);
}
/**
*
*
* @param editSchCollectRecordDTO
* @return
*/
@TrackGroup(group = "SchCollectRecordController-edit", processor = ChannelProcessor.class)
@Override
public boolean edit(EditSchCollectRecordDTO editSchCollectRecordDTO) {
return iSchCollectRecordService.edit(editSchCollectRecordDTO);
}
/**
*
*
* @param deleteSchCollectRecordDTO
* @return
*/
@Override
public int delete(DeleteSchCollectRecordDTO deleteSchCollectRecordDTO) {
return iSchCollectRecordService.delete(deleteSchCollectRecordDTO);
}
@Override
public void retryTask(RetrySchCollectRecordDTO retrySchCollectRecordDTO) {
ReportDownTwoDTO report = JSON.fromJSON(retrySchCollectRecordDTO.getTaskOriginJson(), ReportDownTwoDTO.class);
report.setParams(ParamsUtils
.addParam("collectRecordId", retrySchCollectRecordDTO.getId())
.addParam("isRetryTask", RetryTaskEnum.RETRY_TASK.getValue())
.param());
schedulerTask.addRetryTask(report);
}
}

@ -1,81 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchCollectRecordRetryLogApi;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.AddSchCollectRecordRetryLogDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.DeleteSchCollectRecordRetryLogDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.EditSchCollectRecordRetryLogDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import com.docus.server.service.ISchCollectRecordRetryLogService;
import com.docus.server.vo.scheduling.management.schcollectrecordretrylog.SchCollectRecordRetryLogVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectRecordRetryLogController implements SchCollectRecordRetryLogApi {
@Resource
private ISchCollectRecordRetryLogService iSchCollectRecordRetryLogService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectRecordRetryLogVO findById(String id) {
return iSchCollectRecordRetryLogService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectRecordRetryLogVO> search(SearchDTO searchDTO) {
return iSchCollectRecordRetryLogService.search(searchDTO);
}
/**
*
*
* @param addSchCollectRecordRetryLogDTO
* @return
*/
@Override
public SchCollectRecordRetryLog add(AddSchCollectRecordRetryLogDTO addSchCollectRecordRetryLogDTO) {
return iSchCollectRecordRetryLogService.add(addSchCollectRecordRetryLogDTO);
}
/**
*
*
* @param editSchCollectRecordRetryLogDTO
* @return
*/
@Override
public boolean edit(EditSchCollectRecordRetryLogDTO editSchCollectRecordRetryLogDTO) {
return iSchCollectRecordRetryLogService.edit(editSchCollectRecordRetryLogDTO);
}
/**
*
*
* @param deleteSchCollectRecordRetryLogDTO
* @return
*/
@Override
public int delete(DeleteSchCollectRecordRetryLogDTO deleteSchCollectRecordRetryLogDTO) {
return iSchCollectRecordRetryLogService.delete(deleteSchCollectRecordRetryLogDTO);
}
}

@ -1,94 +0,0 @@
package com.docus.server.controller;
import com.docus.core.util.json.JSON;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchCollectorConfigApi;
import com.docus.server.dto.scheduling.management.schcollectorconfig.AddSchCollectorConfigDTO;
import com.docus.server.dto.scheduling.management.schcollectorconfig.DeleteSchCollectorConfigDTO;
import com.docus.server.dto.scheduling.management.schcollectorconfig.EditSchCollectorConfigDTO;
import com.docus.server.service.ISchCollectorConfigService;
import com.docus.server.vo.scheduling.management.schcollectorconfig.SchCollectorConfigVO;
import com.google.common.collect.Maps;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.HashMap;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectorConfigController implements SchCollectorConfigApi {
@Resource
private ISchCollectorConfigService iSchCollectorConfigService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorConfigVO findById(String id) {
return iSchCollectorConfigService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorConfigVO> search(SearchDTO searchDTO) {
return iSchCollectorConfigService.search(searchDTO);
}
/**
*
*
* @param addSchCollectorConfigDTO
* @return
*/
@Override
public boolean add(AddSchCollectorConfigDTO addSchCollectorConfigDTO) {
return iSchCollectorConfigService.add(addSchCollectorConfigDTO);
}
/**
*
*
* @param editSchCollectorConfigDTO
* @return
*/
@Override
public boolean edit(EditSchCollectorConfigDTO editSchCollectorConfigDTO) {
return iSchCollectorConfigService.edit(editSchCollectorConfigDTO);
}
/**
*
*
* @param deleteSchCollectorConfigDTO
* @return
*/
@Override
public int delete(DeleteSchCollectorConfigDTO deleteSchCollectorConfigDTO) {
return iSchCollectorConfigService.delete(deleteSchCollectorConfigDTO);
}
public static void main(String[] args) {
HashMap<Object, Object> objectObjectHashMap = Maps.newHashMap();
objectObjectHashMap.put("ocr.url", "http://192.168.2.13/ocr");
objectObjectHashMap.put("ocr.name", "lin");
objectObjectHashMap.put("ocr.pwd", "123");
System.out.println(JSON.toJSON(objectObjectHashMap));
}
}

@ -1,94 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.log.annotation.TrackLogGroup;
import com.docus.server.api.scheduling.management.SchCollectorApi;
import com.docus.server.common.process.CollectorVersionProcessor;
import com.docus.server.dto.scheduling.management.schcollector.AddSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.DeleteSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.EditSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.UpdateSchCollectorDTO;
import com.docus.server.service.ISchCollectorService;
import com.docus.server.vo.scheduling.management.schcollector.SchCollectorVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectorController implements SchCollectorApi {
@Resource
private ISchCollectorService iSchCollectorService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVO findById(String id) {
return iSchCollectorService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVO> search(SearchDTO searchDTO) {
return iSchCollectorService.search(searchDTO);
}
/**
*
*
* @param addSchCollectorDTO
* @return
*/
@Override
public boolean add(AddSchCollectorDTO addSchCollectorDTO) {
return iSchCollectorService.add(addSchCollectorDTO);
}
/**
*
*
* @param editSchCollectorDTO
* @return
*/
@Override
public boolean edit(EditSchCollectorDTO editSchCollectorDTO) {
return iSchCollectorService.edit(editSchCollectorDTO);
}
/**
*
*
* @param deleteSchCollectorDTO
* @return
*/
@Override
public int delete(DeleteSchCollectorDTO deleteSchCollectorDTO) {
return iSchCollectorService.delete(deleteSchCollectorDTO);
}
/**
*
*
* @return
*/
@TrackLogGroup(group = "采集器管理", action = "更新", desc = "更新采集器版本", processor = CollectorVersionProcessor.class)
@Override
public boolean updateVersion(UpdateSchCollectorDTO updateDTO) {
return iSchCollectorService.updateVersion(updateDTO);
}
}

@ -1,84 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchCollectorVersionApi;
import com.docus.server.dto.scheduling.management.schcollectorversion.AddSchCollectorVersionDTO;
import com.docus.server.dto.scheduling.management.schcollectorversion.DeleteSchCollectorVersionDTO;
import com.docus.server.dto.scheduling.management.schcollectorversion.EditSchCollectorVersionDTO;
import com.docus.server.service.ISchCollectorService;
import com.docus.server.service.ISchCollectorVersionService;
import com.docus.server.vo.scheduling.management.schcollectorversion.SchCollectorVersionVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectorVersionController implements SchCollectorVersionApi {
@Resource
private ISchCollectorVersionService iSchCollectorVersionService;
@Resource
private ISchCollectorService iSchCollectorService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVersionVO findById(String id) {
return iSchCollectorVersionService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVersionVO> search(SearchDTO searchDTO) {
return iSchCollectorVersionService.search(searchDTO);
}
/**
*
*
* @param addSchCollectorVersionDTO
* @return
*/
@Override
public boolean add(AddSchCollectorVersionDTO addSchCollectorVersionDTO) {
return iSchCollectorVersionService.add(addSchCollectorVersionDTO);
}
/**
*
*
* @param editSchCollectorVersionDTO
* @return
*/
@Override
public boolean edit(EditSchCollectorVersionDTO editSchCollectorVersionDTO) {
return iSchCollectorVersionService.edit(editSchCollectorVersionDTO);
}
/**
*
*
* @param deleteSchCollectorVersionDTO
* @return
*/
@Override
public int delete(DeleteSchCollectorVersionDTO deleteSchCollectorVersionDTO) {
return iSchCollectorVersionService.delete(deleteSchCollectorVersionDTO);
}
}

@ -1,114 +0,0 @@
package com.docus.server.controller;
import cn.hutool.core.util.StrUtil;
import com.docus.core.util.Func;
import com.docus.infrastructure.web.exception.ApiException;
import com.docus.infrastructure.web.exception.ExceptionCode;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchCollectorVersionFileApi;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.AddSchCollectorVersionFileDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.DeleteSchCollectorVersionFileDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.EditSchCollectorVersionFileDTO;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import com.docus.server.service.ISchCollectorVersionFileService;
import com.docus.server.service.ISchCollectorVersionService;
import com.docus.server.vo.scheduling.management.schcollectorversionfile.SchCollectorVersionFileVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
@Slf4j
public class SchCollectorVersionFileController implements SchCollectorVersionFileApi {
@Resource
private ISchCollectorVersionFileService iSchCollectorVersionFileService;
@Resource
private ISchCollectorVersionService iSchCollectorVersionService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVersionFileVO findById(String id) {
return iSchCollectorVersionFileService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVersionFileVO> search(SearchDTO searchDTO) {
return iSchCollectorVersionFileService.search(searchDTO);
}
/**
*
*
* @param addDTO
* @return
*/
@Override
public boolean add(AddSchCollectorVersionFileDTO addDTO, MultipartFile[] multipartFiles) throws Exception {
if (fileValid(multipartFiles, addDTO)) {
throw new ApiException(ExceptionCode.ParamIllegal.getCode(), "请选择文件和填写上传文件信息!");
}
SchCollectorVersion schCollectorVersion = iSchCollectorVersionService.findByVersion(addDTO.getCollectorId(), addDTO.getCollectorVersionNo());
if (null != schCollectorVersion) {
throw new ApiException(ExceptionCode.ParamIllegal.getCode(), "当前采集器版本号已存在!");
}
iSchCollectorVersionFileService.addVersionAndFile(addDTO, multipartFiles);
return true;
}
private boolean fileValid(MultipartFile[] multipartFiles, AddSchCollectorVersionFileDTO addSchCollectorVersionFileDTO) {
return multipartFiles == null
|| multipartFiles.length == 0
|| StrUtil.isBlank(addSchCollectorVersionFileDTO.getCollectorVersionNo())
|| Func.isEmpty(addSchCollectorVersionFileDTO.getCollectorId());
}
public boolean add(AddSchCollectorVersionFileDTO addSchCollectorVersionFileDTO) {
return iSchCollectorVersionFileService.add(addSchCollectorVersionFileDTO);
}
/**
*
*
* @param editSchCollectorVersionFileDTO
* @return
*/
@Override
public boolean edit(EditSchCollectorVersionFileDTO editSchCollectorVersionFileDTO) {
return iSchCollectorVersionFileService.edit(editSchCollectorVersionFileDTO);
}
/**
*
*
* @param deleteSchCollectorVersionFileDTO
* @return
*/
@Override
public int delete(DeleteSchCollectorVersionFileDTO deleteSchCollectorVersionFileDTO) {
return iSchCollectorVersionFileService.delete(deleteSchCollectorVersionFileDTO);
}
}

@ -1,80 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchCollectorVersionLogApi;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.AddSchCollectorVersionLogDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.DeleteSchCollectorVersionLogDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.EditSchCollectorVersionLogDTO;
import com.docus.server.service.ISchCollectorVersionLogService;
import com.docus.server.vo.scheduling.management.schcollectorversionlog.SchCollectorVersionLogVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchCollectorVersionLogController implements SchCollectorVersionLogApi {
@Resource
private ISchCollectorVersionLogService iSchCollectorVersionLogService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVersionLogVO findById(String id) {
return iSchCollectorVersionLogService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVersionLogVO> search(SearchDTO searchDTO) {
return iSchCollectorVersionLogService.search(searchDTO);
}
/**
*
*
* @param addSchCollectorVersionLogDTO
* @return
*/
@Override
public boolean add(AddSchCollectorVersionLogDTO addSchCollectorVersionLogDTO) {
return iSchCollectorVersionLogService.add(addSchCollectorVersionLogDTO);
}
/**
*
*
* @param editSchCollectorVersionLogDTO
* @return
*/
@Override
public boolean edit(EditSchCollectorVersionLogDTO editSchCollectorVersionLogDTO) {
return iSchCollectorVersionLogService.edit(editSchCollectorVersionLogDTO);
}
/**
*
*
* @param deleteSchCollectorVersionLogDTO
* @return
*/
@Override
public int delete(DeleteSchCollectorVersionLogDTO deleteSchCollectorVersionLogDTO) {
return iSchCollectorVersionLogService.delete(deleteSchCollectorVersionLogDTO);
}
}

@ -1,80 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchOperationLogApi;
import com.docus.server.dto.scheduling.management.schoperationlog.AddSchOperationLogDTO;
import com.docus.server.dto.scheduling.management.schoperationlog.DeleteSchOperationLogDTO;
import com.docus.server.dto.scheduling.management.schoperationlog.EditSchOperationLogDTO;
import com.docus.server.service.ISchOperationLogService;
import com.docus.server.vo.scheduling.management.schoperationlog.SchOperationLogVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchOperationLogController implements SchOperationLogApi {
@Resource
private ISchOperationLogService iSchOperationLogService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchOperationLogVO findById(String id) {
return iSchOperationLogService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchOperationLogVO> search(SearchDTO searchDTO) {
return iSchOperationLogService.search(searchDTO);
}
/**
*
*
* @param addSchOperationLogDTO
* @return
*/
@Override
public boolean add(AddSchOperationLogDTO addSchOperationLogDTO) {
return iSchOperationLogService.add(addSchOperationLogDTO);
}
/**
*
*
* @param editSchOperationLogDTO
* @return
*/
@Override
public boolean edit(EditSchOperationLogDTO editSchOperationLogDTO) {
return iSchOperationLogService.edit(editSchOperationLogDTO);
}
/**
*
*
* @param deleteSchOperationLogDTO
* @return
*/
@Override
public int delete(DeleteSchOperationLogDTO deleteSchOperationLogDTO) {
return iSchOperationLogService.delete(deleteSchOperationLogDTO);
}
}

@ -1,80 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchSystemParamsApi;
import com.docus.server.dto.scheduling.management.schsystemparams.AddSchSystemParamsDTO;
import com.docus.server.dto.scheduling.management.schsystemparams.DeleteSchSystemParamsDTO;
import com.docus.server.dto.scheduling.management.schsystemparams.EditSchSystemParamsDTO;
import com.docus.server.service.ISchSystemParamsService;
import com.docus.server.vo.scheduling.management.schsystemparams.SchSystemParamsVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchSystemParamsController implements SchSystemParamsApi {
@Resource
private ISchSystemParamsService iSchSystemParamsService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchSystemParamsVO findById(String id) {
return iSchSystemParamsService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchSystemParamsVO> search(SearchDTO searchDTO) {
return iSchSystemParamsService.search(searchDTO);
}
/**
*
*
* @param addSchSystemParamsDTO
* @return
*/
@Override
public boolean add(AddSchSystemParamsDTO addSchSystemParamsDTO) {
return iSchSystemParamsService.add(addSchSystemParamsDTO);
}
/**
*
*
* @param editSchSystemParamsDTO
* @return
*/
@Override
public boolean edit(EditSchSystemParamsDTO editSchSystemParamsDTO) {
return iSchSystemParamsService.edit(editSchSystemParamsDTO);
}
/**
*
*
* @param deleteSchSystemParamsDTO
* @return
*/
@Override
public int delete(DeleteSchSystemParamsDTO deleteSchSystemParamsDTO) {
return iSchSystemParamsService.delete(deleteSchSystemParamsDTO);
}
}

@ -1,87 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.log.annotation.TrackGroup;
import com.docus.server.api.scheduling.management.SchTerminatorApi;
import com.docus.server.common.netty.server.ChannelRepository;
import com.docus.server.common.process.ChannelProcessor;
import com.docus.server.dto.scheduling.management.schterminator.AddSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.DeleteSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.EditSchTerminatorDTO;
import com.docus.server.service.ISchTerminatorService;
import com.docus.server.vo.scheduling.management.schterminator.SchTerminatorVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchTerminatorController implements SchTerminatorApi {
@Resource
private ISchTerminatorService iSchTerminatorService;
@Resource
private ChannelRepository channelRepository;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchTerminatorVO findById(String id) {
return iSchTerminatorService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchTerminatorVO> search(SearchDTO searchDTO) {
return iSchTerminatorService.search(searchDTO);
}
/**
*
*
* @param addSchTerminatorDTO
* @return
*/
@Override
public boolean add(AddSchTerminatorDTO addSchTerminatorDTO) {
return iSchTerminatorService.add(addSchTerminatorDTO);
}
/**
*
*
* @param editSchTerminatorDTO
* @return
*/
@TrackGroup(group = "SchTerminatorController", processor = ChannelProcessor.class)
@Override
public boolean edit(EditSchTerminatorDTO editSchTerminatorDTO) {
return iSchTerminatorService.edit(editSchTerminatorDTO);
}
/**
*
*
* @param deleteSchTerminatorDTO
* @return
*/
@Override
public int delete(DeleteSchTerminatorDTO deleteSchTerminatorDTO) {
return iSchTerminatorService.delete(deleteSchTerminatorDTO);
}
}

@ -1,80 +0,0 @@
package com.docus.server.controller;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.api.scheduling.management.SchVirtualLogApi;
import com.docus.server.dto.scheduling.management.schvirtuallog.AddSchVirtualLogDTO;
import com.docus.server.dto.scheduling.management.schvirtuallog.DeleteSchVirtualLogDTO;
import com.docus.server.dto.scheduling.management.schvirtuallog.EditSchVirtualLogDTO;
import com.docus.server.service.ISchVirtualLogService;
import com.docus.server.vo.scheduling.management.schvirtuallog.SchVirtualLogVO;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* 使
*
* @author AutoGenerator
* @since 2023-07-15
*/
@RestController
public class SchVirtualLogController implements SchVirtualLogApi {
@Resource
private ISchVirtualLogService iSchVirtualLogService;
/**
*
*
* @param id Id
* @return
*/
@Override
public SchVirtualLogVO findById(String id) {
return iSchVirtualLogService.findById(id);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchVirtualLogVO> search(SearchDTO searchDTO) {
return iSchVirtualLogService.search(searchDTO);
}
/**
*
*
* @param addSchVirtualLogDTO
* @return
*/
@Override
public boolean add(AddSchVirtualLogDTO addSchVirtualLogDTO) {
return iSchVirtualLogService.add(addSchVirtualLogDTO);
}
/**
*
*
* @param editSchVirtualLogDTO
* @return
*/
@Override
public boolean edit(EditSchVirtualLogDTO editSchVirtualLogDTO) {
return iSchVirtualLogService.edit(editSchVirtualLogDTO);
}
/**
*
*
* @param deleteSchVirtualLogDTO
* @return
*/
@Override
public int delete(DeleteSchVirtualLogDTO deleteSchVirtualLogDTO) {
return iSchVirtualLogService.delete(deleteSchVirtualLogDTO);
}
}

@ -1,24 +0,0 @@
package com.docus.server.convert;
import com.docus.server.common.netty.CommMsg;
import com.docus.server.dto.scheduling.management.schterminator.CommMsgDTO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface CommMsgConvert {
CommMsgConvert INSTANCE = Mappers.getMapper(CommMsgConvert.class);
@Mappings({})
CommMsg convertDO(CommMsgDTO commMsgDTO);
}

@ -1,48 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectErrorLog;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.AddSchCollectErrorLogDTO;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.EditSchCollectErrorLogDTO;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.DeleteSchCollectErrorLogDTO;
import com.docus.server.vo.scheduling.management.schcollecterrorlog.SchCollectErrorLogVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectErrorLogConvert {
SchCollectErrorLogConvert INSTANCE = Mappers.getMapper(SchCollectErrorLogConvert.class);
@Mappings({})
SchCollectErrorLog convertDO(AddSchCollectErrorLogDTO addSchCollectErrorLogDTO);
@Mappings({})
SchCollectErrorLog convertDO(EditSchCollectErrorLogDTO editSchCollectErrorLogDTO);
@Mappings({})
List<SchCollectErrorLog> convertAddDOList(List<AddSchCollectErrorLogDTO> addSchCollectErrorLogDTO);
@Mappings({})
List<SchCollectErrorLog> convertEditDOList(List<EditSchCollectErrorLogDTO> editSchCollectErrorLogDTO);
@Mappings({})
SchCollectErrorLogVO convertVO(SchCollectErrorLog schCollectErrorLog);
@Mappings({})
List<SchCollectErrorLogVO> convertVO(List<SchCollectErrorLog> schCollectErrorLogList);
@Mappings({})
PageResult<SchCollectErrorLogVO> convertVO(PageResult<SchCollectErrorLog> pageResult);
}

@ -1,47 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectrecord.AddSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.EditSchCollectRecordDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import com.docus.server.vo.scheduling.management.schcollectrecord.SchCollectRecordVO;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectRecordConvert {
SchCollectRecordConvert INSTANCE = Mappers.getMapper(SchCollectRecordConvert.class);
@Mappings({})
SchCollectRecord convertDO(AddSchCollectRecordDTO addSchCollectRecordDTO);
@Mappings({})
SchCollectRecord convertDO(EditSchCollectRecordDTO editSchCollectRecordDTO, @MappingTarget SchCollectRecord schCollectRecord);
@Mappings({})
List<SchCollectRecord> convertAddDOList(List<AddSchCollectRecordDTO> addSchCollectRecordDTO);
@Mappings({})
List<SchCollectRecord> convertEditDOList(List<EditSchCollectRecordDTO> editSchCollectRecordDTO);
@Mappings({})
SchCollectRecordVO convertVO(SchCollectRecord schCollectRecord);
@Mappings({})
List<SchCollectRecordVO> convertVO(List<SchCollectRecord> schCollectRecordList);
@Mappings({})
PageResult<SchCollectRecordVO> convertVO(PageResult<SchCollectRecord> pageResult);
}

@ -1,51 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectrecord.EditSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.AddSchCollectRecordRetryLogDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.EditSchCollectRecordRetryLogDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import com.docus.server.vo.scheduling.management.schcollectrecordretrylog.SchCollectRecordRetryLogVO;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectRecordRetryLogConvert {
SchCollectRecordRetryLogConvert INSTANCE = Mappers.getMapper(SchCollectRecordRetryLogConvert.class);
@Mappings({})
SchCollectRecordRetryLog convertDO(EditSchCollectRecordDTO editSchCollectRecordDTO, @MappingTarget SchCollectRecordRetryLog schCollectRecordRetryLog);
@Mappings({})
SchCollectRecordRetryLog convertDO(AddSchCollectRecordRetryLogDTO addSchCollectRecordRetryLogDTO);
@Mappings({})
SchCollectRecordRetryLog convertDO(EditSchCollectRecordRetryLogDTO editSchCollectRecordRetryLogDTO);
@Mappings({})
List<SchCollectRecordRetryLog> convertAddDOList(List<AddSchCollectRecordRetryLogDTO> addSchCollectRecordRetryLogDTO);
@Mappings({})
List<SchCollectRecordRetryLog> convertEditDOList(List<EditSchCollectRecordRetryLogDTO> editSchCollectRecordRetryLogDTO);
@Mappings({})
SchCollectRecordRetryLogVO convertVO(SchCollectRecordRetryLog schCollectRecordRetryLog);
@Mappings({})
List<SchCollectRecordRetryLogVO> convertVO(List<SchCollectRecordRetryLog> schCollectRecordRetryLogList);
@Mappings({})
PageResult<SchCollectRecordRetryLogVO> convertVO(PageResult<SchCollectRecordRetryLog> pageResult);
}

@ -1,44 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectorconfig.AddSchCollectorConfigDTO;
import com.docus.server.dto.scheduling.management.schcollectorconfig.EditSchCollectorConfigDTO;
import com.docus.server.entity.scheduling.management.SchCollectorConfig;
import com.docus.server.vo.scheduling.management.schcollectorconfig.SchCollectorConfigVO;
import com.docus.server.vo.scheduling.management.schcollectorconfig.TcpSchCollectorConfigVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorConfigConvert {
SchCollectorConfigConvert INSTANCE = Mappers.getMapper(SchCollectorConfigConvert.class);
@Mappings({})
SchCollectorConfig convertDO(AddSchCollectorConfigDTO addSchCollectorConfigDTO);
@Mappings({})
SchCollectorConfig convertDO(EditSchCollectorConfigDTO editSchCollectorConfigDTO);
@Mappings({})
SchCollectorConfigVO convertVO(SchCollectorConfig schCollectorConfig);
@Mappings({})
PageResult<SchCollectorConfigVO> convertVO(PageResult<SchCollectorConfig> pageResult);
@Mappings({})
List<TcpSchCollectorConfigVO> convertTcpVOList(List<SchCollectorConfig> publicConfig);
@Mappings({})
TcpSchCollectorConfigVO convertTcpVO(SchCollectorConfig schCollectorConfig);
}

@ -1,47 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollector.AddSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.EditSchCollectorDTO;
import com.docus.server.entity.scheduling.management.SchCollector;
import com.docus.server.vo.scheduling.management.schcollector.SchCollectorVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorConvert {
SchCollectorConvert INSTANCE = Mappers.getMapper(SchCollectorConvert.class);
@Mappings({})
SchCollector convertDO(AddSchCollectorDTO addSchCollectorDTO);
@Mappings({})
SchCollector convertDO(EditSchCollectorDTO editSchCollectorDTO);
@Mappings({})
List<SchCollector> convertAddDOList(List<AddSchCollectorDTO> addSchCollectorDTO);
@Mappings({})
List<SchCollector> convertEditDOList(List<EditSchCollectorDTO> editSchCollectorDTO);
@Mappings({})
SchCollectorVO convertVO(SchCollector schCollector);
@Mappings({})
List<SchCollectorVO> convertVO(List<SchCollector> schCollectorList);
@Mappings({})
PageResult<SchCollectorVO> convertVO(PageResult<SchCollector> pageResult);
}

@ -1,46 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectorversion.AddSchCollectorVersionDTO;
import com.docus.server.dto.scheduling.management.schcollectorversion.EditSchCollectorVersionDTO;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import com.docus.server.vo.scheduling.management.schcollectorversion.SchCollectorVersionVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorVersionConvert {
SchCollectorVersionConvert INSTANCE = Mappers.getMapper(SchCollectorVersionConvert.class);
@Mappings({})
SchCollectorVersion convertDO(AddSchCollectorVersionDTO addSchCollectorVersionDTO);
@Mappings({})
SchCollectorVersion convertDO(EditSchCollectorVersionDTO editSchCollectorVersionDTO);
@Mappings({})
List<SchCollectorVersion> convertAddDOList(List<AddSchCollectorVersionDTO> addSchCollectorVersionDTO);
@Mappings({})
List<SchCollectorVersion> convertEditDOList(List<EditSchCollectorVersionDTO> editSchCollectorVersionDTO);
@Mappings({})
SchCollectorVersionVO convertVO(SchCollectorVersion schCollectorVersion);
@Mappings({})
List<SchCollectorVersionVO> convertVO(List<SchCollectorVersion> schCollectorVersionList);
@Mappings({})
PageResult<SchCollectorVersionVO> convertVO(PageResult<SchCollectorVersion> pageResult);
}

@ -1,48 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersionFile;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.AddSchCollectorVersionFileDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.EditSchCollectorVersionFileDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.DeleteSchCollectorVersionFileDTO;
import com.docus.server.vo.scheduling.management.schcollectorversionfile.SchCollectorVersionFileVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorVersionFileConvert {
SchCollectorVersionFileConvert INSTANCE = Mappers.getMapper(SchCollectorVersionFileConvert.class);
@Mappings({})
SchCollectorVersionFile convertDO(AddSchCollectorVersionFileDTO addSchCollectorVersionFileDTO);
@Mappings({})
SchCollectorVersionFile convertDO(EditSchCollectorVersionFileDTO editSchCollectorVersionFileDTO);
@Mappings({})
List<SchCollectorVersionFile> convertAddDOList(List<AddSchCollectorVersionFileDTO> addSchCollectorVersionFileDTO);
@Mappings({})
List<SchCollectorVersionFile> convertEditDOList(List<EditSchCollectorVersionFileDTO> editSchCollectorVersionFileDTO);
@Mappings({})
SchCollectorVersionFileVO convertVO(SchCollectorVersionFile schCollectorVersionFile);
@Mappings({})
List<SchCollectorVersionFileVO> convertVO(List<SchCollectorVersionFile> schCollectorVersionFileList);
@Mappings({})
PageResult<SchCollectorVersionFileVO> convertVO(PageResult<SchCollectorVersionFile> pageResult);
}

@ -1,48 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersionLog;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.AddSchCollectorVersionLogDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.EditSchCollectorVersionLogDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.DeleteSchCollectorVersionLogDTO;
import com.docus.server.vo.scheduling.management.schcollectorversionlog.SchCollectorVersionLogVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorVersionLogConvert {
SchCollectorVersionLogConvert INSTANCE = Mappers.getMapper(SchCollectorVersionLogConvert.class);
@Mappings({})
SchCollectorVersionLog convertDO(AddSchCollectorVersionLogDTO addSchCollectorVersionLogDTO);
@Mappings({})
SchCollectorVersionLog convertDO(EditSchCollectorVersionLogDTO editSchCollectorVersionLogDTO);
@Mappings({})
List<SchCollectorVersionLog> convertAddDOList(List<AddSchCollectorVersionLogDTO> addSchCollectorVersionLogDTO);
@Mappings({})
List<SchCollectorVersionLog> convertEditDOList(List<EditSchCollectorVersionLogDTO> editSchCollectorVersionLogDTO);
@Mappings({})
SchCollectorVersionLogVO convertVO(SchCollectorVersionLog schCollectorVersionLog);
@Mappings({})
List<SchCollectorVersionLogVO> convertVO(List<SchCollectorVersionLog> schCollectorVersionLogList);
@Mappings({})
PageResult<SchCollectorVersionLogVO> convertVO(PageResult<SchCollectorVersionLog> pageResult);
}

@ -1,48 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchOperationLog;
import com.docus.server.dto.scheduling.management.schoperationlog.AddSchOperationLogDTO;
import com.docus.server.dto.scheduling.management.schoperationlog.EditSchOperationLogDTO;
import com.docus.server.dto.scheduling.management.schoperationlog.DeleteSchOperationLogDTO;
import com.docus.server.vo.scheduling.management.schoperationlog.SchOperationLogVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchOperationLogConvert {
SchOperationLogConvert INSTANCE = Mappers.getMapper(SchOperationLogConvert.class);
@Mappings({})
SchOperationLog convertDO(AddSchOperationLogDTO addSchOperationLogDTO);
@Mappings({})
SchOperationLog convertDO(EditSchOperationLogDTO editSchOperationLogDTO);
@Mappings({})
List<SchOperationLog> convertAddDOList(List<AddSchOperationLogDTO> addSchOperationLogDTO);
@Mappings({})
List<SchOperationLog> convertEditDOList(List<EditSchOperationLogDTO> editSchOperationLogDTO);
@Mappings({})
SchOperationLogVO convertVO(SchOperationLog schOperationLog);
@Mappings({})
List<SchOperationLogVO> convertVO(List<SchOperationLog> schOperationLogList);
@Mappings({})
PageResult<SchOperationLogVO> convertVO(PageResult<SchOperationLog> pageResult);
}

@ -1,48 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchSystemParams;
import com.docus.server.dto.scheduling.management.schsystemparams.AddSchSystemParamsDTO;
import com.docus.server.dto.scheduling.management.schsystemparams.EditSchSystemParamsDTO;
import com.docus.server.dto.scheduling.management.schsystemparams.DeleteSchSystemParamsDTO;
import com.docus.server.vo.scheduling.management.schsystemparams.SchSystemParamsVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchSystemParamsConvert {
SchSystemParamsConvert INSTANCE = Mappers.getMapper(SchSystemParamsConvert.class);
@Mappings({})
SchSystemParams convertDO(AddSchSystemParamsDTO addSchSystemParamsDTO);
@Mappings({})
SchSystemParams convertDO(EditSchSystemParamsDTO editSchSystemParamsDTO);
@Mappings({})
List<SchSystemParams> convertAddDOList(List<AddSchSystemParamsDTO> addSchSystemParamsDTO);
@Mappings({})
List<SchSystemParams> convertEditDOList(List<EditSchSystemParamsDTO> editSchSystemParamsDTO);
@Mappings({})
SchSystemParamsVO convertVO(SchSystemParams schSystemParams);
@Mappings({})
List<SchSystemParamsVO> convertVO(List<SchSystemParams> schSystemParamsList);
@Mappings({})
PageResult<SchSystemParamsVO> convertVO(PageResult<SchSystemParams> pageResult);
}

@ -1,42 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schterminator.AddSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.EditSchTerminatorDTO;
import com.docus.server.entity.scheduling.management.SchTerminator;
import com.docus.server.vo.scheduling.management.schterminator.SchTerminatorVO;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchTerminatorConvert {
SchTerminatorConvert INSTANCE = Mappers.getMapper(SchTerminatorConvert.class);
@Mappings({})
SchTerminator convertDO(AddSchTerminatorDTO addSchTerminatorDTO);
@Mappings({})
SchTerminator convertDO(EditSchTerminatorDTO editSchTerminatorDTO, @MappingTarget SchTerminator schTerminator1);
@Mappings({})
SchTerminatorVO convertVO(SchTerminator schTerminator);
@Mappings({})
List<SchTerminatorVO> convertVO(List<SchTerminator> schTerminatorList);
@Mappings({})
PageResult<SchTerminatorVO> convertVO(PageResult<SchTerminator> pageResult);
}

@ -1,46 +0,0 @@
package com.docus.server.convert;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schvirtuallog.AddSchVirtualLogDTO;
import com.docus.server.dto.scheduling.management.schvirtuallog.EditSchVirtualLogDTO;
import com.docus.server.entity.scheduling.management.SchVirtualLog;
import com.docus.server.vo.scheduling.management.schvirtuallog.SchVirtualLogVO;
import org.mapstruct.Mapper;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 使
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchVirtualLogConvert {
SchVirtualLogConvert INSTANCE = Mappers.getMapper(SchVirtualLogConvert.class);
@Mappings({})
SchVirtualLog convertDO(AddSchVirtualLogDTO addSchVirtualLogDTO);
@Mappings({})
SchVirtualLog convertDO(EditSchVirtualLogDTO editSchVirtualLogDTO);
@Mappings({})
List<SchVirtualLog> convertAddDOList(List<AddSchVirtualLogDTO> addSchVirtualLogDTO);
@Mappings({})
List<SchVirtualLog> convertEditDOList(List<EditSchVirtualLogDTO> editSchVirtualLogDTO);
@Mappings({})
SchVirtualLogVO convertVO(SchVirtualLog schVirtualLog);
@Mappings({})
List<SchVirtualLogVO> convertVO(List<SchVirtualLog> schVirtualLogList);
@Mappings({})
PageResult<SchVirtualLogVO> convertVO(PageResult<SchVirtualLog> pageResult);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectErrorLog;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectErrorLogDao extends IBaseDao<SchCollectErrorLog> {
/**
*
*
* @param id id
* @return
*/
SchCollectErrorLog findById(String id);
/**
*
*
* @param schCollectErrorLog
* @return
*/
boolean add(SchCollectErrorLog schCollectErrorLog);
/**
*
*
* @param schCollectErrorLog
* @return
*/
boolean edit(SchCollectErrorLog schCollectErrorLog);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectErrorLog> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectRecordDao extends IBaseDao<SchCollectRecord> {
/**
*
*
* @param id id
* @return
*/
SchCollectRecord findById(String id);
/**
*
*
* @param schCollectRecord
* @return
*/
boolean add(SchCollectRecord schCollectRecord);
/**
*
*
* @param schCollectRecord
* @return
*/
boolean edit(SchCollectRecord schCollectRecord);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectRecord> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectRecordRetryLogDao extends IBaseDao<SchCollectRecordRetryLog> {
/**
*
*
* @param id id
* @return
*/
SchCollectRecordRetryLog findById(String id);
/**
*
*
* @param schCollectRecordRetryLog
* @return
*/
boolean add(SchCollectRecordRetryLog schCollectRecordRetryLog);
/**
*
*
* @param schCollectRecordRetryLog
* @return
*/
boolean edit(SchCollectRecordRetryLog schCollectRecordRetryLog);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectRecordRetryLog> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorConfig;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorConfigDao extends IBaseDao<SchCollectorConfig> {
/**
*
*
* @param id id
* @return
*/
SchCollectorConfig findById(String id);
/**
*
*
* @param schCollectorConfig
* @return
*/
boolean add(SchCollectorConfig schCollectorConfig);
/**
*
*
* @param schCollectorConfig
* @return
*/
boolean edit(SchCollectorConfig schCollectorConfig);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorConfig> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollector;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorDao extends IBaseDao<SchCollector> {
/**
*
*
* @param id id
* @return
*/
SchCollector findById(String id);
/**
*
*
* @param schCollector
* @return
*/
boolean add(SchCollector schCollector);
/**
*
*
* @param schCollector
* @return
*/
boolean edit(SchCollector schCollector);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollector> search(SearchDTO searchDTO);
}

@ -1,66 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorVersionDao extends IBaseDao<SchCollectorVersion> {
/**
*
*
* @param id id
* @return
*/
SchCollectorVersion findById(String id);
/**
*
*
* @param schCollectorVersion
* @return
*/
boolean add(SchCollectorVersion schCollectorVersion);
/**
*
*
* @param schCollectorVersion
* @return
*/
boolean edit(SchCollectorVersion schCollectorVersion);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVersion> search(SearchDTO searchDTO);
/**
* id
*
* @param collectorId id
* @param collectorVersionNo
* @return SchCollectorVersion
*/
SchCollectorVersion findByVersion(Long collectorId, String collectorVersionNo);
}

@ -1,58 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersionFile;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorVersionFileDao extends IBaseDao<SchCollectorVersionFile> {
/**
*
*
* @param id id
* @return
*/
SchCollectorVersionFile findById(String id);
/**
*
*
* @param schCollectorVersionFile
* @return
*/
boolean add(SchCollectorVersionFile schCollectorVersionFile);
/**
*
*
* @param schCollectorVersionFile
* @return
*/
boolean edit(SchCollectorVersionFile schCollectorVersionFile);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVersionFile> search(SearchDTO searchDTO);
SchCollectorVersionFile findByVersionIdAndCollectorId(Long collectorId, Long collectorVersionId);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersionLog;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorVersionLogDao extends IBaseDao<SchCollectorVersionLog> {
/**
*
*
* @param id id
* @return
*/
SchCollectorVersionLog findById(String id);
/**
*
*
* @param schCollectorVersionLog
* @return
*/
boolean add(SchCollectorVersionLog schCollectorVersionLog);
/**
*
*
* @param schCollectorVersionLog
* @return
*/
boolean edit(SchCollectorVersionLog schCollectorVersionLog);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVersionLog> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchOperationLog;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchOperationLogDao extends IBaseDao<SchOperationLog> {
/**
*
*
* @param id id
* @return
*/
SchOperationLog findById(String id);
/**
*
*
* @param schOperationLog
* @return
*/
boolean add(SchOperationLog schOperationLog);
/**
*
*
* @param schOperationLog
* @return
*/
boolean edit(SchOperationLog schOperationLog);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchOperationLog> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchSystemParams;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchSystemParamsDao extends IBaseDao<SchSystemParams> {
/**
*
*
* @param id id
* @return
*/
SchSystemParams findById(String id);
/**
*
*
* @param schSystemParams
* @return
*/
boolean add(SchSystemParams schSystemParams);
/**
*
*
* @param schSystemParams
* @return
*/
boolean edit(SchSystemParams schSystemParams);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchSystemParams> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchTerminator;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchTerminatorDao extends IBaseDao<SchTerminator> {
/**
*
*
* @param id id
* @return
*/
SchTerminator findById(String id);
/**
*
*
* @param schTerminator
* @return
*/
boolean add(SchTerminator schTerminator);
/**
*
*
* @param schTerminator
* @return
*/
boolean edit(SchTerminator schTerminator);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchTerminator> search(SearchDTO searchDTO);
}

@ -1,57 +0,0 @@
package com.docus.server.infrastructure.dao;
import com.docus.infrastructure.core.db.dao.IBaseDao;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchVirtualLog;
import java.util.List;
/**
* 使 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchVirtualLogDao extends IBaseDao<SchVirtualLog> {
/**
*
*
* @param id id
* @return
*/
SchVirtualLog findById(String id);
/**
*
*
* @param schVirtualLog
* @return
*/
boolean add(SchVirtualLog schVirtualLog);
/**
*
*
* @param schVirtualLog
* @return
*/
boolean edit(SchVirtualLog schVirtualLog);
/**
*
*
* @param ids ids
* @return
*/
int delete(List<Long> ids);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchVirtualLog> search(SearchDTO searchDTO);
}

@ -1,104 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectErrorLog;
import com.docus.server.infrastructure.dao.ISchCollectErrorLogDao;
import com.docus.server.infrastructure.mapper.SchCollectErrorLogMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectErrorLogDaoImpl extends BaseDaoImpl<SchCollectErrorLogMapper, SchCollectErrorLog> implements ISchCollectErrorLogDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectErrorLog findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectErrorLog
* @return
*/
@Override
public boolean add(SchCollectErrorLog schCollectErrorLog) {
return super.save(schCollectErrorLog);
}
/**
*
*
* @param schCollectErrorLog
* @return
*/
@Override
public boolean edit(SchCollectErrorLog schCollectErrorLog) {
return super.updateById(schCollectErrorLog);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectErrorLog> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectErrorLog> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectErrorLog::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollectErrorLog::getCreateTime, endTime);
}
//关键字比较多个列or
//if (!StringUtils.isEmpty(searchDTO.getKeyword())) {
//单个列用like
//query. like(SchCollectErrorLog::getxxx, searchDTO.getKeyword());
//多个列用like
//query. and(sub -> sub.like(SchCollectErrorLog::getxx1, searchDTO.getKeyword())
// оr(). like(SchCollectErrorLog::getXX2, searchDTO.getKeyword()))
//);
//}
//默认createTime倒序排序
query.orderByDesc(SchCollectErrorLog::getCreateTime);
List<SchCollectErrorLog> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,101 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import com.docus.server.infrastructure.dao.ISchCollectRecordDao;
import com.docus.server.infrastructure.mapper.SchCollectRecordMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectRecordDaoImpl extends BaseDaoImpl<SchCollectRecordMapper, SchCollectRecord> implements ISchCollectRecordDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectRecord findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectRecord
* @return
*/
@Override
public boolean add(SchCollectRecord schCollectRecord) {
return super.save(schCollectRecord);
}
/**
*
*
* @param schCollectRecord
* @return
*/
@Override
public boolean edit(SchCollectRecord schCollectRecord) {
return super.updateById(schCollectRecord);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectRecord> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectRecord> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectRecord::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
query.le(SchCollectRecord::getCreateTime, searchDTO.getEndTime());
}
Object collectorId = searchDTO.getParams("collectorId");
if (Func.isNotEmpty(collectorId)) {
query.eq(SchCollectRecord::getCollectorId, collectorId);
}
//默认createTime倒序排序
query.orderByDesc(SchCollectRecord::getCreateTime);
List<SchCollectRecord> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,100 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import com.docus.server.infrastructure.dao.ISchCollectRecordRetryLogDao;
import com.docus.server.infrastructure.mapper.SchCollectRecordRetryLogMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectRecordRetryLogDaoImpl extends BaseDaoImpl<SchCollectRecordRetryLogMapper, SchCollectRecordRetryLog> implements ISchCollectRecordRetryLogDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectRecordRetryLog findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectRecordRetryLog
* @return
*/
@Override
public boolean add(SchCollectRecordRetryLog schCollectRecordRetryLog) {
return super.save(schCollectRecordRetryLog);
}
/**
*
*
* @param schCollectRecordRetryLog
* @return
*/
@Override
public boolean edit(SchCollectRecordRetryLog schCollectRecordRetryLog) {
return super.updateById(schCollectRecordRetryLog);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectRecordRetryLog> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectRecordRetryLog> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectRecordRetryLog::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
query.le(SchCollectRecordRetryLog::getCreateTime, searchDTO.getEndTime());
}
Object collectorId = searchDTO.getParams("collectorId");
if (Func.isNotEmpty(collectorId)) {
query.eq(SchCollectRecordRetryLog::getCollectorId, collectorId);
}
//默认createTime倒序排序
query.orderByDesc(SchCollectRecordRetryLog::getCreateTime);
List<SchCollectRecordRetryLog> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,109 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorConfig;
import com.docus.server.infrastructure.dao.ISchCollectorConfigDao;
import com.docus.server.infrastructure.mapper.SchCollectorConfigMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectorConfigDaoImpl extends BaseDaoImpl<SchCollectorConfigMapper, SchCollectorConfig> implements ISchCollectorConfigDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorConfig findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectorConfig
* @return
*/
@Override
public boolean add(SchCollectorConfig schCollectorConfig) {
return super.save(schCollectorConfig);
}
/**
*
*
* @param schCollectorConfig
* @return
*/
@Override
public boolean edit(SchCollectorConfig schCollectorConfig) {
return super.updateById(schCollectorConfig);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorConfig> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectorConfig> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectorConfig::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollectorConfig::getCreateTime, endTime);
}
if (searchDTO.getParams("collectorId") != null && searchDTO.getParams("collectorId") != "") {
query.eq(SchCollectorConfig::getCollectorId, searchDTO.getParams("collectorId"));
}
if (searchDTO.getParams("configType") != null && searchDTO.getParams("configType") != "") {
query.eq(SchCollectorConfig::getConfigType, searchDTO.getParams("configType"));
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollectorConfig::getCreateTime, endTime);
}
//默认createTime倒序排序
query.orderByDesc(SchCollectorConfig::getCreateTime);
List<SchCollectorConfig> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,102 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollector;
import com.docus.server.infrastructure.dao.ISchCollectorDao;
import com.docus.server.infrastructure.mapper.SchCollectorMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectorDaoImpl extends BaseDaoImpl<SchCollectorMapper, SchCollector> implements ISchCollectorDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollector findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollector
* @return
*/
@Override
public boolean add(SchCollector schCollector) {
return super.save(schCollector);
}
/**
*
*
* @param schCollector
* @return
*/
@Override
public boolean edit(SchCollector schCollector) {
return super.updateById(schCollector);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollector> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollector> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollector::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollector::getCreateTime, endTime);
}
Object collectorId = searchDTO.getParams("collectorId");
if (Func.isNotEmpty(collectorId)) {
query.eq(SchCollector::getCollectorId, collectorId);
}
//默认createTime倒序排序
query.orderByDesc(SchCollector::getCreateTime);
List<SchCollector> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,117 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import com.docus.server.infrastructure.dao.ISchCollectorVersionDao;
import com.docus.server.infrastructure.mapper.SchCollectorVersionMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectorVersionDaoImpl extends BaseDaoImpl<SchCollectorVersionMapper, SchCollectorVersion> implements ISchCollectorVersionDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVersion findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectorVersion
* @return
*/
@Override
public boolean add(SchCollectorVersion schCollectorVersion) {
return super.save(schCollectorVersion);
}
/**
*
*
* @param schCollectorVersion
* @return
*/
@Override
public boolean edit(SchCollectorVersion schCollectorVersion) {
return super.updateById(schCollectorVersion);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVersion> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectorVersion> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectorVersion::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollectorVersion::getCreateTime, endTime);
}
Object collectorId = searchDTO.getParams("collectorId");
if (Func.isNotEmpty(collectorId)) {
query.eq(SchCollectorVersion::getCollectorId, collectorId);
}
//默认createTime倒序排序
query.orderByDesc(SchCollectorVersion::getCreateTime);
List<SchCollectorVersion> list = super.find(query);
return new PageResult<>(list);
}
@Override
public SchCollectorVersion findByVersion(Long collectorId, String collectorVersionNo) {
LambdaQueryWrapper<SchCollectorVersion> query = Wrappers.lambdaQuery();
if (Func.isNotEmpty(collectorId)) {
query.ge(SchCollectorVersion::getCollectorId, collectorId);
}
if (Func.isNotBlank(collectorVersionNo)) {
query.le(SchCollectorVersion::getCollectVersion, collectorVersionNo);
}
return super.findOne(query);
}
}

@ -1,112 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersionFile;
import com.docus.server.enums.CancelEnum;
import com.docus.server.infrastructure.dao.ISchCollectorVersionFileDao;
import com.docus.server.infrastructure.mapper.SchCollectorVersionFileMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectorVersionFileDaoImpl extends BaseDaoImpl<SchCollectorVersionFileMapper, SchCollectorVersionFile> implements ISchCollectorVersionFileDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVersionFile findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectorVersionFile
* @return
*/
@Override
public boolean add(SchCollectorVersionFile schCollectorVersionFile) {
return super.save(schCollectorVersionFile);
}
/**
*
*
* @param schCollectorVersionFile
* @return
*/
@Override
public boolean edit(SchCollectorVersionFile schCollectorVersionFile) {
return super.updateById(schCollectorVersionFile);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVersionFile> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectorVersionFile> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectorVersionFile::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollectorVersionFile::getCreateTime, endTime);
}
//默认createTime倒序排序
query.orderByDesc(SchCollectorVersionFile::getCreateTime);
List<SchCollectorVersionFile> list = super.find(query);
return new PageResult<>(list);
}
@Override
public SchCollectorVersionFile findByVersionIdAndCollectorId(Long collectorId, Long collectorVersionId) {
LambdaQueryWrapper<SchCollectorVersionFile> query = Wrappers.lambdaQuery();
if (Func.isNotEmpty(collectorId)) {
query.eq(SchCollectorVersionFile::getCollectorId, collectorId);
}
if (Func.isNotEmpty(collectorVersionId)) {
query.eq(SchCollectorVersionFile::getCollectorVersionId, collectorVersionId);
}
query.ne(SchCollectorVersionFile::getState, CancelEnum.CANCEL);
return super.findOne(query);
}
}

@ -1,100 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchCollectorVersionLog;
import com.docus.server.infrastructure.dao.ISchCollectorVersionLogDao;
import com.docus.server.infrastructure.mapper.SchCollectorVersionLogMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchCollectorVersionLogDaoImpl extends BaseDaoImpl<SchCollectorVersionLogMapper, SchCollectorVersionLog> implements ISchCollectorVersionLogDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchCollectorVersionLog findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schCollectorVersionLog
* @return
*/
@Override
public boolean add(SchCollectorVersionLog schCollectorVersionLog) {
return super.save(schCollectorVersionLog);
}
/**
*
*
* @param schCollectorVersionLog
* @return
*/
@Override
public boolean edit(SchCollectorVersionLog schCollectorVersionLog) {
return super.updateById(schCollectorVersionLog);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchCollectorVersionLog> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchCollectorVersionLog> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchCollectorVersionLog::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchCollectorVersionLog::getCreateTime, endTime);
}
Object collectorId = searchDTO.getParams("collectorId");
if (Func.isNotEmpty(collectorId)) {
query.eq(SchCollectorVersionLog::getCollectorId, collectorId);
}
//默认createTime倒序排序
query.orderByDesc(SchCollectorVersionLog::getCreateTime);
List<SchCollectorVersionLog> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,104 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchOperationLog;
import com.docus.server.infrastructure.dao.ISchOperationLogDao;
import com.docus.server.infrastructure.mapper.SchOperationLogMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchOperationLogDaoImpl extends BaseDaoImpl<SchOperationLogMapper, SchOperationLog> implements ISchOperationLogDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchOperationLog findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schOperationLog
* @return
*/
@Override
public boolean add(SchOperationLog schOperationLog) {
return super.save(schOperationLog);
}
/**
*
*
* @param schOperationLog
* @return
*/
@Override
public boolean edit(SchOperationLog schOperationLog) {
return super.updateById(schOperationLog);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchOperationLog> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchOperationLog> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchOperationLog::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchOperationLog::getCreateTime, endTime);
}
//关键字比较多个列or
//if (!StringUtils.isEmpty(searchDTO.getKeyword())) {
//单个列用like
//query. like(SchOperationLog::getxxx, searchDTO.getKeyword());
//多个列用like
//query. and(sub -> sub.like(SchOperationLog::getxx1, searchDTO.getKeyword())
// оr(). like(SchOperationLog::getXX2, searchDTO.getKeyword()))
//);
//}
//默认createTime倒序排序
query.orderByDesc(SchOperationLog::getCreateTime);
List<SchOperationLog> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,103 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.core.util.Func;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchSystemParams;
import com.docus.server.infrastructure.dao.ISchSystemParamsDao;
import com.docus.server.infrastructure.mapper.SchSystemParamsMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchSystemParamsDaoImpl extends BaseDaoImpl<SchSystemParamsMapper, SchSystemParams> implements ISchSystemParamsDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchSystemParams findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schSystemParams
* @return
*/
@Override
public boolean add(SchSystemParams schSystemParams) {
return super.save(schSystemParams);
}
/**
*
*
* @param schSystemParams
* @return
*/
@Override
public boolean edit(SchSystemParams schSystemParams) {
return super.updateById(schSystemParams);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchSystemParams> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchSystemParams> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchSystemParams::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchSystemParams::getCreateTime, endTime);
}
//分组查询系统参数表
String paramGroup = String.valueOf(searchDTO.getParams("paramGroup"));
if (Func.isNotBlank(paramGroup)) {
query.eq(SchSystemParams::getParamGroup, paramGroup);
}
//默认createTime倒序排序
query.orderByDesc(SchSystemParams::getCreateTime);
List<SchSystemParams> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,101 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchTerminator;
import com.docus.server.infrastructure.dao.ISchTerminatorDao;
import com.docus.server.infrastructure.mapper.SchTerminatorMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchTerminatorDaoImpl extends BaseDaoImpl<SchTerminatorMapper, SchTerminator> implements ISchTerminatorDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchTerminator findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schTerminator
* @return
*/
@Override
public boolean add(SchTerminator schTerminator) {
return super.save(schTerminator);
}
/**
*
*
* @param schTerminator
* @return
*/
@Override
public boolean edit(SchTerminator schTerminator) {
return super.updateById(schTerminator);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchTerminator> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchTerminator> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchTerminator::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchTerminator::getCreateTime, endTime);
}
//在线状态
if (searchDTO.getParams("onlineState") != null) {
query.eq(SchTerminator::getOnlineState, searchDTO.getParams("onlineState"));
}
//默认createTime倒序排序
query.orderByDesc(SchTerminator::getCreateTime);
List<SchTerminator> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,104 +0,0 @@
package com.docus.server.infrastructure.dao.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.docus.infrastructure.core.db.dao.impl.BaseDaoImpl;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.entity.scheduling.management.SchVirtualLog;
import com.docus.server.infrastructure.dao.ISchVirtualLogDao;
import com.docus.server.infrastructure.mapper.SchVirtualLogMapper;
import com.github.pagehelper.PageHelper;
import org.springframework.stereotype.Repository;
import java.util.Date;
import java.util.List;
/**
* 使 访
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Repository
public class SchVirtualLogDaoImpl extends BaseDaoImpl<SchVirtualLogMapper, SchVirtualLog> implements ISchVirtualLogDao {
/**
*
*
* @param id Id
* @return
*/
@Override
public SchVirtualLog findById(String id) {
return super.findById(id);
}
/**
*
*
* @param schVirtualLog
* @return
*/
@Override
public boolean add(SchVirtualLog schVirtualLog) {
return super.save(schVirtualLog);
}
/**
*
*
* @param schVirtualLog
* @return
*/
@Override
public boolean edit(SchVirtualLog schVirtualLog) {
return super.updateById(schVirtualLog);
}
/**
*
*
* @param ids ids
* @return
*/
@Override
public int delete(List<Long> ids) {
return super.deleteByIds(ids);
}
/**
*
*
* @param searchDTO
* @return
*/
@Override
public PageResult<SchVirtualLog> search(SearchDTO searchDTO) {
//分页
PageHelper.startPage(searchDTO.getPageNum(), searchDTO.getPageSize());
LambdaQueryWrapper<SchVirtualLog> query = Wrappers.lambdaQuery();
//时间范围默认按createTime
if (searchDTO.getBeginTime() != null) {
query.ge(SchVirtualLog::getCreateTime, searchDTO.getBeginTime());
}
if (searchDTO.getEndTime() != null) {
Date endTime = searchDTO.getEndTime();
query.le(SchVirtualLog::getCreateTime, endTime);
}
//关键字比较多个列or
//if (!StringUtils.isEmpty(searchDTO.getKeyword())) {
//单个列用like
//query. like(SchVirtualLog::getxxx, searchDTO.getKeyword());
//多个列用like
//query. and(sub -> sub.like(SchVirtualLog::getxx1, searchDTO.getKeyword())
// оr(). like(SchVirtualLog::getXX2, searchDTO.getKeyword()))
//);
//}
//默认createTime倒序排序
query.orderByDesc(SchVirtualLog::getCreateTime);
List<SchVirtualLog> list = super.find(query);
return new PageResult<>(list);
}
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectErrorLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectErrorLogMapper extends BaseMapper<SchCollectErrorLog> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectRecordMapper extends BaseMapper<SchCollectRecord> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectRecordRetryLogMapper extends BaseMapper<SchCollectRecordRetryLog> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectorConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorConfigMapper extends BaseMapper<SchCollectorConfig> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollector;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorMapper extends BaseMapper<SchCollector> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectorVersionFile;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorVersionFileMapper extends BaseMapper<SchCollectorVersionFile> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectorVersionLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorVersionLogMapper extends BaseMapper<SchCollectorVersionLog> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchCollectorVersionMapper extends BaseMapper<SchCollectorVersion> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchOperationLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchOperationLogMapper extends BaseMapper<SchOperationLog> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchSystemParams;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchSystemParamsMapper extends BaseMapper<SchSystemParams> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchTerminator;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchTerminatorMapper extends BaseMapper<SchTerminator> {
}

@ -1,17 +0,0 @@
package com.docus.server.infrastructure.mapper;
import com.docus.server.entity.scheduling.management.SchVirtualLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
*
* 使 Mapper
*
* @author AutoGenerator
* @since 2023-07-15
*/
@Mapper
public interface SchVirtualLogMapper extends BaseMapper<SchVirtualLog> {
}

@ -1,21 +0,0 @@
package com.docus.server.service;
import com.docus.server.dto.scheduling.management.schterminator.CommMsgDTO;
public interface ICommMsgService {
/**
* TCP
*
* @param commMsgDTO
*/
void clientCommand(CommMsgDTO commMsgDTO);
/**
* TCP
*
* @param commMsgDTO
*/
void clientsCommand(CommMsgDTO commMsgDTO);
}

@ -1,14 +0,0 @@
package com.docus.server.service;
import com.docus.server.vo.scheduling.management.schcollectorversionfile.UploadFileVO;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
public interface IFileUploadService {
List<UploadFileVO> uploadFile(MultipartFile[] multipartFiles, String pathKey) throws Exception;
void downloadFile(String filePath, HttpServletResponse response);
}

@ -1,58 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.AddSchCollectErrorLogDTO;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.DeleteSchCollectErrorLogDTO;
import com.docus.server.dto.scheduling.management.schcollecterrorlog.EditSchCollectErrorLogDTO;
import com.docus.server.vo.scheduling.management.schcollecterrorlog.SchCollectErrorLogVO;
import org.springframework.web.multipart.MultipartFile;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectErrorLogService {
/**
*
*
* @param id id
* @return
*/
SchCollectErrorLogVO findById(String id);
/**
*
*
* @param addSchCollectErrorLogDTO
* @param multipartFiles
* @return
*/
boolean add(AddSchCollectErrorLogDTO addSchCollectErrorLogDTO, MultipartFile[] multipartFiles) throws Exception;
/**
*
*
* @param editSchCollectErrorLogDTO
* @return
*/
boolean edit(EditSchCollectErrorLogDTO editSchCollectErrorLogDTO);
/**
*
*
* @param deleteSchCollectErrorLogDTO
* @return
*/
int delete(DeleteSchCollectErrorLogDTO deleteSchCollectErrorLogDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectErrorLogVO> search(SearchDTO searchDTO);
}

@ -1,61 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollector.task.ReportDownTwoDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.AddSchCollectRecordRetryLogDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.DeleteSchCollectRecordRetryLogDTO;
import com.docus.server.dto.scheduling.management.schcollectrecordretrylog.EditSchCollectRecordRetryLogDTO;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecordRetryLog;
import com.docus.server.vo.scheduling.management.schcollectrecordretrylog.SchCollectRecordRetryLogVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectRecordRetryLogService {
/**
*
*
* @param id id
* @return
*/
SchCollectRecordRetryLogVO findById(String id);
/**
*
*
* @param addSchCollectRecordRetryLogDTO
* @return
*/
SchCollectRecordRetryLog add(AddSchCollectRecordRetryLogDTO addSchCollectRecordRetryLogDTO);
/**
*
*
* @param editSchCollectRecordRetryLogDTO
* @return
*/
boolean edit(EditSchCollectRecordRetryLogDTO editSchCollectRecordRetryLogDTO);
/**
*
*
* @param deleteSchCollectRecordRetryLogDTO
* @return
*/
int delete(DeleteSchCollectRecordRetryLogDTO deleteSchCollectRecordRetryLogDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectRecordRetryLogVO> search(SearchDTO searchDTO);
SchCollectRecordRetryLog saveOrUpdateRecordRetryLog(NettyTerminatorDTO terminal, ReportDownTwoDTO reportDownTwoDTO);
}

@ -1,61 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollector.task.ReportDownTwoDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.AddSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.DeleteSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schcollectrecord.EditSchCollectRecordDTO;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.entity.scheduling.management.SchCollectRecord;
import com.docus.server.vo.scheduling.management.schcollectrecord.SchCollectRecordVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectRecordService {
/**
*
*
* @param id id
* @return
*/
SchCollectRecordVO findById(String id);
/**
*
*
* @param addSchCollectRecordDTO
* @return
*/
SchCollectRecord add(AddSchCollectRecordDTO addSchCollectRecordDTO);
/**
*
*
* @param editSchCollectRecordDTO
* @return
*/
boolean edit(EditSchCollectRecordDTO editSchCollectRecordDTO);
/**
*
*
* @param deleteSchCollectRecordDTO
* @return
*/
int delete(DeleteSchCollectRecordDTO deleteSchCollectRecordDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectRecordVO> search(SearchDTO searchDTO);
SchCollectRecord saveOrUpdateRecord(NettyTerminatorDTO terminal, ReportDownTwoDTO messageContent);
}

@ -1,61 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectorconfig.AddSchCollectorConfigDTO;
import com.docus.server.dto.scheduling.management.schcollectorconfig.DeleteSchCollectorConfigDTO;
import com.docus.server.dto.scheduling.management.schcollectorconfig.EditSchCollectorConfigDTO;
import com.docus.server.vo.scheduling.management.schcollectorconfig.SchCollectorConfigVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorConfigService {
/**
*
*
* @param id id
* @return
*/
SchCollectorConfigVO findById(String id);
/**
*
*
* @param addSchCollectorConfigDTO
* @return
*/
boolean add(AddSchCollectorConfigDTO addSchCollectorConfigDTO);
/**
*
*
* @param editSchCollectorConfigDTO
* @return
*/
boolean edit(EditSchCollectorConfigDTO editSchCollectorConfigDTO);
/**
*
*
* @param deleteSchCollectorConfigDTO
* @return
*/
int delete(DeleteSchCollectorConfigDTO deleteSchCollectorConfigDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorConfigVO> search(SearchDTO searchDTO);
/**
*
*/
void updateCollectorConfig();
}

@ -1,68 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollector.AddSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.DeleteSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.EditSchCollectorDTO;
import com.docus.server.dto.scheduling.management.schcollector.UpdateSchCollectorDTO;
import com.docus.server.entity.scheduling.management.SchCollector;
import com.docus.server.vo.scheduling.management.schcollector.SchCollectorVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorService {
/**
*
*
* @param id id
* @return
*/
SchCollectorVO findById(String id);
/**
*
*
* @param addSchCollectorDTO
* @return
*/
boolean add(AddSchCollectorDTO addSchCollectorDTO);
/**
*
*
* @param editSchCollectorDTO
* @return
*/
boolean edit(EditSchCollectorDTO editSchCollectorDTO);
/**
*
*
* @param deleteSchCollectorDTO
* @return
*/
int delete(DeleteSchCollectorDTO deleteSchCollectorDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVO> search(SearchDTO searchDTO);
/**
*
*
* @return
*/
boolean updateVersion(UpdateSchCollectorDTO schCollector);
SchCollector findByCollectorId(String collectorId);
}

@ -1,65 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.AddSchCollectorVersionFileDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.DeleteSchCollectorVersionFileDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionfile.EditSchCollectorVersionFileDTO;
import com.docus.server.entity.scheduling.management.SchCollectorVersionFile;
import com.docus.server.vo.scheduling.management.schcollectorversionfile.SchCollectorVersionFileVO;
import org.springframework.web.multipart.MultipartFile;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorVersionFileService {
/**
*
*
* @param id id
* @return
*/
SchCollectorVersionFileVO findById(String id);
/**
*
*
* @param addSchCollectorVersionFileDTO
* @return
*/
boolean add(AddSchCollectorVersionFileDTO addSchCollectorVersionFileDTO);
/**
*
*
* @param editSchCollectorVersionFileDTO
* @return
*/
boolean edit(EditSchCollectorVersionFileDTO editSchCollectorVersionFileDTO);
/**
*
*
* @param deleteSchCollectorVersionFileDTO
* @return
*/
int delete(DeleteSchCollectorVersionFileDTO deleteSchCollectorVersionFileDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVersionFileVO> search(SearchDTO searchDTO);
/**
*
*/
void addVersionAndFile(AddSchCollectorVersionFileDTO addSchCollectorVersionFileDTO, MultipartFile[] multipartFiles) throws Exception;
SchCollectorVersionFile findByCollectorIdAndVersionId(Long collectorId, Long collectorVersionId);
}

@ -1,56 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.AddSchCollectorVersionLogDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.DeleteSchCollectorVersionLogDTO;
import com.docus.server.dto.scheduling.management.schcollectorversionlog.EditSchCollectorVersionLogDTO;
import com.docus.server.vo.scheduling.management.schcollectorversionlog.SchCollectorVersionLogVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorVersionLogService {
/**
*
*
* @param id id
* @return
*/
SchCollectorVersionLogVO findById(String id);
/**
*
*
* @param addSchCollectorVersionLogDTO
* @return
*/
boolean add(AddSchCollectorVersionLogDTO addSchCollectorVersionLogDTO);
/**
*
*
* @param editSchCollectorVersionLogDTO
* @return
*/
boolean edit(EditSchCollectorVersionLogDTO editSchCollectorVersionLogDTO);
/**
*
*
* @param deleteSchCollectorVersionLogDTO
* @return
*/
int delete(DeleteSchCollectorVersionLogDTO deleteSchCollectorVersionLogDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVersionLogVO> search(SearchDTO searchDTO);
}

@ -1,65 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schcollectorversion.AddSchCollectorVersionDTO;
import com.docus.server.dto.scheduling.management.schcollectorversion.DeleteSchCollectorVersionDTO;
import com.docus.server.dto.scheduling.management.schcollectorversion.EditSchCollectorVersionDTO;
import com.docus.server.entity.scheduling.management.SchCollectorVersion;
import com.docus.server.vo.scheduling.management.schcollectorversion.SchCollectorVersionVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchCollectorVersionService {
/**
*
*
* @param id id
* @return
*/
SchCollectorVersionVO findById(String id);
/**
*
*
* @param addSchCollectorVersionDTO
* @return
*/
boolean add(AddSchCollectorVersionDTO addSchCollectorVersionDTO);
/**
*
*
* @param editSchCollectorVersionDTO
* @return
*/
boolean edit(EditSchCollectorVersionDTO editSchCollectorVersionDTO);
/**
*
*
* @param deleteSchCollectorVersionDTO
* @return
*/
int delete(DeleteSchCollectorVersionDTO deleteSchCollectorVersionDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchCollectorVersionVO> search(SearchDTO searchDTO);
/**
*
* @param collectorId
* @param collectorVersionNo
* @return
*/
SchCollectorVersion findByVersion(Long collectorId, String collectorVersionNo);
}

@ -1,56 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schoperationlog.AddSchOperationLogDTO;
import com.docus.server.dto.scheduling.management.schoperationlog.DeleteSchOperationLogDTO;
import com.docus.server.dto.scheduling.management.schoperationlog.EditSchOperationLogDTO;
import com.docus.server.vo.scheduling.management.schoperationlog.SchOperationLogVO;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchOperationLogService {
/**
*
*
* @param id id
* @return
*/
SchOperationLogVO findById(String id);
/**
*
*
* @param addSchOperationLogDTO
* @return
*/
boolean add(AddSchOperationLogDTO addSchOperationLogDTO);
/**
*
*
* @param editSchOperationLogDTO
* @return
*/
boolean edit(EditSchOperationLogDTO editSchOperationLogDTO);
/**
*
*
* @param deleteSchOperationLogDTO
* @return
*/
int delete(DeleteSchOperationLogDTO deleteSchOperationLogDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchOperationLogVO> search(SearchDTO searchDTO);
}

@ -1,69 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schsystemparams.AddSchSystemParamsDTO;
import com.docus.server.dto.scheduling.management.schsystemparams.DeleteSchSystemParamsDTO;
import com.docus.server.dto.scheduling.management.schsystemparams.EditSchSystemParamsDTO;
import com.docus.server.entity.scheduling.management.SchSystemParams;
import com.docus.server.vo.scheduling.management.schsystemparams.SchSystemParamsVO;
import java.util.List;
import java.util.Map;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchSystemParamsService {
/**
*
*
* @param id id
* @return
*/
SchSystemParamsVO findById(String id);
/**
*
*
* @param addSchSystemParamsDTO
* @return
*/
boolean add(AddSchSystemParamsDTO addSchSystemParamsDTO);
/**
*
*
* @param editSchSystemParamsDTO
* @return
*/
boolean edit(EditSchSystemParamsDTO editSchSystemParamsDTO);
/**
*
*
* @param deleteSchSystemParamsDTO
* @return
*/
int delete(DeleteSchSystemParamsDTO deleteSchSystemParamsDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchSystemParamsVO> search(SearchDTO searchDTO);
/**
* id
*
* @param paramValueIds ids
* @return Map<String, SchSystemParams>
*/
Map<String, SchSystemParams> find(List<Long> paramValueIds);
}

@ -1,72 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schterminator.AddSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.DeleteSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.EditSchTerminatorDTO;
import com.docus.server.dto.scheduling.management.schterminator.NettyTerminatorDTO;
import com.docus.server.entity.scheduling.management.SchTerminator;
import com.docus.server.vo.scheduling.management.schterminator.SchTerminatorVO;
import java.util.List;
/**
*
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchTerminatorService {
/**
*
*
* @param id id
* @return
*/
SchTerminatorVO findById(String id);
/**
*
*
* @param addSchTerminatorDTO
* @return
*/
boolean add(AddSchTerminatorDTO addSchTerminatorDTO);
/**
*
*
* @param editSchTerminatorDTO
* @return
*/
boolean edit(EditSchTerminatorDTO editSchTerminatorDTO);
/**
*
*
* @param deleteSchTerminatorDTO
* @return
*/
int delete(DeleteSchTerminatorDTO deleteSchTerminatorDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchTerminatorVO> search(SearchDTO searchDTO);
/**
*
* @param terminatorIp
* @param nettyTerminatorDTO
* @return
*/
SchTerminatorVO saveOrUpdate(String terminatorIp, NettyTerminatorDTO nettyTerminatorDTO);
List<SchTerminator> findAll();
void batchUpdate(List<SchTerminator> terminators);
}

@ -1,56 +0,0 @@
package com.docus.server.service;
import com.docus.infrastructure.web.request.SearchDTO;
import com.docus.infrastructure.web.response.PageResult;
import com.docus.server.dto.scheduling.management.schvirtuallog.AddSchVirtualLogDTO;
import com.docus.server.dto.scheduling.management.schvirtuallog.DeleteSchVirtualLogDTO;
import com.docus.server.dto.scheduling.management.schvirtuallog.EditSchVirtualLogDTO;
import com.docus.server.vo.scheduling.management.schvirtuallog.SchVirtualLogVO;
/**
* 使
*
* @author AutoGenerator
* @since 2023-07-15
*/
public interface ISchVirtualLogService {
/**
*
*
* @param id id
* @return
*/
SchVirtualLogVO findById(String id);
/**
*
*
* @param addSchVirtualLogDTO
* @return
*/
boolean add(AddSchVirtualLogDTO addSchVirtualLogDTO);
/**
*
*
* @param editSchVirtualLogDTO
* @return
*/
boolean edit(EditSchVirtualLogDTO editSchVirtualLogDTO);
/**
*
*
* @param deleteSchVirtualLogDTO
* @return
*/
int delete(DeleteSchVirtualLogDTO deleteSchVirtualLogDTO);
/**
*
*
* @param searchDTO
* @return
*/
PageResult<SchVirtualLogVO> search(SearchDTO searchDTO);
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save