feat: 增加设备与任务中心的映射表，通过分页返回最后执行时间

@@ -5,7 +5,6 @@ import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.quartz.SchedulerException;
 import org.quartz.SchedulerException;
-import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.bind.annotation.*;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
@@ -37,13 +36,14 @@ public class TkTaskCenterController extends BaseController {
   @GetMapping(
   @GetMapping(
       name = "page",
       name = "page",
       params = {PAGE_SIZE, PAGE})
       params = {PAGE_SIZE, PAGE})
-  public TkPageData<TkTaskCenterDTO> pageDevice(
+  public TkPageData<TkTaskCenterDTO> page(
       @RequestParam(PAGE_SIZE) int pageSize,
       @RequestParam(PAGE_SIZE) int pageSize,
       @RequestParam(PAGE) int page,
       @RequestParam(PAGE) int page,
       @RequestParam(value = "state", required = false) Integer state,
       @RequestParam(value = "state", required = false) Integer state,
       @RequestParam(value = "targetType", required = false) TargetTypeEnum targetType,
       @RequestParam(value = "targetType", required = false) TargetTypeEnum targetType,
       @RequestParam(value = ORDER_FILED, required = false) String orderBy,
       @RequestParam(value = ORDER_FILED, required = false) String orderBy,
-      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType)
+      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType,
+      @RequestParam(value = "tbDeviceId", required = false) String tbDeviceId)
       throws ThingsboardException {
       throws ThingsboardException {
     HashMap<String, Object> queryMap = new HashMap<>();
     HashMap<String, Object> queryMap = new HashMap<>();
     queryMap.put(PAGE_SIZE, pageSize);
     queryMap.put(PAGE_SIZE, pageSize);
@@ -52,13 +52,17 @@ public class TkTaskCenterController extends BaseController {
     queryMap.put(ORDER_TYPE, orderType);
     queryMap.put(ORDER_TYPE, orderType);
     queryMap.put("state", state);
     queryMap.put("state", state);
     queryMap.put("targetType", targetType);
     queryMap.put("targetType", targetType);
+    if (!StringUtils.isEmpty(tbDeviceId)) {
+      queryMap.put("tbDeviceId", tbDeviceId);
+    }
     return tkTaskCenterService.taskCenterPage(queryMap, getCurrentUser().getCurrentTenantId());
     return tkTaskCenterService.taskCenterPage(queryMap, getCurrentUser().getCurrentTenantId());
   }
   }
 
 
   @PostMapping("/add")
   @PostMapping("/add")
   @ApiOperation(value = "新增任务中心")
   @ApiOperation(value = "新增任务中心")
-//  @PreAuthorize(
-//      "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:add:post'})")
+  //  @PreAuthorize(
+  //
+  // "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:add:post'})")
   public ResponseResult<TkTaskCenterDTO> save(
   public ResponseResult<TkTaskCenterDTO> save(
       @RequestBody @Validated(AddGroup.class) TkTaskCenterDTO taskCenter)
       @RequestBody @Validated(AddGroup.class) TkTaskCenterDTO taskCenter)
       throws ThingsboardException, SchedulerException {
       throws ThingsboardException, SchedulerException {
@@ -69,8 +73,9 @@ public class TkTaskCenterController extends BaseController {
   }
   }
 
 
   @PutMapping("/update")
   @PutMapping("/update")
-//  @PreAuthorize(
-//      "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:update:update'})")
+  //  @PreAuthorize(
+  //
+  // "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:update:update'})")
   @ApiOperation(value = "编辑任务中心")
   @ApiOperation(value = "编辑任务中心")
   public ResponseResult<TkTaskCenterDTO> update(
   public ResponseResult<TkTaskCenterDTO> update(
       @RequestBody @Validated(UpdateGroup.class) TkTaskCenterDTO taskCenter)
       @RequestBody @Validated(UpdateGroup.class) TkTaskCenterDTO taskCenter)
@@ -82,8 +87,9 @@ public class TkTaskCenterController extends BaseController {
   }
   }
 
 
   @PutMapping("/{id}/update/{state}")
   @PutMapping("/{id}/update/{state}")
-//  @PreAuthorize(
-//      "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:update:update'})")
+  //  @PreAuthorize(
+  //
+  // "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:update:update'})")
   @ApiOperation(value = "更新状态")
   @ApiOperation(value = "更新状态")
   public ResponseResult<Boolean> updateState(
   public ResponseResult<Boolean> updateState(
       @PathVariable("id") String id, @PathVariable("state") Integer state)
       @PathVariable("id") String id, @PathVariable("state") Integer state)
@@ -96,8 +102,8 @@ public class TkTaskCenterController extends BaseController {
   }
   }
 
 
   @DeleteMapping
   @DeleteMapping
-//  @PreAuthorize(
-//      "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:delete'})")
+  //  @PreAuthorize(
+  //      "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:delete'})")
   @ApiOperation(value = "删除任务中心")
   @ApiOperation(value = "删除任务中心")
   public ResponseResult<Boolean> deleteTaskCenter(@RequestBody DeleteDTO deleteDTO)
   public ResponseResult<Boolean> deleteTaskCenter(@RequestBody DeleteDTO deleteDTO)
       throws ThingsboardException, SchedulerException {
       throws ThingsboardException, SchedulerException {
@@ -105,18 +111,22 @@ public class TkTaskCenterController extends BaseController {
     return ResponseResult.success(tkTaskCenterService.deleteTaskCenter(deleteDTO));
     return ResponseResult.success(tkTaskCenterService.deleteTaskCenter(deleteDTO));
   }
   }
 
 
-  @PutMapping("/{id}/cancel/{tbDeviceId}")
-//  @PreAuthorize(
-//          "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:cancel'})")
-  @ApiOperation(value = "设备取消任务执行")
-  public ResponseResult<Boolean> cancelExecute(
-      @PathVariable("id") String taskId, @PathVariable("tbDeviceId") String tbDeviceId)throws ThingsboardException {
-    if(StringUtils.isEmpty(taskId) || StringUtils.isEmpty(tbDeviceId)){
+  @PutMapping("/{id}/update/{tbDeviceId}/{allow}")
+  //  @PreAuthorize(
+  //
+  // "@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{'api:yt:task_center:cancel'})")
+  @ApiOperation(value = "设备更新任务执行")
+  public ResponseResult<Boolean> cancelOrAllowExecute(
+      @PathVariable("id") String taskId,
+      @PathVariable("tbDeviceId") String tbDeviceId,
+      @PathVariable("allow") boolean allow)
+      throws ThingsboardException {
+    if (StringUtils.isEmpty(taskId) || StringUtils.isEmpty(tbDeviceId)) {
       throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
       throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
     }
     }
     return ResponseResult.success(
     return ResponseResult.success(
-        tkTaskCenterService.cancelExecute(
-            taskId, tbDeviceId, getCurrentUser().getCurrentTenantId()));
+        tkTaskCenterService.cancelOrAllowExecute(
+            taskId, tbDeviceId, getCurrentUser().getCurrentTenantId(), allow));
   }
   }
 
 
   private TkTaskCenterDTO saveOrUpdate(TkTaskCenterDTO tkTaskCenterDTO)
   private TkTaskCenterDTO saveOrUpdate(TkTaskCenterDTO tkTaskCenterDTO)

@@ -16,6 +16,7 @@ import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.rpc.ToDeviceRpcRequestBody;
 import org.thingsboard.server.common.data.rpc.ToDeviceRpcRequestBody;
 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.cache.CacheUtils;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.task.TargetContentDTO;
 import org.thingsboard.server.common.data.yunteng.dto.task.TargetContentDTO;
 import org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO;
 import org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO;
@@ -25,6 +26,8 @@ import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
 import org.thingsboard.server.dao.yunteng.service.TkTaskCenterService;
 import org.thingsboard.server.dao.yunteng.service.TkTaskCenterService;
 import org.thingsboard.server.service.rpc.TbCoreDeviceRpcService;
 import org.thingsboard.server.service.rpc.TbCoreDeviceRpcService;
 import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.security.model.SecurityUser;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 import java.util.*;
 import java.util.*;
 
 
 @Component("rpcCommandTask")
 @Component("rpcCommandTask")
@@ -40,6 +43,8 @@ public class RpcCommandTask {
   private final TkTaskCenterService tkTaskCenterService;
   private final TkTaskCenterService tkTaskCenterService;
   private final TbCoreDeviceRpcService tbCoreDeviceRpcService;
   private final TbCoreDeviceRpcService tbCoreDeviceRpcService;
   private final TkDeviceService tkDeviceService;
   private final TkDeviceService tkDeviceService;
+  private final CacheUtils cacheUtils;
+
   public void process(String taskCenterId) {
   public void process(String taskCenterId) {
     // 通过任务中心ID查询执行命令及执行对象
     // 通过任务中心ID查询执行命令及执行对象
     ListenableFuture<TkTaskCenterDTO> future =
     ListenableFuture<TkTaskCenterDTO> future =
@@ -57,6 +62,15 @@ public class RpcCommandTask {
               // send cmd
               // send cmd
               if (targetContent.getData() != null && null != cmdJsonNode) {
               if (targetContent.getData() != null && null != cmdJsonNode) {
                 String tenantId = tkTaskCenterDTO.getTenantId();
                 String tenantId = tkTaskCenterDTO.getTenantId();
+                String cacheName = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS;
+                String key =
+                    FastIotConstants.CacheConfigKey.TASK_CENTER_EXECUTE_TIME
+                        + "_"
+                        + tkTaskCenterDTO.getId();
+                cacheUtils.put(
+                    cacheName,
+                    key,
+                    LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
                 if (targetType.equals(TargetTypeEnum.DEVICES)) {
                 if (targetType.equals(TargetTypeEnum.DEVICES)) {
                   for (String deviceId : targetContent.getData()) {
                   for (String deviceId : targetContent.getData()) {
                     sendRpcCommand(cmdJsonNode, tenantId, deviceId, securityUser);
                     sendRpcCommand(cmdJsonNode, tenantId, deviceId, securityUser);
@@ -82,7 +96,7 @@ public class RpcCommandTask {
     for (String deviceProfileId : targetContent.getData()) {
     for (String deviceProfileId : targetContent.getData()) {
       Futures.addCallback(
       Futures.addCallback(
           tkDeviceService.findDeviceListByDeviceProfileId(deviceProfileId, tenantId),
           tkDeviceService.findDeviceListByDeviceProfileId(deviceProfileId, tenantId),
-          new FutureCallback<List<DeviceDTO>>() {
+          new FutureCallback<>() {
             @Override
             @Override
             public void onSuccess(@Nullable List<DeviceDTO> deviceDTOS) {
             public void onSuccess(@Nullable List<DeviceDTO> deviceDTOS) {
               if (null != deviceDTOS && !deviceDTOS.isEmpty()) {
               if (null != deviceDTOS && !deviceDTOS.isEmpty()) {
@@ -125,7 +139,7 @@ public class RpcCommandTask {
             true,
             true,
             System.currentTimeMillis() + Math.max(minTimeout, defaultTimeout),
             System.currentTimeMillis() + Math.max(minTimeout, defaultTimeout),
             body,
             body,
-            false,
+            true,
             null,
             null,
             null);
             null);
     tbCoreDeviceRpcService.processRestApiRpcRequest(
     tbCoreDeviceRpcService.processRestApiRpcRequest(

@@ -27,7 +27,8 @@ public interface FastIotConstants {
     String MOBILE_LOGIN_SMS_CODE = "mobileLoginSmsCode";
     String MOBILE_LOGIN_SMS_CODE = "mobileLoginSmsCode";
     String AREA = "thingsArea";
     String AREA = "thingsArea";
     String PUBLIC_ID = "publicId_";
     String PUBLIC_ID = "publicId_";
-    String TASK_CENTER_INFOS = "taskCenterInfos_";
+    String TASK_CENTER_INFOS = "taskCenterInfos";
+    String TASK_CENTER_EXECUTE_TIME = "taskCenterExecuteTime";
   }
   }
 
 
   interface TBCacheConfig {
   interface TBCacheConfig {

@@ -120,6 +120,8 @@ public final class ModelConstants {
     public static final String TK_DEVICE_STATE_LOG = "tk_device_state_log";
     public static final String TK_DEVICE_STATE_LOG = "tk_device_state_log";
     /** 任务中心表 */
     /** 任务中心表 */
     public static final String TK_TASK_CENTER_NAME = "tk_task_center";
     public static final String TK_TASK_CENTER_NAME = "tk_task_center";
+    /** 设备与任务中心映射表 */
+    public static final String TK_DEVICE_TASK_CENTER_NAME = "tk_device_task_center";
   }
   }
 
 
   public static class TableFields {
   public static class TableFields {

@@ -19,6 +19,6 @@ public class TargetContentDTO {
   @ApiModelProperty(value = "设备配置ID")
   @ApiModelProperty(value = "设备配置ID")
   String deviceProfileId;
   String deviceProfileId;
 
 
-  @ApiModelProperty(value = "取消执行的数据：只有目标类型是产品时才会有值,且List<String>里面为tbDeviceId")
+  @ApiModelProperty(value = "取消执行的数据：key为产品ID即deviceProfileId,value为List<String>里面为tbDeviceId")
   Map<String, List<String>> cancelExecuteDevices;
   Map<String, List<String>> cancelExecuteDevices;
 }
 }

+package org.thingsboard.server.common.data.yunteng.dto.task;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.dto.BaseDTO;
+
+@Data
+public class TkDeviceTaskCenterDTO extends BaseDTO {
+  @ApiModelProperty(value = "设备ID")
+  private String tbDeviceId;
+
+  @ApiModelProperty(value = "任务中心ID")
+  private String taskCenterId;
+
+  @ApiModelProperty(value = "是否允许执行：0不执行 1允许执行")
+  private Integer state;
+
+  @ApiModelProperty(value = "租户ID")
+  private String tenantId;
+}

@@ -33,9 +33,14 @@ public class TkTaskCenterDTO extends TenantDTO {
   @NotNull(message = "执行时间不能为空", groups = AddGroup.class)
   @NotNull(message = "执行时间不能为空", groups = AddGroup.class)
   private TaskExecuteTimeDTO executeTime;
   private TaskExecuteTimeDTO executeTime;
 
 
-  @ApiModelProperty(value = "0禁用 1启用")
+  @ApiModelProperty(value = "状态：0禁用 1启用")
   private Integer state = FastIotConstants.StateValue.DISABLE;
   private Integer state = FastIotConstants.StateValue.DISABLE;
 
 
+  @ApiModelProperty(value = "最后执行时间")
+  private Long lastExecuteTime;
+
+  private TkDeviceTaskCenterDTO tkDeviceTaskCenter;
+
   @ApiModelProperty(value = "备注")
   @ApiModelProperty(value = "备注")
   private String remark;
   private String remark;
 }
 }

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+@TableName(value = ModelConstants.Table.TK_DEVICE_TASK_CENTER_NAME)
+public class TkDeviceTaskCenterEntity extends TenantBaseEntity {
+
+  private static final long serialVersionUID = -5425391296429906856L;
+  private String tbDeviceId;
+
+  private String taskCenterId;
+
+  private Integer state;
+}

@@ -2,6 +2,8 @@ package org.thingsboard.server.dao.yunteng.impl;
 
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -17,6 +19,7 @@ import org.thingsboard.server.dao.yunteng.entities.SysJobLogEntity;
 import org.thingsboard.server.dao.yunteng.mapper.SysJobLogMapper;
 import org.thingsboard.server.dao.yunteng.mapper.SysJobLogMapper;
 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
 import org.thingsboard.server.dao.yunteng.service.TkSysJobLogService;
 import org.thingsboard.server.dao.yunteng.service.TkSysJobLogService;
+import java.time.ZoneOffset;
 import java.util.Map;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Optional;
 
 
@@ -61,9 +64,7 @@ public class SysJobLogServiceImpl extends AbstractBaseService<SysJobLogMapper, S
               }
               }
             })
             })
         .orElseThrow(
         .orElseThrow(
-            () -> {
-              throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
-            });
+            () -> new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage()));
   }
   }
 
 
   @Override
   @Override
@@ -77,9 +78,7 @@ public class SysJobLogServiceImpl extends AbstractBaseService<SysJobLogMapper, S
       Optional.ofNullable(sysJobLog)
       Optional.ofNullable(sysJobLog)
           .map(job -> baseMapper.updateById(jobLog))
           .map(job -> baseMapper.updateById(jobLog))
           .orElseThrow(
           .orElseThrow(
-              () -> {
-                throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
-              });
+              () -> new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage()));
     }
     }
     return jobLogDTO;
     return jobLogDTO;
   }
   }
@@ -109,4 +108,21 @@ public class SysJobLogServiceImpl extends AbstractBaseService<SysJobLogMapper, S
     }
     }
     return result;
     return result;
   }
   }
+
+  @Override
+  public ListenableFuture<Long> findLastLogEndTimeByJobId(String jobId, String jobGroup) {
+    SysJobLogEntity entity =
+        baseMapper.selectOne(
+            new LambdaQueryWrapper<SysJobLogEntity>()
+                .eq(SysJobLogEntity::getJobId, jobId)
+                .eq(SysJobLogEntity::getJobGroup, jobGroup)
+                .orderBy(true, false, SysJobLogEntity::getEndTime)
+                .last("limit 1"));
+    return Optional.ofNullable(entity)
+        .map(
+            obj ->
+                Futures.immediateFuture(
+                    obj.getEndTime().toInstant(ZoneOffset.of("+8")).toEpochMilli()))
+        .orElse(Futures.immediateFuture(null));
+  }
 }
 }

@@ -2,17 +2,23 @@ package org.thingsboard.server.dao.yunteng.impl;
 
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.NotNull;
 import org.quartz.*;
 import org.quartz.*;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.cache.CacheUtils;
 import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
 import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
 import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
 import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
 import org.thingsboard.server.common.data.yunteng.dto.*;
 import org.thingsboard.server.common.data.yunteng.dto.*;
+import org.thingsboard.server.common.data.yunteng.enums.JobGroupEnum;
 import org.thingsboard.server.common.data.yunteng.enums.StatusEnum;
 import org.thingsboard.server.common.data.yunteng.enums.StatusEnum;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.dao.util.yunteng.CronUtils;
 import org.thingsboard.server.dao.util.yunteng.CronUtils;
@@ -32,24 +38,31 @@ import java.util.stream.Collectors;
 public class SysJobServiceImpl extends AbstractBaseService<SysJobMapper, SysJobEntity>
 public class SysJobServiceImpl extends AbstractBaseService<SysJobMapper, SysJobEntity>
     implements TkSysJobService {
     implements TkSysJobService {
   private final Scheduler scheduler;
   private final Scheduler scheduler;
-
+  private final SysJobLogServiceImpl sysJobLogService;
+  private final CacheUtils cacheUtils;
   /** 项目启动时，初始化定时器 主要是防止手动修改数据库导致未同步到定时任务处理（注：不能手动修改数据库ID和任务组名，否则会导致脏数据） */
   /** 项目启动时，初始化定时器 主要是防止手动修改数据库导致未同步到定时任务处理（注：不能手动修改数据库ID和任务组名，否则会导致脏数据） */
   @PostConstruct
   @PostConstruct
   public void init() throws SchedulerException {
   public void init() throws SchedulerException {
     scheduler.clear();
     scheduler.clear();
-    List<SysJobEntity> jobList = new ArrayList<>();
     try {
     try {
-      jobList.addAll(
-          baseMapper.selectList(
-              new LambdaQueryWrapper<SysJobEntity>()
-                  .eq(SysJobEntity::getStatus, StatusEnum.ENABLE.getIndex())));
+      List<SysJobEntity> jobList =
+          new ArrayList<>(baseMapper.selectList(new LambdaQueryWrapper<>()));
+      List<SysJobEntity> enableJobs = new ArrayList<>();
+      for (SysJobEntity job : jobList) {
+        if (Objects.equals(job.getStatus(),StatusEnum.ENABLE.getIndex())) {
+          enableJobs.add(job);
+        }
+        if (Objects.equals(job.getJobGroup(), JobGroupEnum.TASK_CENTER.name())) {
+          // 查询任务中心的最新执行时间放在缓存里面
+          queryJobLastExecuteTime(job.getSourceId(), job.getId(), job.getJobGroup());
+        }
+      }
+      for (SysJobEntity job : enableJobs) {
+        ScheduleUtils.createScheduleJob(scheduler, job);
+      }
     } catch (Exception e) {
     } catch (Exception e) {
       // TODO: 兼容ThingsboardInstallApplication。执行数据库脚本前，会跑表不存在异常。
       // TODO: 兼容ThingsboardInstallApplication。执行数据库脚本前，会跑表不存在异常。
     }
     }
-
-    for (SysJobEntity job : jobList) {
-      ScheduleUtils.createScheduleJob(scheduler, job);
-    }
   }
   }
 
 
   @Override
   @Override
@@ -297,4 +310,22 @@ public class SysJobServiceImpl extends AbstractBaseService<SysJobMapper, SysJobE
         .map(obj -> obj.getDTO(SysJobDTO.class))
         .map(obj -> obj.getDTO(SysJobDTO.class))
         .orElse(null);
         .orElse(null);
   }
   }
+
+  private void queryJobLastExecuteTime(String sourceId, String jobId, String jobGroup) {
+    ListenableFuture<Long> future = sysJobLogService.findLastLogEndTimeByJobId(jobId, jobGroup);
+    Futures.addCallback(
+        future,
+        new FutureCallback<>() {
+          @Override
+          public void onSuccess(@Nullable Long executeTime) {
+            String cacheName = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS;
+            String key = FastIotConstants.CacheConfigKey.TASK_CENTER_EXECUTE_TIME + "_" + sourceId;
+            cacheUtils.put(cacheName, key, executeTime);
+          }
+
+          @Override
+          public void onFailure(@NotNull Throwable throwable) {}
+        },
+        MoreExecutors.directExecutor());
+  }
 }
 }

@@ -613,9 +613,7 @@ public class TkDeviceServiceImpl extends AbstractBaseService<DeviceMapper, TkDev
     return Optional.ofNullable(device)
     return Optional.ofNullable(device)
         .map(obj -> obj.getDTO(DeviceDTO.class))
         .map(obj -> obj.getDTO(DeviceDTO.class))
         .orElseThrow(
         .orElseThrow(
-            () -> {
-              throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
-            });
+            () -> new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage()));
   }
   }
 
 
   @Override
   @Override
