Merge branch 'master' into 20220829

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.quartz.SchedulerException;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+import org.thingsboard.server.common.data.yunteng.common.DeleteGroup;
+import org.thingsboard.server.common.data.yunteng.common.UpdateGroup;
+import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DataBoardDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.board.ComponentLayoutDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDataBoardService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.ORDER_TYPE;
+
+@RestController
+@RequiredArgsConstructor
+@PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+@RequestMapping("api/yt/data_board")
+@Api(tags = {"数据看板"})
+public class YtDataBoardController extends BaseController {
+  private final YtDataBoardService ytDataBoardService;
+
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  @ApiOperation("分页查询")
+  public YtPageData<DataBoardDTO> page(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = ORDER_FILED, required = false) String orderBy,
+      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType)
+      throws ThingsboardException {
+    Map<String, Object> queryMap = new HashMap<>();
+    queryMap.put(PAGE_SIZE, pageSize);
+    queryMap.put(PAGE, page);
+    queryMap.put(ORDER_FILED, orderBy);
+    queryMap.put(ORDER_TYPE, orderType);
+    queryMap.put(TENANT_ID, getCurrentUser().getCurrentTenantId());
+    return ytDataBoardService.dataBoardPage(queryMap);
+  }
+
+  @DeleteMapping
+  @ApiOperation(value = "删除数据看板")
+  public ResponseResult<Boolean> deleteDataBoard(
+      @Validated(DeleteGroup.class) @RequestBody DeleteDTO deleteDTO) throws ThingsboardException {
+    deleteDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+    return ResponseResult.success(ytDataBoardService.deleteDataBoard(deleteDTO));
+  }
+
+  @PostMapping("/add")
+  @ApiOperation(value = "新增数据看板")
+  public ResponseResult<DataBoardDTO> save(
+      @RequestBody @Validated(AddGroup.class) DataBoardDTO dataBoard)
+      throws SchedulerException, ThingsboardException {
+    if (StringUtils.isNotEmpty(dataBoard.getId())) {
+      throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    return saveOrUpdate(dataBoard);
+  }
+
+  @PostMapping("/update")
+  @ApiOperation(value = "编辑数据看板")
+  public ResponseResult<DataBoardDTO> update(
+      @RequestBody @Validated(UpdateGroup.class) DataBoardDTO dataBoard)
+      throws SchedulerException, ThingsboardException {
+    if (StringUtils.isEmpty(dataBoard.getId())) {
+      throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    return saveOrUpdate(dataBoard);
+  }
+
+  @PostMapping("/{boardId}/layout/")
+  @ApiOperation(value = "保存看板的组件布局")
+  public ResponseResult<Boolean> saveLayout(
+      @PathVariable("boardId") String boardId, @RequestBody List<ComponentLayoutDTO> layoutDTOList)
+      throws ThingsboardException {
+    return ResponseResult.success(
+        ytDataBoardService.saveComponentLayout(
+            layoutDTOList, boardId, getCurrentUser().getCurrentTenantId()));
+  }
+
+  private ResponseResult<DataBoardDTO> saveOrUpdate(DataBoardDTO dataBoard)
+      throws ThingsboardException {
+    dataBoard.setTenantId(getCurrentUser().getCurrentTenantId());
+    return ResponseResult.success(ytDataBoardService.saveOrUpdateDataBoard(dataBoard));
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.quartz.SchedulerException;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+import org.thingsboard.server.common.data.yunteng.common.DeleteGroup;
+import org.thingsboard.server.common.data.yunteng.common.UpdateGroup;
+import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DataBoardDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DataComponentDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDataBoardService;
+import org.thingsboard.server.dao.yunteng.service.YtDataComponentService;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+@PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+@RequestMapping("api/yt/data_component")
+@Api(tags = {"数据组件"})
+public class YtDataComponentController extends BaseController {
+  private final YtDataComponentService ytDataComponentService;
+  private final YtDataBoardService ytDataBoardService;
+
+  @GetMapping("/{boardId}")
+  @ApiOperation(value = "查询看板下的所有组件信息")
+  public ResponseResult<List<DataComponentDTO>> getDataComponentsByBoardId(
+      @PathVariable("boardId") String boardId) throws ThingsboardException {
+    checkDataBoardInfo(boardId);
+    return ResponseResult.success(
+        ytDataComponentService.getDataComponentsByBoardId(
+            getCurrentUser().getCurrentTenantId(), boardId));
+  }
+
+  @PostMapping("/{boardId}/add")
+  @ApiOperation(value = "新增组件")
+  public ResponseResult<DataComponentDTO> save(
+      @PathVariable("boardId") String boardId,
+      @RequestBody @Validated(AddGroup.class) DataComponentDTO dataComponent)
+      throws SchedulerException, ThingsboardException {
+    if (StringUtils.isNotEmpty(dataComponent.getId())) {
+      throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    checkDataBoardInfo(boardId);
+    dataComponent.setTenantId(getCurrentUser().getCurrentTenantId());
+    dataComponent.setDataBoardId(boardId);
+    return saveOrUpdate(dataComponent);
+  }
+
+  @PostMapping("/{boardId}/update")
+  @ApiOperation(value = "编辑组件")
+  public ResponseResult<DataComponentDTO> update(
+      @PathVariable("boardId") String boardId,
+      @RequestBody @Validated(UpdateGroup.class) DataComponentDTO dataComponent)
+      throws SchedulerException, ThingsboardException {
+    if (StringUtils.isEmpty(dataComponent.getId())) {
+      throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    checkDataBoardInfo(boardId);
+    dataComponent.setDataBoardId(boardId);
+    dataComponent.setTenantId(getCurrentUser().getCurrentTenantId());
+    return saveOrUpdate(dataComponent);
+  }
+
+  @DeleteMapping
+  @ApiOperation(value = "删除数据组件")
+  public ResponseResult<Boolean> deleteDataBoard(
+      @Validated(DeleteGroup.class) @RequestBody DeleteDTO deleteDTO) throws ThingsboardException {
+    deleteDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+    return ResponseResult.success(ytDataComponentService.deleteDataComponent(deleteDTO));
+  }
+
+  private ResponseResult<DataComponentDTO> saveOrUpdate(DataComponentDTO dataComponent)
+      throws ThingsboardException {
+    dataComponent.setTenantId(getCurrentUser().getCurrentTenantId());
+    return ResponseResult.success(ytDataComponentService.saveOrUpdateDataBoard(dataComponent));
+  }
+
+  private void checkDataBoardInfo(String boardId) throws ThingsboardException {
+    DataBoardDTO dto =
+        ytDataBoardService.findDataBoardInfoById(boardId, getCurrentUser().getCurrentTenantId());
+    if (null == dto) {
+      throw new YtDataValidationException(ErrorMessage.NOT_BELONG_CURRENT_TENANT.getMessage());
+    }
+  }
+}

@@ -97,6 +97,10 @@ public final class ModelConstants {
     public static final String IOTFS_REPORT_FORM_CONFIG_NAME = "iotfs_report_form_config";
     public static final String IOTFS_REPORT_FORM_CONFIG_NAME = "iotfs_report_form_config";
     /** 报表生成记录表 */
     /** 报表生成记录表 */
     public static final String IOTFS_REPORT_GENERATE_RECORD_NAME = "iotfs_report_generate_record";
     public static final String IOTFS_REPORT_GENERATE_RECORD_NAME = "iotfs_report_generate_record";
+    /** 数据看板 */
+    public static final String IOTFS_DATA_BOARD_NAME = "iotfs_data_board";
+    /** 数据组件 */
+    public static final String IOTFS_DATA_COMPONENT_NAME = "iotfs_data_component";
   }
   }
 
 
   public static class TableFields {
   public static class TableFields {

@@ -6,4 +6,5 @@ public class QueryConstant {
   public static final String ORDER_FILED = "orderFiled";
   public static final String ORDER_FILED = "orderFiled";
   public static final String ORDER_TYPE = "orderType";
   public static final String ORDER_TYPE = "orderType";
   public static final String CREATE_TIME="createTime";
   public static final String CREATE_TIME="createTime";
+  public static final String TENANT_ID = "tenantId";
 }
 }

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+import org.thingsboard.server.common.data.yunteng.dto.board.ComponentLayoutDTO;
+import org.thingsboard.server.common.data.yunteng.enums.ViewType;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class DataBoardDTO extends TenantDTO {
+  @ApiModelProperty(value = "数据看板名称", required = true)
+  @NotEmpty(message = "数据看板名称不能为空或者空字符串",groups = AddGroup.class)
+  private String name;
+
+  @ApiModelProperty(value = "视图类型")
+  private ViewType viewType = ViewType.PRIVATE_VIEW;
+
+  @ApiModelProperty(value = "公有视图URL")
+  private String openUrl;
+
+  @ApiModelProperty(value = "组件布局")
+  private List<ComponentLayoutDTO> layout;
+
+  @ApiModelProperty(value = "备注")
+  private String remark;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.dto.board.DataSourceInfoDTO;
+
+import java.util.List;
+
+@Data
+public class DataComponentDTO extends TenantDTO {
+  @ApiModelProperty(value = "组件名称", required = true)
+  private String name;
+
+  @ApiModelProperty(value = "数据看板ID", required = true)
+  private String dataBoardId;
+
+  @ApiModelProperty(value = "前端组件ID", required = true)
+  private String frontId;
+
+  @ApiModelProperty(value = "数据源", required = true)
+  private List<DataSourceInfoDTO> dataSource;
+
+  @ApiModelProperty(value = "备注")
+  private String remark;
+}

+package org.thingsboard.server.common.data.yunteng.dto.board;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Data
+public class ComponentInfoDTO implements Serializable {
+
+  private static final long serialVersionUID = -1383423212190365330L;
+
+  @ApiModelProperty(value = "数值字体颜色", required = true)
+  private String fontColor;
+
+  @ApiModelProperty(value = "数值单位")
+  private String unit;
+
+  @ApiModelProperty(value = "icon图标")
+  private String icon;
+
+  @ApiModelProperty(value = "icon图标颜色")
+  private String iconColor;
+
+  @ApiModelProperty(value = "梯度信息")
+  private List<GradientInfo> gradientInfo;
+
+  @Data
+  class GradientInfo {
+
+    @ApiModelProperty(value = "梯度key")
+    private String key;
+
+    @ApiModelProperty(value = "梯度值")
+    private Integer value;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto.board;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+public class ComponentLayoutDTO implements Serializable {
+
+  private static final long serialVersionUID = 8166034261704947504L;
+
+  @ApiModelProperty(value = "组件元素ID", required = true)
+  private String id;
+
+  @ApiModelProperty(value = "X坐标", required = true)
+  private Integer x;
+
+  @ApiModelProperty(value = "Y坐标", required = true)
+  private Integer y;
+
+  @ApiModelProperty(value = "宽度", required = true)
+  private Integer w;
+
+  @ApiModelProperty(value = "高度", required = true)
+  private Integer h;
+}

+package org.thingsboard.server.common.data.yunteng.dto.board;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+public class DataSourceInfoDTO implements Serializable {
+
+  private static final long serialVersionUID = -8044628645505274772L;
+
+  @ApiModelProperty(value = "组织ID", required = true)
+  private String organizationId;
+
+  @ApiModelProperty(value = "设备ID", required = true)
+  private String deviceId;
+
+  @ApiModelProperty(value = "属性", required = true)
+  private String attribute;
+
+  @ApiModelProperty(value = "设备重命名")
+  private String deviceRename;
+
+  @ApiModelProperty(value = "属性重命名")
+  private String attributeRename;
+
+  @ApiModelProperty(value = "组件选项信息")
+  private ComponentInfoDTO componentInfo;
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+public enum ViewType {
+  PUBLIC_VIEW,
+  PRIVATE_VIEW
+}

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.apache.ibatis.type.EnumTypeHandler;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+import org.thingsboard.server.common.data.yunteng.enums.ViewType;
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = ModelConstants.Table.IOTFS_DATA_BOARD_NAME, autoResultMap = true)
+@Data
+public class DataBoard extends TenantBaseEntity {
+
+  private static final long serialVersionUID = 1438007769925112807L;
+
+  private String name;
+
+  @TableField(typeHandler = EnumTypeHandler.class)
+  private ViewType viewType;
+
+  private String openUrl;
+
+  @TableField(typeHandler = JacksonTypeHandler.class)
+  private JsonNode layout;
+
+  private String remark;
+}

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = ModelConstants.Table.IOTFS_DATA_COMPONENT_NAME, autoResultMap = true)
+public class DataComponent extends TenantBaseEntity {
+
+  private static final long serialVersionUID = -1500982711916168023L;
+  /** 组件名称 */
+  private String name;
+
+  /** 数据看板ID */
+  private String dataBoardId;
+
+  /** 前端组件ID */
+  private String frontId;
+
+  /** 数据源 */
+  @TableField(typeHandler = JacksonTypeHandler.class)
+  private JsonNode dataSource;
+
+  /** 备注 */
+  private String remark;
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DataBoardDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.board.ComponentLayoutDTO;
+import org.thingsboard.server.common.data.yunteng.enums.ViewType;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
+import org.thingsboard.server.dao.yunteng.entities.DataBoard;
+import org.thingsboard.server.dao.yunteng.mapper.DataBoardMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtDataBoardService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+@Service
+public class YtDataBoardServiceImpl extends AbstractBaseService<DataBoardMapper, DataBoard>
+    implements YtDataBoardService {
+  @Override
+  public YtPageData<DataBoardDTO> dataBoardPage(Map<String, Object> queryMap) {
+    String tenantId =
+        Optional.ofNullable(queryMap.get("tenantId"))
+            .map(obj -> queryMap.get("tenantId").toString())
+            .orElseThrow(
+                () -> {
+                  throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+                });
+    IPage<DataBoard> page =
+        baseMapper.selectPage(
+            getPage(queryMap, FastIotConstants.DefaultOrder.CREATE_TIME, false),
+            new LambdaQueryWrapper<DataBoard>().eq(DataBoard::getTenantId, tenantId));
+    return getPageData(page, DataBoardDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public DataBoardDTO saveOrUpdateDataBoard(DataBoardDTO dataBoardDTO) {
+    DataBoard dataBoard = dataBoardDTO.getEntity(DataBoard.class);
+    if (StringUtils.isEmpty(dataBoardDTO.getId())) {
+      try {
+        baseMapper.insert(dataBoard);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    } else {
+      DataBoard board =
+          baseMapper.selectOne(
+              new LambdaQueryWrapper<DataBoard>()
+                  .eq(DataBoard::getId, dataBoardDTO.getId())
+                  .eq(DataBoard::getTenantId, dataBoardDTO.getTenantId()));
+      Optional.ofNullable(board)
+          .map(obj -> baseMapper.updateById(dataBoard))
+          .orElseThrow(
+              () -> {
+                throw new YtDataValidationException(ErrorMessage.INTERNAL_ERROR.getMessage());
+              });
+    }
+    // 公有视图,生成访问路径
+    if (dataBoard.getViewType() == ViewType.PUBLIC_VIEW) {}
+
+    return dataBoard.getDTO(DataBoardDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public boolean deleteDataBoard(DeleteDTO deleteDTO) {
+    return baseMapper.delete(
+            new LambdaQueryWrapper<DataBoard>()
+                .eq(DataBoard::getTenantId, deleteDTO.getTenantId())
+                .in(DataBoard::getId, deleteDTO.getIds()))
+        > FastIotConstants.MagicNumber.ZERO;
+  }
+
+  @Override
+  @Transactional
+  public boolean saveComponentLayout(
+      List<ComponentLayoutDTO> layoutDTOList, String boardId, String tenantId) {
+    DataBoard dataBoard =
+        baseMapper.selectOne(
+            new LambdaQueryWrapper<DataBoard>()
+                .eq(DataBoard::getTenantId, tenantId)
+                .eq(DataBoard::getId, boardId));
+    return Optional.ofNullable(dataBoard)
+        .map(
+            obj -> {
+              dataBoard.setLayout(JacksonUtil.convertValue(layoutDTOList, JsonNode.class));
+              return baseMapper.updateById(dataBoard) > 0;
+            })
+        .orElseThrow(
+            () -> {
+              throw new YtDataValidationException(
+                  ErrorMessage.NOT_BELONG_CURRENT_TENANT.getMessage());
+            });
+  }
+
+  @Override
+  public DataBoardDTO findDataBoardInfoById(String id, String tenantId) {
+    return Optional.ofNullable(
+            baseMapper.selectOne(
+                new LambdaQueryWrapper<DataBoard>()
+                    .eq(DataBoard::getTenantId, tenantId)
+                    .eq(DataBoard::getId, id)))
+        .map(obj -> obj.getDTO(DataBoardDTO.class))
+        .orElse(null);
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.fasterxml.jackson.databind.JsonNode;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DataComponentDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.board.DataSourceInfoDTO;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+import org.thingsboard.server.dao.yunteng.entities.DataComponent;
+import org.thingsboard.server.dao.yunteng.mapper.DataComponentMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtDataComponentService;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+public class YtDataComponentServiceImpl
+    extends AbstractBaseService<DataComponentMapper, DataComponent>
+    implements YtDataComponentService {
+  @Override
+  public List<DataComponentDTO> getDataComponentsByBoardId(String tenantId, String boardId) {
+    List<DataComponent> dataComponentList =
+        baseMapper.selectList(
+            new LambdaQueryWrapper<DataComponent>()
+                .eq(DataComponent::getTenantId, tenantId)
+                .eq(DataComponent::getDataBoardId, boardId));
+    if (dataComponentList.isEmpty()) {
+      throw new YtDataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    return dataComponentList.stream()
+        .map(
+            obj -> {
+              DataComponentDTO dto = obj.getDTO(DataComponentDTO.class);
+              List<DataSourceInfoDTO> list = new ArrayList<>();
+              if (null != obj.getDataSource() && obj.getDataSource().isArray()) {
+                for (JsonNode jsonNode : obj.getDataSource()) {
+                  list.add(JacksonUtil.convertValue(jsonNode, DataSourceInfoDTO.class));
+                }
+              }
+              dto.setDataSource(list);
+              return dto;
+            })
+        .collect(Collectors.toList());
+  }
+
+  @Override
+  public DataComponentDTO saveOrUpdateDataBoard(DataComponentDTO dataComponentDTO) {
+    DataComponent dataComponent = dataComponentDTO.getEntity(DataComponent.class);
+    dataComponent.setDataSource(
+        JacksonUtil.convertValue(dataComponentDTO.getDataSource(), JsonNode.class));
+    if (StringUtils.isEmpty(dataComponentDTO.getId())) {
+      baseMapper.insert(dataComponent);
+    } else {
+      DataComponent queryEntity =
+          baseMapper.selectOne(
+              new LambdaQueryWrapper<DataComponent>()
+                  .eq(DataComponent::getId, dataComponentDTO.getId())
+                  .eq(DataComponent::getTenantId, dataComponentDTO.getTenantId()));
+      Optional.ofNullable(queryEntity)
+          .map(obj -> baseMapper.updateById(dataComponent))
+          .orElseThrow(
+              () -> {
+                throw new YtDataValidationException(
+                    ErrorMessage.NOT_BELONG_CURRENT_TENANT.getMessage());
+              });
+    }
+    return dataComponent.getDTO(DataComponentDTO.class);
+  }
+
+  @Override
+  public boolean deleteDataComponent(DeleteDTO deleteDTO) {
+    return baseMapper.delete(
+            new LambdaQueryWrapper<DataComponent>()
+                .eq(DataComponent::getTenantId, deleteDTO.getTenantId())
+                .in(DataComponent::getId, deleteDTO.getIds()))
+        > FastIotConstants.MagicNumber.ZERO;
+  }
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.thingsboard.server.dao.yunteng.entities.DataBoard;
+
+@Mapper
+public interface DataBoardMapper extends BaseMapper<DataBoard> {
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.thingsboard.server.dao.yunteng.entities.DataComponent;
+
+@Mapper
+public interface DataComponentMapper extends BaseMapper<DataComponent> {}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.DataBoardDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.board.ComponentLayoutDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
+
+import java.util.List;
+import java.util.Map;
+
+public interface YtDataBoardService {
+  /**
+   * 数据看板分页
+   *
+   * @param queryMap 分页查询条件
+   * @return 分页数据
+   */
+  YtPageData<DataBoardDTO> dataBoardPage(Map<String, Object> queryMap);
+
+  /**
+   * 修改或保存数据看板
+   *
+   * @param dataBoardDTO 数据看板信息
+   */
+  DataBoardDTO saveOrUpdateDataBoard(DataBoardDTO dataBoardDTO);
+
+  /**
+   * 删除数据看板
+   *
+   * @param deleteDTO 删除IDS
+   */
+  boolean deleteDataBoard(DeleteDTO deleteDTO);
+
+  /**
+   * 保存看板的组件布局
+   * @param layoutDTOList 组件布局
+   * @param boardId 看板ID
+   * @return true成功 false失败
+   */
+  boolean saveComponentLayout(List<ComponentLayoutDTO> layoutDTOList,String boardId,String tenantId);
+
+
+  /**
+   * 根据租户ID和看板ID查询看板信息
+   * @param id
+   * @param tenantId
+   * @return
+   */
+  DataBoardDTO findDataBoardInfoById(String id,String tenantId);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.DataComponentDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+
+import java.util.List;
+
+public interface YtDataComponentService {
+  /**
+   * 查询数据看板下的所有组件
+   * @param tenantId 租户id
+   * @param boardId 看板ID
+   * @return 组件列表
+   */
+  List<DataComponentDTO> getDataComponentsByBoardId(String tenantId, String boardId);
+
+  /**
+   * 修改或保存数据看板
+   *
+   * @param dataComponentDTO 数据看板信息
+   */
+  DataComponentDTO saveOrUpdateDataBoard(DataComponentDTO dataComponentDTO);
+
+  /**
+   * 删除组件
+   *
+   * @param deleteDTO 删除IDS
+   */
+  boolean deleteDataComponent(DeleteDTO deleteDTO);
+}