@@ -710,4 +708,19 @@ public class TkDeviceServiceImpl extends AbstractBaseService<DeviceMapper, TkDev
                         .collect(Collectors.toList())))
                         .collect(Collectors.toList())))
         .orElse(Futures.immediateFuture(devices));
         .orElse(Futures.immediateFuture(devices));
   }
   }
+
+  @Override
+  public List<String> findTbDeviceIdsByDeviceProfileId(String deviceProfileId, String tenantId) {
+    if (StringUtils.isEmpty(deviceProfileId) || StringUtils.isEmpty(tenantId)) {
+      throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    return Optional.ofNullable(
+            baseMapper.selectList(
+                new LambdaQueryWrapper<TkDeviceEntity>()
+                    .eq(TkDeviceEntity::getTenantId, tenantId)
+                    .eq(TkDeviceEntity::getDeviceProfileId, deviceProfileId)
+                    .select(TkDeviceEntity::getTbDeviceId)))
+        .map(list -> list.stream().map(TkDeviceEntity::getTbDeviceId).collect(Collectors.toList()))
+        .orElse(null);
+  }
 }
 }

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.task.TkDeviceTaskCenterDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceTaskCenterEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkDeviceTaskCenterMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceTaskCenterService;
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class TkDeviceTaskCenterServiceImpl
+    extends AbstractBaseService<TkDeviceTaskCenterMapper, TkDeviceTaskCenterEntity>
+    implements TkDeviceTaskCenterService {
+  @Override
+  @Transactional
+  public TkDeviceTaskCenterDTO saveOrUpdate(TkDeviceTaskCenterDTO tkDeviceTaskCenterDTO) {
+    TkDeviceTaskCenterEntity entity =
+        tkDeviceTaskCenterDTO.getEntity(TkDeviceTaskCenterEntity.class);
+    if (StringUtils.isEmpty(tkDeviceTaskCenterDTO.getId())) {
+      baseMapper.insert(entity);
+    } else {
+      baseMapper.updateById(entity);
+    }
+    return tkDeviceTaskCenterDTO;
+  }
+
+  @Override
+  @Transactional
+  public boolean delete(DeleteDTO delete) {
+    return baseMapper.deleteBatchIds(delete.getIds()) > FastIotConstants.MagicNumber.ZERO;
+  }
+
+  @Override
+  public boolean updateStateByTbDeviceIdAndTaskCenterId(
+      String tenantId, String taskCenterId, String tbDeviceId, Integer state) {
+    TkDeviceTaskCenterEntity entity =
+        baseMapper.selectOne(
+            new LambdaQueryWrapper<TkDeviceTaskCenterEntity>()
+                .eq(TkDeviceTaskCenterEntity::getTbDeviceId, tbDeviceId)
+                .eq(TkDeviceTaskCenterEntity::getTaskCenterId, taskCenterId)
+                .eq(TkDeviceTaskCenterEntity::getTenantId, tenantId));
+    if (null != entity) {
+      entity.setState(state);
+      baseMapper.updateById(entity);
+    }
+    return false;
+  }
+
+  @Override
+  public boolean deleteByTaskCenterId(String tenantId, String taskCenterId) {
+    return baseMapper.delete(
+            new LambdaQueryWrapper<TkDeviceTaskCenterEntity>()
+                .eq(TkDeviceTaskCenterEntity::getTenantId, tenantId)
+                .eq(TkDeviceTaskCenterEntity::getTaskCenterId, taskCenterId))
+        > FastIotConstants.MagicNumber.ZERO;
+  }
+
+  @Override
+  @Transactional
+  public boolean insertBatch(List<TkDeviceTaskCenterEntity> list) {
+    return insertBatch(list, list.size());
+  }
+}

@@ -17,68 +17,49 @@ import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
 import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
 import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.SysJobDTO;
 import org.thingsboard.server.common.data.yunteng.dto.SysJobDTO;
-import org.thingsboard.server.common.data.yunteng.dto.task.TargetContentDTO;
-import org.thingsboard.server.common.data.yunteng.dto.task.TaskExecuteTimeDTO;
-import org.thingsboard.server.common.data.yunteng.dto.task.TaskTypeDTO;
-import org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO;
+import org.thingsboard.server.common.data.yunteng.dto.task.*;
 import org.thingsboard.server.common.data.yunteng.enums.JobGroupEnum;
 import org.thingsboard.server.common.data.yunteng.enums.JobGroupEnum;
+import org.thingsboard.server.common.data.yunteng.enums.StatusEnum;
 import org.thingsboard.server.common.data.yunteng.enums.TargetTypeEnum;
 import org.thingsboard.server.common.data.yunteng.enums.TargetTypeEnum;
 import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
 import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceTaskCenterEntity;
 import org.thingsboard.server.dao.yunteng.entities.TkTaskCenterEntity;
 import org.thingsboard.server.dao.yunteng.entities.TkTaskCenterEntity;
-import org.thingsboard.server.dao.yunteng.mapper.TaskCenterMapper;
-import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
-import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
-import org.thingsboard.server.dao.yunteng.service.TkSysJobService;
-import org.thingsboard.server.dao.yunteng.service.TkTaskCenterService;
+import org.thingsboard.server.dao.yunteng.mapper.TkTaskCenterMapper;
+import org.thingsboard.server.dao.yunteng.service.*;
 
 
 import javax.transaction.Transactional;
 import javax.transaction.Transactional;
 import java.util.*;
 import java.util.*;
-import java.util.stream.Collectors;
 
 
 @Service
 @Service
 @RequiredArgsConstructor
 @RequiredArgsConstructor
 @Slf4j
 @Slf4j
 public class TkTaskCenterServiceImpl
 public class TkTaskCenterServiceImpl
-    extends AbstractBaseService<TaskCenterMapper, TkTaskCenterEntity>
+    extends AbstractBaseService<TkTaskCenterMapper, TkTaskCenterEntity>
     implements TkTaskCenterService {
     implements TkTaskCenterService {
   private final TkSysJobService tkSysJobService;
   private final TkSysJobService tkSysJobService;
   private final TkDeviceService tkDeviceService;
   private final TkDeviceService tkDeviceService;
   private final CacheUtils cacheUtils;
   private final CacheUtils cacheUtils;
+  private final TkDeviceTaskCenterService tkDeviceTaskCenterService;
 
 
   @Override
   @Override
   public TkPageData<TkTaskCenterDTO> taskCenterPage(Map<String, Object> queryMap, String tenantId) {
   public TkPageData<TkTaskCenterDTO> taskCenterPage(Map<String, Object> queryMap, String tenantId) {
-    Integer state = (Integer) queryMap.get("state");
-    TargetTypeEnum targetTypeEnum = (TargetTypeEnum) queryMap.get("targetType");
+    queryMap.put("tenantId", tenantId);
     IPage<TkTaskCenterEntity> page =
     IPage<TkTaskCenterEntity> page =
         getPage(queryMap, FastIotConstants.DefaultOrder.CREATE_TIME, false);
         getPage(queryMap, FastIotConstants.DefaultOrder.CREATE_TIME, false);
-    IPage<TkTaskCenterEntity> taskCenterIPage =
-        baseMapper.selectPage(
-            page,
-            new LambdaQueryWrapper<TkTaskCenterEntity>()
-                .eq(TkTaskCenterEntity::getTenantId, tenantId)
-                .eq(null != state, TkTaskCenterEntity::getState, state)
-                .eq(null != targetTypeEnum, TkTaskCenterEntity::getTargetType, targetTypeEnum));
-    if (!taskCenterIPage.getRecords().isEmpty()) {
-      List<TkTaskCenterDTO> listRecords =
-          taskCenterIPage.getRecords().stream()
-              .map(
-                  entity -> {
-                    TkTaskCenterDTO dto = entity.getDTO(TkTaskCenterDTO.class);
-                    dto.setExecuteContent(
-                        JacksonUtil.convertValue(entity.getExecuteContent(), TaskTypeDTO.class));
-                    dto.setExecuteTime(
-                        JacksonUtil.convertValue(
-                            entity.getExecuteTime(), TaskExecuteTimeDTO.class));
-                    dto.setExecuteTarget(
-                        JacksonUtil.convertValue(
-                            entity.getExecuteTarget(), TargetContentDTO.class));
-                    return dto;
-                  })
-              .collect(Collectors.toList());
-      return new TkPageData<>(listRecords, taskCenterIPage.getTotal());
+    IPage<TkTaskCenterDTO> iPage = baseMapper.getPageData(page, queryMap);
+    if (!iPage.getRecords().isEmpty()) {
+      iPage.getRecords().stream()
+          .peek(
+              obj -> {
+                String cacheName = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS;
+                String key =
+                    FastIotConstants.CacheConfigKey.TASK_CENTER_EXECUTE_TIME + "_" + obj.getId();
+                Optional<Long> lastExecuteTime = cacheUtils.get(cacheName, key);
+                lastExecuteTime.ifPresent(obj::setLastExecuteTime);
+              });
     }
     }
-    return getPageData(taskCenterIPage, TkTaskCenterDTO.class);
+    return new TkPageData<>(iPage.getRecords(), iPage.getTotal());
   }
   }
 
 
   @Override
   @Override
@@ -90,7 +71,9 @@ public class TkTaskCenterServiceImpl
       throw new TkDataValidationException(ErrorMessage.EXECUTE_COMMAND_IS_NULL.getMessage());
       throw new TkDataValidationException(ErrorMessage.EXECUTE_COMMAND_IS_NULL.getMessage());
     }
     }
     TaskExecuteTimeDTO executeTime = tkTaskCenterDTO.getExecuteTime();
     TaskExecuteTimeDTO executeTime = tkTaskCenterDTO.getExecuteTime();
-    if (null == executeTime || StringUtils.isEmpty(executeTime.getCron())) {
+    if (null == executeTime
+        || StringUtils.isEmpty(executeTime.getCron())
+        || !tkSysJobService.checkCronExpressionIsValid(executeTime.getCron())) {
       throw new TkDataValidationException(ErrorMessage.CRON_INVALID.getMessage());
       throw new TkDataValidationException(ErrorMessage.CRON_INVALID.getMessage());
     }
     }
     entity.setExecuteContent(
     entity.setExecuteContent(
@@ -113,16 +96,18 @@ public class TkTaskCenterServiceImpl
       baseMapper.updateById(entity);
       baseMapper.updateById(entity);
       updateTaskCenterCache(entity);
       updateTaskCenterCache(entity);
     }
     }
+    saveOrUpdateDeviceTaskCenter(tkTaskCenterDTO);
     return tkTaskCenterDTO;
     return tkTaskCenterDTO;
   }
   }
 
 
   @Override
   @Override
   @Transactional
   @Transactional
   public boolean deleteTaskCenter(DeleteDTO deleteDTO) throws SchedulerException {
   public boolean deleteTaskCenter(DeleteDTO deleteDTO) throws SchedulerException {
+    String tenantId = deleteDTO.getTenantId();
     List<TkTaskCenterEntity> list =
     List<TkTaskCenterEntity> list =
         baseMapper.selectList(
         baseMapper.selectList(
             new LambdaQueryWrapper<TkTaskCenterEntity>()
             new LambdaQueryWrapper<TkTaskCenterEntity>()
-                .eq(TkTaskCenterEntity::getTenantId, deleteDTO.getTenantId())
+                .eq(TkTaskCenterEntity::getTenantId, tenantId)
                 .in(TkTaskCenterEntity::getId, deleteDTO.getIds()));
                 .in(TkTaskCenterEntity::getId, deleteDTO.getIds()));
     if (null == list || list.isEmpty()) {
     if (null == list || list.isEmpty()) {
       throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
       throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
@@ -139,13 +124,15 @@ public class TkTaskCenterServiceImpl
     }
     }
     int result = baseMapper.deleteBatchIds(sourceIds);
     int result = baseMapper.deleteBatchIds(sourceIds);
     if (result > FastIotConstants.MagicNumber.ZERO) {
     if (result > FastIotConstants.MagicNumber.ZERO) {
-      return tkSysJobService.deleteJobs(
-          sourceIds, JobGroupEnum.TASK_CENTER.name(), deleteDTO.getTenantId());
+      for (String taskCenterId : sourceIds) {
+        tkDeviceTaskCenterService.deleteByTaskCenterId(tenantId, taskCenterId);
+      }
+      return tkSysJobService.deleteJobs(sourceIds, JobGroupEnum.TASK_CENTER.name(), tenantId);
     }
     }
     // 移除任务中心缓存
     // 移除任务中心缓存
     for (String taskCenterId : sourceIds) {
     for (String taskCenterId : sourceIds) {
-      String key = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS + taskCenterId;
-      cacheUtils.invalidate(key);
+      String cacheName = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS;
+      cacheUtils.invalidate(cacheName, taskCenterId);
     }
     }
     return false;
     return false;
   }
   }
@@ -180,8 +167,8 @@ public class TkTaskCenterServiceImpl
     if (StringUtils.isEmpty(id)) {
     if (StringUtils.isEmpty(id)) {
       throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
       throw new TkDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
     }
     }
-    String key = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS + id;
-    Optional<TkTaskCenterEntity> entityCache = cacheUtils.get(key);
+    String cacheName = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS;
+    Optional<TkTaskCenterEntity> entityCache = cacheUtils.get(cacheName, id);
     TkTaskCenterEntity entity =
     TkTaskCenterEntity entity =
         entityCache.orElseGet(
         entityCache.orElseGet(
             () ->
             () ->
@@ -200,7 +187,7 @@ public class TkTaskCenterServiceImpl
                   JacksonUtil.convertValue(object.getExecuteTime(), TaskExecuteTimeDTO.class));
                   JacksonUtil.convertValue(object.getExecuteTime(), TaskExecuteTimeDTO.class));
               return Futures.immediateFuture(tkTaskCenterDTO);
               return Futures.immediateFuture(tkTaskCenterDTO);
             })
             })
-        .orElse(null);
+        .orElse(Futures.immediateFuture(new TkTaskCenterDTO()));
   }
   }
 
 
   @Override
   @Override
@@ -243,7 +230,8 @@ public class TkTaskCenterServiceImpl
 
 
   @Override
   @Override
   @Transactional
   @Transactional
-  public boolean cancelExecute(String id, String tbDeviceId, String tenantId) {
+  public boolean cancelOrAllowExecute(
+      String id, String tbDeviceId, String tenantId, boolean isAllow) {
     boolean result = false;
     boolean result = false;
     TkTaskCenterEntity entity = baseMapper.selectById(id);
     TkTaskCenterEntity entity = baseMapper.selectById(id);
     if (entity != null) {
     if (entity != null) {
@@ -253,31 +241,21 @@ public class TkTaskCenterServiceImpl
       TargetContentDTO targetContent =
       TargetContentDTO targetContent =
           JacksonUtil.convertValue(entity.getExecuteTarget(), TargetContentDTO.class);
           JacksonUtil.convertValue(entity.getExecuteTarget(), TargetContentDTO.class);
       if (null != targetContent) {
       if (null != targetContent) {
-        // 按设备执行
-        if (Objects.equals(entity.getTargetType(), TargetTypeEnum.DEVICES)) {
-          List<String> data = targetContent.getData();
-          List<String> removeResult = new ArrayList<>();
-          if (null != data && !data.isEmpty()) {
-            for (String deviceId : data) {
-              if (!Objects.equals(deviceId, tbDeviceId)) {
-                removeResult.add(deviceId);
-              }
-            }
-            targetContent.setData(removeResult);
-          }
+        // 查询设备信息
+        DeviceDTO dto = tkDeviceService.findDeviceInfoByTbDeviceId(tenantId, tbDeviceId);
+        Map<String, List<String>> map = targetContent.getCancelExecuteDevices();
+        if (isAllow) {
+          map.get(dto.getDeviceProfileId()).remove(tbDeviceId);
         } else {
         } else {
-          // 按产品执行
-          Map<String, List<String>> map = targetContent.getCancelExecuteDevices();
-          DeviceDTO deviceDTO = tkDeviceService.findDeviceInfoByTbDeviceId(tenantId, tbDeviceId);
-          for (String key : map.keySet()) {
-            if (Objects.equals(key, deviceDTO.getDeviceProfileId())) {
-              map.get(key).add(tbDeviceId);
-              break;
-            }
-          }
+          map.get(dto.getDeviceProfileId()).add(tbDeviceId);
         }
         }
         entity.setExecuteTarget(JacksonUtil.convertValue(targetContent, JsonNode.class));
         entity.setExecuteTarget(JacksonUtil.convertValue(targetContent, JsonNode.class));
         baseMapper.updateById(entity);
         baseMapper.updateById(entity);
+        tkDeviceTaskCenterService.updateStateByTbDeviceIdAndTaskCenterId(
+            tenantId,
+            id,
+            tbDeviceId,
+            isAllow ? StatusEnum.ENABLE.getIndex() : StatusEnum.DISABLE.getIndex());
         updateTaskCenterCache(entity);
         updateTaskCenterCache(entity);
       }
       }
     }
     }
@@ -285,10 +263,50 @@ public class TkTaskCenterServiceImpl
   }
   }
 
 
   private void updateTaskCenterCache(TkTaskCenterEntity entity) {
   private void updateTaskCenterCache(TkTaskCenterEntity entity) {
-    String key = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS + entity.getId();
-    Optional<TkTaskCenterEntity> entityCache = cacheUtils.get(key);
+    String cacheName = FastIotConstants.CacheConfigKey.TASK_CENTER_INFOS;
+    Optional<TkTaskCenterEntity> entityCache = cacheUtils.get(cacheName, entity.getId());
     if (entityCache.isPresent()) {
     if (entityCache.isPresent()) {
-      cacheUtils.put(key, entity);
+      cacheUtils.put(cacheName, entity.getId(), entity);
+    }
+  }
+
+  private void saveOrUpdateDeviceTaskCenter(TkTaskCenterDTO tkTaskCenter) {
+    String taskCenterId = tkTaskCenter.getId();
+    String tenantId = tkTaskCenter.getTenantId();
+    // 判断是按产品执行还是按设备执行
+    List<String> data = tkTaskCenter.getExecuteTarget().getData();
+    boolean isUpdate = !StringUtils.isEmpty(taskCenterId);
+    if (Objects.equals(tkTaskCenter.getTargetType(), TargetTypeEnum.DEVICES)) {
+      processDeviceTaskCenterMapping(isUpdate, tenantId, taskCenterId, data);
+    } else {
+      for (String key : data) {
+        List<String> tbDeviceIds = tkDeviceService.findTbDeviceIdsByDeviceProfileId(key, tenantId);
+        processDeviceTaskCenterMapping(isUpdate, tenantId, taskCenterId, tbDeviceIds);
+      }
+    }
+  }
+
+  private void processDeviceTaskCenterMapping(
+      boolean isUpdate, String tenantId, String taskCenterId, List<String> deviceIds) {
+    if (null != deviceIds && !deviceIds.isEmpty()) {
+      if (isUpdate) {
+        tkDeviceTaskCenterService.deleteByTaskCenterId(tenantId, taskCenterId);
+      }
+      insertBatchByTbDeviceIdsAndTaskCenterId(tenantId, taskCenterId, deviceIds);
+    }
+  }
+
+  private void insertBatchByTbDeviceIdsAndTaskCenterId(
+      String tenantId, String taskCenterId, List<String> deviceIds) {
+    List<TkDeviceTaskCenterEntity> saveList = new ArrayList<>();
+    for (String key : deviceIds) {
+      TkDeviceTaskCenterEntity entity = new TkDeviceTaskCenterEntity();
+      entity.setTbDeviceId(key);
+      entity.setTaskCenterId(taskCenterId);
+      entity.setTenantId(tenantId);
+      entity.setState(StatusEnum.ENABLE.getIndex());
+      saveList.add(entity);
     }
     }
+    tkDeviceTaskCenterService.insertBatch(saveList);
   }
   }
 }
 }

@@ -2,8 +2,7 @@ package org.thingsboard.server.dao.yunteng.mapper;
 
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Mapper;
-import org.thingsboard.server.dao.yunteng.entities.TkTaskCenterEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceTaskCenterEntity;
 
 
 @Mapper
 @Mapper
-public interface TaskCenterMapper extends BaseMapper<TkTaskCenterEntity> {
-}
+public interface TkDeviceTaskCenterMapper extends BaseMapper<TkDeviceTaskCenterEntity> {}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkTaskCenterEntity;
+import java.util.Map;
+
+@Mapper
+public interface TkTaskCenterMapper extends BaseMapper<TkTaskCenterEntity> {
+    IPage<TkTaskCenterDTO> getPageData(
+            IPage<?> page,
+            @Param("queryMap")Map<String,Object> queryMap);
+}

@@ -204,4 +204,12 @@ public interface TkDeviceService extends BaseService<TkDeviceEntity> {
   List<String> rpcDevices(String tenantId,String organizationId,String projectId);
   List<String> rpcDevices(String tenantId,String organizationId,String projectId);
 
 
   ListenableFuture<List<DeviceDTO>> findDeviceListByDeviceProfileId(String deviceProfileId,String tenantId);
   ListenableFuture<List<DeviceDTO>> findDeviceListByDeviceProfileId(String deviceProfileId,String tenantId);
+
+  /**
+   * 通过设备配置ID查询所有的tbDeviceId
+   * @param deviceProfileId 设备配置ID
+   * @param tenantId 租户ID
+   * @return id集合
+   */
+  List<String> findTbDeviceIdsByDeviceProfileId(String deviceProfileId,String tenantId);
 }
 }

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.task.TkDeviceTaskCenterDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceTaskCenterEntity;
+import java.util.List;
+
+public interface TkDeviceTaskCenterService {
+  /**
+   * 新增或修改设备与任务中心的映射关系
+   *
+   * @param tkDeviceTaskCenterDTO 映射信息
+   * @return 映射信息
+   */
+  TkDeviceTaskCenterDTO saveOrUpdate(TkDeviceTaskCenterDTO tkDeviceTaskCenterDTO);
+
+  /**
+   * 删除设备与任务中心的映射关系
+   *
+   * @param delete 删除参数
+   * @return true成功 false失败
+   */
+  boolean delete(DeleteDTO delete);
+
+  /**
+   * 根据任务中心ID和设备ID更新状态
+   * @param tenantId 租户ID
+   * @param taskCenterId 任务重ID
+   * @param tbDeviceId 设备ID
+   * @param state 状态
+   * @return true成功 false失败
+   */
+  boolean updateStateByTbDeviceIdAndTaskCenterId(String tenantId,String taskCenterId,String tbDeviceId,Integer state);
+
+  /**
+   * 通过任务ID删除所有的映射关系
+   * @param tenantId 租户ID
+   * @param taskCenterId 任务ID
+   * @return true成功 false失败
+   */
+  boolean deleteByTaskCenterId(String tenantId,String taskCenterId);
+
+  /**
+   * 批量插入
+   *
+   * @param list 插入实体集合
+   * @return true成功 false失败
+   */
+  boolean insertBatch(List<TkDeviceTaskCenterEntity> list);
+}

 package org.thingsboard.server.dao.yunteng.service;
 package org.thingsboard.server.dao.yunteng.service;
 
 
-import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import com.google.common.util.concurrent.ListenableFuture;import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
 import org.thingsboard.server.common.data.yunteng.dto.SysJobLogDTO;
 import org.thingsboard.server.common.data.yunteng.dto.SysJobLogDTO;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 
 
@@ -46,4 +46,12 @@ public interface TkSysJobLogService
      * 清空任务日志
      * 清空任务日志
      */
      */
     boolean cleanJobLog();
     boolean cleanJobLog();
+
+  /**
+   * 根据任务ID获取任务日志执行的最新时间戳
+   * @param jobId 任务ID
+   * @param jobGroup 任务分组
+   * @return 最新时间戳
+   */
+  ListenableFuture<Long> findLastLogEndTimeByJobId(String jobId, String jobGroup);
 }
 }

 package org.thingsboard.server.dao.yunteng.service;
 package org.thingsboard.server.dao.yunteng.service;
 
 
-import com.google.common.util.concurrent.ListenableFuture;import org.quartz.SchedulerException;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.quartz.SchedulerException;
 import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
 import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
 import org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO;
 import org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
@@ -15,7 +16,6 @@ public interface TkTaskCenterService {
    * @return 分页数据
    * @return 分页数据
    */
    */
   TkPageData<TkTaskCenterDTO> taskCenterPage(Map<String, Object> queryMap, String tenantId);
   TkPageData<TkTaskCenterDTO> taskCenterPage(Map<String, Object> queryMap, String tenantId);
-
   /**
   /**
    * 修改或保存任务中心
    * 修改或保存任务中心
    *
    *
@@ -28,18 +28,20 @@ public interface TkTaskCenterService {
    *
    *
    * @param deleteDTO 删除IDS
    * @param deleteDTO 删除IDS
    */
    */
-  boolean deleteTaskCenter(DeleteDTO deleteDTO)throws SchedulerException;
+  boolean deleteTaskCenter(DeleteDTO deleteDTO) throws SchedulerException;
 
 
   /**
   /**
    * 根据任务中心ID，查询任务信息
    * 根据任务中心ID，查询任务信息
+   *
    * @param id 任务中心ID
    * @param id 任务中心ID
    * @param tenantId 租户ID
    * @param tenantId 租户ID
    * @return 任务信息
    * @return 任务信息
    */
    */
-  TkTaskCenterDTO findTaskCenterInfoById(String id,String tenantId);
+  TkTaskCenterDTO findTaskCenterInfoById(String id, String tenantId);
 
 
   /**
   /**
    * 根据任务中心ID，异步查询任务信息
    * 根据任务中心ID，异步查询任务信息
+   *
    * @param id 任务中心ID
    * @param id 任务中心ID
    * @return 任务信息
    * @return 任务信息
    */
    */
@@ -47,19 +49,22 @@ public interface TkTaskCenterService {
 
 
   /**
   /**
    * 启用禁用任务中心
    * 启用禁用任务中心
+   *
    * @param id 任务中心ID
    * @param id 任务中心ID
    * @param state 1启用 0禁用
    * @param state 1启用 0禁用
    * @param tenantId 租户ID
    * @param tenantId 租户ID
    * @return true成功 false失败
    * @return true成功 false失败
    */
    */
-  boolean updateState(String id,Integer state,String tenantId)throws SchedulerException;
+  boolean updateState(String id, Integer state, String tenantId) throws SchedulerException;
 
 
   /**
   /**
    * 设备取消任务执行
    * 设备取消任务执行
+   *
    * @param id 任务ID
    * @param id 任务ID
    * @param tbDeviceId 设备ID
    * @param tbDeviceId 设备ID
    * @param tenantId 租户ID
    * @param tenantId 租户ID
+   * @param isAllow true允许执行 false取消执行
    * @return true成功 false失败
    * @return true成功 false失败
    */
    */
-  boolean cancelExecute(String id,String tbDeviceId,String tenantId);
+  boolean cancelOrAllowExecute(String id, String tbDeviceId, String tenantId, boolean isAllow);
 }
 }

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="org.thingsboard.server.dao.yunteng.mapper.TkTaskCenterMapper">
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.task.TkTaskCenterDTO" id="dataMap">
+        <result property="id" column="id"/>
+        <result property="name" column="name"/>
+        <result property="targetType" column="target_type" typeHandler="org.apache.ibatis.type.EnumTypeHandler" />
+        <result property="executeTarget" column="execute_target"
+                typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler"/>
+        <result property="executeContent" column="execute_content"
+                typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler"/>
+        <result property="executeTime" column="execute_time"
+                typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler"/>
+        <result property="createTime" column="create_time"/>
+        <result property="creator" column="creator"/>
+        <result property="updater" column="updater"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="tenantId" column="tenant_id" />
+        <association property="tkDeviceTaskCenter" javaType="org.thingsboard.server.common.data.yunteng.dto.task.TkDeviceTaskCenterDTO">
+            <result property="state" column="state"/>
+            <result property="taskCenterId" column="task_center_id"/>
+            <result property="tbDeviceId" column="tb_device_id"/>
+        </association>
+    </resultMap>
+
+
+
+    <sql id="basicColumns">
+        tc.id,tc.name,tc.target_type,tc.execute_target,tc.execute_content,tc.execute_time,tc.create_time,tc.creator,
+        tc.updater,tc.update_time,tc.tenant_id
+    </sql>
+
+    <sql id="detailColumns">
+        <include refid="basicColumns"/>
+        ,tdc.state,tdc.task_center_id,tb_device_id
+    </sql>
+    <select id="getPageData" resultMap="dataMap">
+        SELECT
+        <include refid="detailColumns"/>
+        FROM tk_task_center tc
+        LEFT JOIN tk_device_task_center tdc ON tc.id = tdc.task_center_id
+        <where>
+            <if test="queryMap.tenantId !=null and queryMap.tenantId !=''">
+                AND tc.tenant_id = #{queryMap.tenantId}
+            </if>
+            <if test="queryMap.state !=null">
+                AND tc.state = #{queryMap.state}
+            </if>
+            <if test="queryMap.targetType !=null">
+                AND tc.target_type = #{queryMap.targetType}
+            </if>
+            <if test="queryMap.tbDeviceId !=null and queryMap.tbDeviceId !=''">
+                AND tdc.tb_device_id = #{queryMap.tbDeviceId}
+            </if>
+        </where>
+    </select>
+</mapper>