feat: 增加openApi应用管理

@@ -86,7 +86,7 @@ public class ThingsboardSecurityConfiguration {
 
 
     public static final String PUBLIC_LOGIN_ENTRY_POINT = "/api/auth/login/public";
     public static final String PUBLIC_LOGIN_ENTRY_POINT = "/api/auth/login/public";
     public static final String TOKEN_REFRESH_ENTRY_POINT = "/api/auth/token";
     public static final String TOKEN_REFRESH_ENTRY_POINT = "/api/auth/token";
-    protected static final String[] NON_TOKEN_BASED_AUTH_ENTRY_POINTS = new String[] {"/index.html", "/assets/**", "/static/**", "/api/noauth/**", "/webjars/**",  "/api/license/**", "/api/images/public/**"};
+    protected static final String[] NON_TOKEN_BASED_AUTH_ENTRY_POINTS = new String[] {"/index.html", "/assets/**", "/static/**", "/api/noauth/**", "/webjars/**",  "/api/license/**", "/api/images/public/**", "/api/yt/openApi/getToken/**"};
     public static final String TOKEN_BASED_AUTH_ENTRY_POINT = "/api/**";
     public static final String TOKEN_BASED_AUTH_ENTRY_POINT = "/api/**";
     public static final String WS_ENTRY_POINT = "/api/ws/**";
     public static final String WS_ENTRY_POINT = "/api/ws/**";
     public static final String MAIL_OAUTH2_PROCESSING_ENTRY_POINT = "/api/admin/mail/oauth2/code";
     public static final String MAIL_OAUTH2_PROCESSING_ENTRY_POINT = "/api/admin/mail/oauth2/code";

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+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.StringUtils;
+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.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.ApplicationDTO;
+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.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.ApplicationService;
+import org.thingsboard.server.dao.yunteng.service.TkOrganizationService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.HashMap;
+import java.util.List;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+
+@Api(tags = "应用管理")
+@RestController
+@TbCoreComponent
+@RequestMapping("api/yt/application")
+@RequiredArgsConstructor
+public class TkApplicationController extends BaseController {
+  private final ApplicationService applicationService;
+  private final TkOrganizationService tkOrganizationService;
+
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public TkPageData<ApplicationDTO> page(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "name", required = false) String name,
+      @RequestParam(value = "organizationId", required = false) String organizationId,
+      @RequestParam(value = ORDER_FILED, required = false) String orderBy,
+      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType) throws ThingsboardException {
+
+    HashMap<String, Object> queryMap = new HashMap<>();
+    queryMap.put(PAGE_SIZE, pageSize);
+    queryMap.put(PAGE, page);
+    queryMap.put(ORDER_FILED, orderBy);
+    queryMap.put("name", name);
+    if(StringUtils.isNotEmpty(organizationId)){
+      List<String> organizationIds = tkOrganizationService.organizationAllIds(getCurrentUser().getCurrentTenantId(),organizationId);
+      queryMap.put("organizationIds", organizationIds);
+    }
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return applicationService.page(queryMap);
+  }
+
+  @PostMapping
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseResult<ApplicationDTO> save(@RequestBody ApplicationDTO applicationDTO)
+      throws ThingsboardException {
+    ApplicationDTO newDTO =
+            applicationService.save(applicationDTO, getCurrentUser().getCurrentTenantId());
+    return ResponseResult.success(newDTO);
+  }
+
+  @DeleteMapping
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseResult<String> delete(@RequestBody DeleteDTO deleteDTO) {
+    return applicationService.delete(deleteDTO.getIds())
+        ? ResponseResult.success(FastIotConstants.StateValue.DELETE_SUCCESS)
+        : ResponseResult.failed(FastIotConstants.StateValue.DELETE_FAILED);
+  }
+
+  @PutMapping
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseResult<ApplicationDTO> update( @RequestBody ApplicationDTO applicationDTO)
+      throws ThingsboardException {
+    return ResponseResult.success(
+            applicationService.update(applicationDTO));
+  }
+
+  @GetMapping("/find")
+  public ResponseEntity<ApplicationDTO> find(String id) {
+    return ResponseEntity.ok(applicationService.getDto(id));
+  }
+}

@@ -238,7 +238,18 @@ public class TkDeviceController extends BaseController {
     return ResponseEntity.of(tkdeviceService.getDevice(getCurrentUser().getTenantId().getId(), UUID.fromString(id)));
     return ResponseEntity.of(tkdeviceService.getDevice(getCurrentUser().getTenantId().getId(), UUID.fromString(id)));
   }
   }
 
 
-  @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+
+
+  @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER','OPENAPI_USER')")
+  @PostMapping(path = {"/page"})
+  @ApiOperation("查询")
+  public TkPageData<DeviceDTO> getPage(
+          @RequestBody Map<String, Object> queryMap)
+          throws ThingsboardException {
+    return pageDevice((Integer) queryMap.get("pageSize"),(Integer) queryMap.get("page"),queryMap);
+  }
+
+  @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER','OPENAPI_USER')")
   @PostMapping(params = {PAGE_SIZE, PAGE})
   @PostMapping(params = {PAGE_SIZE, PAGE})
   @ApiOperation("查询")
   @ApiOperation("查询")
   public TkPageData<DeviceDTO> pageDevice(
   public TkPageData<DeviceDTO> pageDevice(

@@ -84,7 +84,7 @@ public class TkDeviceProfileController extends BaseController {
 
 
   @GetMapping(params = {PAGE_SIZE, PAGE})
   @GetMapping(params = {PAGE_SIZE, PAGE})
   @ApiOperation("查询")
   @ApiOperation("查询")
-  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER'},{})")
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN','CUSTOMER_USER','OPENAPI_USER'},{})")
   public TkPageData<DeviceProfileDTO> pageDeviceProfile(
   public TkPageData<DeviceProfileDTO> pageDeviceProfile(
           @RequestParam(PAGE_SIZE) int pageSize,
           @RequestParam(PAGE_SIZE) int pageSize,
           @RequestParam(PAGE) int page,
           @RequestParam(PAGE) int page,

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+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.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiDTO;
+import org.thingsboard.server.common.data.yunteng.dto.ApiMenuDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+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.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.OpenApiService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.HashMap;
+import java.util.List;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@Api(tags = "OpenApi管理")
+@RestController
+@TbCoreComponent
+@RequestMapping("api/yt/openApi")
+@RequiredArgsConstructor
+public class TkOpenApiController extends BaseController {
+  private final OpenApiService apiService;
+
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public TkPageData<OpenApiDTO> page(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "name", required = false) String name,
+      @RequestParam(value = "classify", required = false) String classify,
+      @RequestParam(value = ORDER_FILED, required = false) String orderBy,
+      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType) {
+
+    HashMap<String, Object> queryMap = new HashMap<>();
+    queryMap.put(PAGE_SIZE, pageSize);
+    queryMap.put(PAGE, page);
+    queryMap.put(ORDER_FILED, orderBy);
+    queryMap.put("name", name);
+    queryMap.put("classify", classify);
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return apiService.page(queryMap);
+  }
+
+  @PostMapping
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseResult<OpenApiDTO> save(
+      @Validated({AddGroup.class}) @RequestBody OpenApiDTO ApiDTO)
+      throws ThingsboardException {
+    OpenApiDTO newDTO =
+            apiService.save(ApiDTO, getCurrentUser().getCurrentTenantId());
+    return ResponseResult.success(newDTO);
+  }
+
+  @DeleteMapping
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseResult<String> delete(
+      @Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) {
+    return apiService.delete(deleteDTO.getIds())
+        ? ResponseResult.success(FastIotConstants.StateValue.DELETE_SUCCESS)
+        : ResponseResult.failed(FastIotConstants.StateValue.DELETE_FAILED);
+  }
+
+  @PutMapping
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseResult<OpenApiDTO> update(
+      @Validated({UpdateGroup.class}) @RequestBody OpenApiDTO ApiDTO)
+      throws ThingsboardException {
+    return ResponseResult.success(
+            apiService.update(
+            ApiDTO, getCurrentUser().getCurrentTenantId()));
+  }
+
+  @GetMapping("/find")
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseEntity<OpenApiDTO> find(String id) {
+    return ResponseEntity.ok(apiService.getDto(id));
+  }
+
+
+  @GetMapping("/getMenu")
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseEntity<List<ApiMenuDTO>> getMenu() throws ThingsboardException {
+    return ResponseEntity.ok(apiService.getMenu(getCurrentUser().getCurrentTenantId()));
+  }
+
+
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.*;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.OpenApiRecordService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.HashMap;
+import java.util.List;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@Api(tags = "调用记录管理")
+@RestController
+@TbCoreComponent
+@RequestMapping("api/yt/openApiRecord")
+@RequiredArgsConstructor
+public class TkOpenApiRecordController extends BaseController {
+  private final OpenApiRecordService openApiRecordService;
+
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public TkPageData<OpenApiRecordDTO> page(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "apiName", required = false) String apiName,
+      @RequestParam(value = "applicationName", required = false) String applicationName,
+      @RequestParam(value = "classify", required = false) String classify,
+      @RequestParam(value = "startTime", required = false) Long startTime,
+      @RequestParam(value = "endTime", required = false) Long endTime,
+      @RequestParam(value = "state", required = false) Integer state,
+      @RequestParam(value = ORDER_FILED, required = false) String orderBy,
+      @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType) throws ThingsboardException {
+
+    HashMap<String, Object> queryMap = new HashMap<>();
+    queryMap.put(PAGE_SIZE, pageSize);
+    queryMap.put(PAGE, page);
+    queryMap.put(ORDER_FILED, orderBy);
+    queryMap.put("apiName", apiName);
+    queryMap.put("applicationName", applicationName);
+    queryMap.put("startTime", startTime);
+    queryMap.put("endTime", endTime);
+    queryMap.put("state", state);
+    queryMap.put("classify", classify);
+    queryMap.put("tenantId", getCurrentUser().getTenantId().toString());
+    checkTimeAndPut(queryMap,startTime,endTime);
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return openApiRecordService.page(queryMap);
+  }
+
+  @GetMapping("/find")
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseEntity<OpenApiRecordDTO> find(String id) {
+    return ResponseEntity.ok(openApiRecordService.getDto(id));
+  }
+
+  @GetMapping("/getTop")
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  public ResponseEntity<OpenApiRecordTopAllDTO> getTop() throws ThingsboardException {
+    return ResponseEntity.ok(openApiRecordService.getTop(getCurrentUser().getTenantId().toString()));
+  }
+
+  @GetMapping("/getClassify")
+  @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{})")
+  @ApiImplicitParams(value = {
+          @ApiImplicitParam(name = "type", value = "统计类型 hour按小时;week按7天;month按30天" ,required = true)
+  })
+  public ResponseEntity<List<OpenApiRecordClassifyAllDTO>> getClassify(
+          @RequestParam(value = "type" ) String type
+  ) throws ThingsboardException {
+    return ResponseEntity.ok(openApiRecordService.getClassify(getCurrentUser().getTenantId().toString(), type));
+  }
+
+
+  @GetMapping("/getPage")
+  public TkPageData<OpenApiRecordTopDTO> getPage(
+          @RequestParam(PAGE_SIZE) int pageSize,
+          @RequestParam(PAGE) int page) throws ThingsboardException {
+    return openApiRecordService.getPage(getCurrentUser().getTenantId().toString(),page, pageSize);
+  }
+
+}

@@ -4,11 +4,13 @@ import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
 import io.swagger.annotations.ApiResponses;
+import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.transaction.annotation.Transactional;
 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.Customer;
 import org.thingsboard.server.common.data.Customer;
@@ -256,7 +258,7 @@ public class TkUserController extends AbstractUserAccount {
   @PostMapping("save_tenant_admin")
   @PostMapping("save_tenant_admin")
   public UserDTO saveTenantAdmin(@Validated(AddGroup.class) @RequestBody UserDTO userDTO)
   public UserDTO saveTenantAdmin(@Validated(AddGroup.class) @RequestBody UserDTO userDTO)
       throws ThingsboardException {
       throws ThingsboardException {
-      return saveTenant(userDTO);
+      return saveTenant(userDTO,false);
   }
   }
 
 
   @PreAuthorize(
   @PreAuthorize(
@@ -264,15 +266,19 @@ public class TkUserController extends AbstractUserAccount {
   @PostMapping("save_common_tenant")
   @PostMapping("save_common_tenant")
   public UserDTO saveCommonTenant(@Validated(AddGroup.class) @RequestBody UserDTO userDTO)
   public UserDTO saveCommonTenant(@Validated(AddGroup.class) @RequestBody UserDTO userDTO)
           throws ThingsboardException {
           throws ThingsboardException {
-    return saveTenant(userDTO);
+    return saveTenant(userDTO,false);
   }
   }
 
 
-  public UserDTO saveTenant(UserDTO userDTO) throws ThingsboardException {
+  @Transactional
+  public UserDTO saveTenant(UserDTO userDTO,Boolean isOpenApi) throws ThingsboardException {
     if (StringUtils.isEmpty(userDTO.getTenantId())) {
     if (StringUtils.isEmpty(userDTO.getTenantId())) {
       throw new TkDataValidationException(MessageUtils.message(ErrorMessage.INVALID_PARAMETER.getI18nCode()));
       throw new TkDataValidationException(MessageUtils.message(ErrorMessage.INVALID_PARAMETER.getI18nCode()));
     }
     }
-    userService.validateUserNameAndPhoneNumberAndEmail(userDTO);
-    userService.validateTenantRole(userDTO.getTenantId());
+    if(!isOpenApi){
+      userService.validateUserNameAndPhoneNumberAndEmail(userDTO);
+      userService.validateTenantRole(userDTO.getTenantId());
+    }
+
     // 租户角色不存在，会留存脏数据
     // 租户角色不存在，会留存脏数据
     TenantId tenantId = TenantId.fromUUID(UUID.fromString(userDTO.getTenantId()));
     TenantId tenantId = TenantId.fromUUID(UUID.fromString(userDTO.getTenantId()));
     // 创建TB的租户管理员
     // 创建TB的租户管理员
@@ -280,15 +286,26 @@ public class TkUserController extends AbstractUserAccount {
     User tbUser = new User();
     User tbUser = new User();
     // 只有新增才调用TB
     // 只有新增才调用TB
     if (null == userDTO.getId()) {
     if (null == userDTO.getId()) {
-      tbUser = createTBUser(tbUser, userDTO, tenantId, customerId, Authority.TENANT_ADMIN);
+      Authority authority;
+      if(isOpenApi){
+        authority = Authority.OPENAPI_USER;
+        userDTO.setActivateToken(RandomStringUtils.randomAlphabetic(10));
+      }else{
+        authority = Authority.TENANT_ADMIN;
+      }
+      tbUser = createTBUser(tbUser, userDTO, tenantId, customerId,authority);
       userDTO.setTbUser(tbUser.getId().toString());
       userDTO.setTbUser(tbUser.getId().toString());
       // 激活租户管理员
       // 激活租户管理员
       activeTBUser(
       activeTBUser(
               tbUser.getId(), accountProperties.getDefaultPassword(), tbUser.getTenantId(), true);
               tbUser.getId(), accountProperties.getDefaultPassword(), tbUser.getTenantId(), true);
     }
     }
+    boolean ptSysadmin = false;
+    if(!isOpenApi){
+      ptSysadmin =getCurrentUser().isPtSysadmin();
+    }
     UserDTO result =
     UserDTO result =
         userService.saveTenantAdmin(
         userService.saveTenantAdmin(
-            userDTO, getCurrentUser().isPtSysadmin(), tenantId.getId().toString());
+            userDTO, ptSysadmin, tenantId.getId().toString());
     userService.updateTenantAdminUserCredentials(
     userService.updateTenantAdminUserCredentials(
         List.of(new UserId(UUID.fromString(result.getTbUser()))),
         List.of(new UserId(UUID.fromString(result.getTbUser()))),
         userDTO.getTenantId(),
         userDTO.getTenantId(),
@@ -443,7 +460,7 @@ public class TkUserController extends AbstractUserAccount {
    * @param userId 用户ID
    * @param userId 用户ID
    * @throws ThingsboardException tb运行异常
    * @throws ThingsboardException tb运行异常
    */
    */
-  private void activeTBUser(UserId userId, String password, TenantId tenantId, boolean isPtAdmin)
+  protected void activeTBUser(UserId userId, String password, TenantId tenantId, boolean isPtAdmin)
       throws ThingsboardException {
       throws ThingsboardException {
     // 1、获取UserCredentials 并获取activateToken
     // 1、获取UserCredentials 并获取activateToken
     if (!isPtAdmin) {
     if (!isPtAdmin) {
@@ -473,8 +490,8 @@ public class TkUserController extends AbstractUserAccount {
    * @return 用户
    * @return 用户
    * @throws ThingsboardException tb运行异常
    * @throws ThingsboardException tb运行异常
    */
    */
-  private User createTBUser(
-      User tbUser, UserDTO userDTO, TenantId tenantId, CustomerId customerId, Authority authority){
+  protected User createTBUser(
+          User tbUser, UserDTO userDTO, TenantId tenantId, CustomerId customerId, Authority authority){
     tbUser.setAuthority(authority);
     tbUser.setAuthority(authority);
     tbUser.setTenantId(tenantId);
     tbUser.setTenantId(tenantId);
     tbUser.setCustomerId(customerId);
     tbUser.setCustomerId(customerId);

+package org.thingsboard.server.controller.yunteng.openApi;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.*;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.client.RestTemplate;
+import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.ApplicationDTO;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiContrlooerDTO;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiDTO;
+import org.thingsboard.server.common.data.yunteng.dto.UserDTO;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.controller.yunteng.TkThirdPlatformController;
+import org.thingsboard.server.controller.yunteng.TkUserController;
+import org.thingsboard.server.dao.yunteng.entities.TkOpenApiRecordEntity;
+import org.thingsboard.server.dao.yunteng.service.ApplicationService;
+import org.thingsboard.server.dao.yunteng.service.OpenApiRecordService;
+import org.thingsboard.server.dao.yunteng.service.OpenApiService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.security.auth.yunteng.TkLoginResponse;
+import org.thingsboard.server.utils.MiscUtils;
+
+import javax.servlet.http.HttpServletRequest;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+@Api(tags = "OpenApi接口")
+@RestController
+@TbCoreComponent
+@RequestMapping("/api/yt/openApi")
+@RequiredArgsConstructor
+@Slf4j
+public class OpenApiController extends BaseController {
+
+  private final ApplicationService applicationService;
+  private final TkThirdPlatformController tkThirdPlatformController;
+  private final TkUserController tkUserController;
+  private final RestTemplate restTemplate = new RestTemplate();
+  private final OpenApiService openApiService;
+  private final OpenApiRecordService openApiRecordService;
+
+
+  @GetMapping("/getToken")
+  @ApiOperation(value = "获取token与刷新token")
+  public TkLoginResponse getToken(String key ,String secret) throws ThingsboardException {
+    ApplicationDTO app =  applicationService.getByKeyAndSecret(key,secret);
+    String userId = null;
+    //如果第一次获取token则新建用户并且返回token
+    if(StringUtils.isEmpty(app.getUserId())){
+      UserDTO userDTO = new UserDTO().newOpenApiUser(app.getTenantId(),app.getKey());
+      tkUserController.saveTenant(userDTO,true);
+      userId =userDTO.getId();
+      app.setUserId(userId);
+      applicationService.update(app);
+    }else{
+      userId =app.getUserId();
+    }
+   return tkThirdPlatformController.unionidLogin(userId);
+  }
+
+
+  @PostMapping("/common/{method}/{apiId}")
+  @ApiOperation(value = "openApi公共接口")
+  public ResponseEntity<Object> callOtherController(
+         @PathVariable String method,
+         @PathVariable String apiId,
+         @RequestBody (required = false) Object body,// 支持对象或Map
+         HttpServletRequest request
+        ) throws  ThingsboardException {
+    TkOpenApiRecordEntity record = new TkOpenApiRecordEntity("200", LocalDateTime.now(), 1, "");
+    try {
+      OpenApiDTO api = openApiService.getDto(apiId);
+      ApplicationDTO appDto = applicationService.getDtoByUserId(getCurrentUser().getCurrentUserId());
+      //记录日志
+      setRecord(api,appDto,record);
+      if (!appDto.getApiList().contains(api.getId())) {
+        throw new RuntimeException("没有权限");
+      }
+      // 构建URL
+      String url = MiscUtils.constructBaseUrl(request) + api.getUri();
+      // 如果是 GET 请求，附加查询参数
+      if (method.equals(HttpMethod.GET.name()) && body != null) {
+        StringBuilder queryBuilder = new StringBuilder("?");
+        Map<String, String> queryParams = (Map<String, String>) body;
+        queryParams.forEach((key, value) -> queryBuilder.append(key).append("=").append(value).append("&"));
+        url += queryBuilder.toString();
+      }
+      // 创建 HttpHeaders 对象并设置 token
+      HttpHeaders headers = new HttpHeaders();
+      // 从 Authorization header 中提取 token
+      String token = request.getHeader("x-authorization");
+      headers.set("x-authorization", token); // 设置 Authorization header
+      // 创建 HttpEntity 对象，将 headers 和请求体一起传递
+      HttpEntity<String> entity = new HttpEntity<>(headers);
+      // 根据请求类型判断处理逻辑
+      if (HttpMethod.GET.name().equalsIgnoreCase(method)) {
+        ResponseEntity<Object> response = restTemplate.exchange(
+                url,
+                HttpMethod.GET,
+                entity,
+                Object.class
+        );
+        return response;
+      } else if (HttpMethod.POST.name().equalsIgnoreCase(method)) {
+        //如果POST请求遇到url中拼接参数，需要自己重新写接口调用 自己拼接进去（API中配置自己写的接口）
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<Object> requestEntity = new HttpEntity<>(body, headers);
+        return restTemplate.postForEntity(url, requestEntity, Object.class);
+      }
+    } catch (Exception e) {
+      record.setCode(e.toString());
+      record.setState(0);
+      record.setMessage(e.getMessage());
+      return new ResponseEntity<>(e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
+    } finally {
+      openApiRecordService.save(record, getCurrentUser().getTenantId().toString());
+    }
+
+    // 默认返回 405 Method Not Allowed
+    return new ResponseEntity<>(HttpStatus.METHOD_NOT_ALLOWED);
+  }
+
+  @PostMapping("/getApi")
+  @ApiOperation(value = "获取可调用api")
+  public ResponseEntity<List<OpenApiContrlooerDTO>> callOtherController(HttpServletRequest request) throws  ThingsboardException {
+    ApplicationDTO appDto = applicationService.getDtoByUserId(getCurrentUser().getCurrentUserId());
+    return ResponseEntity.ok(openApiService.getByListId(appDto.getApiList()));
+  }
+
+  void setRecord(OpenApiDTO api,ApplicationDTO app,TkOpenApiRecordEntity record) throws ThingsboardException {
+    record.setApiId(api.getId());
+    record.setApiName(api.getName());
+    record.setApplicationId(app.getId());
+    record.setApplicationName(app.getName());
+    record.setClassify(api.getClassify());
+    record.setTenantId(getCurrentUser().getTenantId().toString());
+  }
+
+}

@@ -23,6 +23,7 @@ public enum Authority {
 	//thingskit
 	//thingskit
 	PLATFORM_USER(3),
 	PLATFORM_USER(3),
 	COMMON_TENANT(4),
 	COMMON_TENANT(4),
+    OPENAPI_USER(5),
     REFRESH_TOKEN(10),
     REFRESH_TOKEN(10),
     PRE_VERIFICATION_TOKEN(11);
     PRE_VERIFICATION_TOKEN(11);
 
 

@@ -312,6 +312,7 @@ public interface FastIotConstants {
     public static final int TWO = 2;
     public static final int TWO = 2;
     public static final int THREE = 3;
     public static final int THREE = 3;
     public static final int FOUR = 4;
     public static final int FOUR = 4;
+    public static final int FIVE = 5;
     public static final int TEN = 10;
     public static final int TEN = 10;
   }
   }
 
 
@@ -361,6 +362,8 @@ public interface FastIotConstants {
     public static final int IS_CUSTOMER_USER = 3;
     public static final int IS_CUSTOMER_USER = 3;
     /** 租户下的子管理员 */
     /** 租户下的子管理员 */
     public static final int IS_CUSTOMER_TENANT = 4;
     public static final int IS_CUSTOMER_TENANT = 4;
+    /** OpenApi用户 */
+    public static final int IS_OPENAPI_USER= 5;
   }
   }
   class Rpc{
   class Rpc{
 
 

@@ -140,6 +140,20 @@ public final class ModelConstants {
 
 
     /** 视频通道表 */
     /** 视频通道表 */
     public static final String TK_VIDEO_CHANNEL_NAME = "tk_video_channel";
     public static final String TK_VIDEO_CHANNEL_NAME = "tk_video_channel";
+
+    /** 应用表 */
+    public static final String TK_APPLICATION = "tk_application";
+
+    /** api表 */
+    public static final String TK_OPEN_API = "tk_open_api";
+
+    /** 应用api表 */
+    public static final String TK_APPLICATION_API = "tk_application_api";
+
+    /** api调用记录表 */
+    public static final String TK_OPEN_API_RECORD = "tk_open_api_record";
+
+
   }
   }
 
 
   public static class TableFields {
   public static class TableFields {

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class ApiMenuDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "名称")
+  private String name;
+
+  @ApiModelProperty(value = "api集合")
+  /**文档地址*/
+  private List<OpenApiDTO> apis;
+
+  public ApiMenuDTO(String name, List<OpenApiDTO> apis) {
+    this.name  = name;
+    this.apis  = apis;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+@Data
+public class ApplicationDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "名称")
+  /** 名称 */
+  private String name;
+  @ApiModelProperty(value = "key")
+  /** key */
+  private String key;
+
+  @ApiModelProperty(value = "secret")
+  /** secret */
+  private String secret;
+  @ApiModelProperty(value = "组织id")
+  /**组织id*/
+  private String organizationId;
+  @ApiModelProperty(value = "组织名称")
+  /**组织名称*/
+  private String organizationName;
+
+  @ApiModelProperty(value = "api集合")
+  /**组织名称*/
+  private List<String> apiList;
+
+  private String userId;
+
+  private String tenantId;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+@Data
+public class OpenApiContrlooerDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "名称")
+  private String name;
+  @ApiModelProperty(value = "请求方式")
+  /** 请求方式 */
+  private Integer requestMethod;
+
+  @ApiModelProperty(value = "文档地址")
+  /**文档地址*/
+  private String documentUrl;
+
+  @ApiModelProperty(value = "调用参数")
+  /**调用参数*/
+  private JsonNode param;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+@Data
+public class OpenApiDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "名称")
+  private String name;
+
+  @ApiModelProperty(value = "所属分类")
+  /** 所属分类 */
+  private ApplicationApiEnum classify;
+
+  @ApiModelProperty(value = "请求方式")
+  /** 请求方式 */
+  private Integer requestMethod;
+
+  @ApiModelProperty(value = "请求路由")
+  /**请求路由*/
+  private String uri;
+
+  @ApiModelProperty(value = "文档地址")
+  /**文档地址*/
+  private String documentUrl;
+
+  @ApiModelProperty(value = "调用参数")
+  /**调用参数*/
+  private JsonNode param;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Data
+public class OpenApiRecordClassifyAllDTO {
+
+  @ApiModelProperty(value = "类型")
+  private ApplicationApiEnum classify;
+
+  @ApiModelProperty(value = "类型集合")
+  private List<OpenApiRecordClassifyDTO> dts;
+
+  public OpenApiRecordClassifyAllDTO(ApplicationApiEnum classify, List<OpenApiRecordClassifyDTO> dts) {
+    this.classify  = classify;
+    this.dts  = dts;
+  }
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+import java.time.LocalDateTime;
+
+@Data
+public class OpenApiRecordClassifyDTO {
+
+  @ApiModelProperty(value = "类型")
+  private ApplicationApiEnum classify;
+
+  @ApiModelProperty(value = "时间")
+  private LocalDateTime time;
+
+  @ApiModelProperty(value = "调用数量")
+  private Integer count;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+import java.time.LocalDateTime;
+
+@Data
+public class OpenApiRecordDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "ApiId")
+  /** ApiId */
+  private String apiId;
+  @ApiModelProperty(value = "名称")
+  /** 名称 */
+  private String apiName;
+  @ApiModelProperty(value = "应用id")
+  /** 应用id */
+  private String applicationId;
+  @ApiModelProperty(value = "应用名称")
+  /** 应用名称 */
+  private String applicationName;
+  @ApiModelProperty(value = "所属分类")
+  /** 所属分类 */
+  private ApplicationApiEnum classify;
+  @ApiModelProperty(value = "相应code")
+  /**相应code*/
+  private String code;
+  @ApiModelProperty(value = "请求时间")
+  /**请求时间*/
+  private LocalDateTime requestTime;
+  @ApiModelProperty(value = "状态 0成功 1失败")
+  /**状态 0成功 1失败*/
+  private Integer state;
+  @ApiModelProperty(value = "错误信息")
+  /**错误信息*/
+  private String message;
+
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.dto.BaseDTO;
+
+import java.util.List;
+
+@Data
+public class OpenApiRecordTopAllDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "调用总数")
+  private Integer count;
+
+  @ApiModelProperty(value = "成功总数")
+  private Integer successCount;
+
+  @ApiModelProperty(value = "失败总数")
+  private Integer failCount;
+
+  @ApiModelProperty(value = "调用占比")
+  private List<OpenApiRecordTopDTO> tops;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+@Data
+public class OpenApiRecordTopDTO extends BaseDTO {
+
+  @ApiModelProperty(value = "应用名称")
+  private String name;
+
+  @ApiModelProperty(value = "调用数量")
+  private Integer recordNum;
+
+  @ApiModelProperty(value = "调用数量")
+  private Integer successCount;
+
+  @ApiModelProperty(value = "调用数量")
+  private Integer failureCount;
+
+
+  @ApiModelProperty(value = "调用占比")
+  private Double recordProportion;
+}

@@ -79,9 +79,21 @@ public class UserDTO extends BaseDTO {
   @JsonInclude(JsonInclude.Include.NON_NULL)
   @JsonInclude(JsonInclude.Include.NON_NULL)
   private Set<PlainRolesDTO> roles;
   private Set<PlainRolesDTO> roles;
 
 
-  @ApiModelProperty(value = "角色级别：0：超级管理员；1：平台管理员 2：租户账号(租户管理员) 3：租户下的账号(客户) 4:普通租户")
+  @ApiModelProperty(value = "角色级别：0：超级管理员；1：平台管理员 2：租户账号(租户管理员) 3：租户下的账号(客户) 4:普通租户 5:OpenApi用户")
   private Integer level;
   private Integer level;
 
 
   @ApiModelProperty(value = "备注")
   @ApiModelProperty(value = "备注")
   private String remark;
   private String remark;
+
+  public UserDTO newOpenApiUser(String tenantId ,String userName){
+    UserDTO dto = new UserDTO();
+    dto.setTenantId(tenantId);
+    dto.setUsername(userName);
+    dto.setEnabled(true);
+    dto.setLevel(5);
+    String[] roleIds = { "ccf77a30-ad68-42a3-a313-312acd0c4083"};
+    dto.setRoleIds(roleIds);
+    return dto;
+  }
+
 }
 }

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum ApplicationApiEnum {
+    DEVICE,//设备管理
+    ALARM,//告警管理
+    VIDEO,//视频管理
+    STATISTICS,//统计功能
+    SYSTEM//系统管理
+}

@@ -16,5 +16,9 @@ public enum RoleEnum {
   /**
   /**
    * 平台系统管理员
    * 平台系统管理员
    */
    */
-  PLATFORM_ADMIN;
+  PLATFORM_ADMIN,
+  /**
+   * openapi用户
+   */
+  OPENAPI_USER;
 }
 }

+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;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName(ModelConstants.Table.TK_APPLICATION_API)
+public class TkApplicationApiEntity {
+
+  /** 应用id */
+  private String applicationId;
+
+  /** apiId */
+  private String apiId;
+
+  public TkApplicationApiEntity(String applicationId, String apiId) {
+    this.applicationId  = applicationId;
+    this.apiId  = apiId;
+  }
+}

+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;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName(ModelConstants.Table.TK_APPLICATION)
+public class TkApplicationEntity extends TenantBaseEntity {
+
+  private static final long serialVersionUID = -5381101569947327544L;
+
+  /** 名称 */
+  private String name;
+
+  /** key */
+  private String key;
+
+  /** secret */
+  private String secret;
+
+  /** userId */
+  private String userId;
+
+  /**组织id*/
+  private String organizationId;
+
+}

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName(ModelConstants.Table.TK_OPEN_API)
+public class TkOpenApiEntity extends TenantBaseEntity {
+
+  private static final long serialVersionUID = -5381101569947327544L;
+
+  /** 名称 */
+  private String name;
+
+  /** 所属分类 */
+  private ApplicationApiEnum classify;
+
+  /** 请求方式 */
+  private Integer requestMethod;
+
+  /**请求路由*/
+  private String uri;
+
+  /**文档地址*/
+  private String documentUrl;
+
+  /**调用参数*/
+  private JsonNode param;
+
+}

+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;
+import org.thingsboard.server.common.data.yunteng.enums.ApplicationApiEnum;
+
+import java.time.LocalDateTime;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName(ModelConstants.Table.TK_OPEN_API_RECORD)
+public class TkOpenApiRecordEntity extends TenantBaseEntity {
+
+  private static final long serialVersionUID = -5381101569947327544L;
+
+  /** ApiId */
+  private String apiId;
+
+  /** 名称 */
+  private String apiName;
+
+  /** 应用id */
+  private String applicationId;
+
+  /** 应用名称 */
+  private String applicationName;
+
+  /** 所属分类 */
+  private ApplicationApiEnum classify;
+
+  /**相应code*/
+  private String code;
+
+  /**请求时间*/
+  private LocalDateTime requestTime;
+
+  /**状态 0成功 1失败*/
+  private Integer state;
+
+  /**错误信息*/
+  private String message;
+
+  public TkOpenApiRecordEntity(String code, LocalDateTime requestTime, Integer state, String message) {
+    this.code = code;
+    this.requestTime = requestTime;
+    this.state = state;
+    this.message = message;
+  }
+  public TkOpenApiRecordEntity() {
+
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.dto.ApplicationDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkApplicationApiEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkApplicationEntity;
+import org.thingsboard.server.dao.yunteng.mapper.ApplicationApiMapper;
+import org.thingsboard.server.dao.yunteng.mapper.ApplicationMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.ApplicationService;
+
+import java.security.SecureRandom;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ApplicationServiceImpl extends AbstractBaseService<ApplicationMapper, TkApplicationEntity>
+    implements ApplicationService {
+
+  private final ApplicationApiMapper applicationApiMapper;
+  private static final int KEY_LENGTH = 32;  // 32位字符
+  private static final SecureRandom secureRandom = new SecureRandom();
+  private static final Base64.Encoder base64Encoder = Base64.getUrlEncoder().withoutPadding();
+
+
+  @Override
+  public ApplicationDTO getDto(String id) {
+    TkApplicationEntity entity  = baseMapper.selectById(id);
+    ApplicationDTO dto = new ApplicationDTO();
+    entity.copyToDTO(dto);
+    List<TkApplicationApiEntity> apis  = applicationApiMapper.selectList(
+            new LambdaQueryWrapper<TkApplicationApiEntity>()
+            .eq(TkApplicationApiEntity::getApplicationId, id));
+    if(!apis.isEmpty()){
+      dto.setApiList(apis.stream().map(r ->  r.getApiId()).collect(Collectors.toList()));
+    }
+    return dto;
+  }
+
+  @Override
+  public TkPageData<ApplicationDTO> page(Map<String, Object> queryMap) {
+    IPage<TkApplicationEntity> iPage =
+        baseMapper.selectPage(
+            getPage(queryMap, "create_time", false),
+            new QueryWrapper<TkApplicationEntity>()
+                .lambda()
+                .eq(
+                        queryMap.get("tenantId") != null,
+                        TkApplicationEntity::getTenantId,
+                        String.valueOf(queryMap.get("tenantId")))
+                .like(
+                    queryMap.get("name") != null,
+                    TkApplicationEntity::getName,
+                    String.valueOf(queryMap.get("name")))
+                .in(
+                    queryMap.get("organizationIds") != null,
+                    TkApplicationEntity::getOrganizationId,
+                        (List<String>)queryMap.get("organizationIds")));
+    return getPageData(iPage, ApplicationDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public ApplicationDTO save(ApplicationDTO dto, String tenantId) {
+    TkApplicationEntity application = new TkApplicationEntity();
+    dto.copyToEntity(application);
+    application.setTenantId(tenantId);
+    application.setKey(generateRandomString(KEY_LENGTH));
+    application.setSecret(generateRandomString(KEY_LENGTH));
+    baseMapper.insert(application);
+    if(null!=dto.getApiList()&&!dto.getApiList().isEmpty()){
+      dto.getApiList().stream().forEach(api -> {
+        applicationApiMapper.insert(new TkApplicationApiEntity(application.getId(),api));
+      });
+    }
+
+    return dto;
+  }
+
+  @Override
+  @Transactional
+  public boolean delete(Set<String> applicationIds) {
+    applicationApiMapper.deleteByAppIds(applicationIds);
+    return baseMapper.deleteBatchIds(applicationIds) > 0;
+  }
+
+  @Override
+  @Transactional
+  public ApplicationDTO update(ApplicationDTO dto) {
+    TkApplicationEntity application = baseMapper.selectById(dto.getId());
+    dto.copyToEntity(application);
+    baseMapper.updateById(application);
+    //先删除关联关系再新增
+    applicationApiMapper.deleteByAppIds(Collections.singleton(dto.getId()));
+    if(null!=dto.getApiList()&&!dto.getApiList().isEmpty()){
+      dto.getApiList().stream().forEach(api -> {
+        applicationApiMapper.insert(new TkApplicationApiEntity(dto.getId(),api));
+      });
+    }
+    return dto;
+  }
+
+  @Override
+  public ApplicationDTO getByKeyAndSecret(String key, String secret) {
+    TkApplicationEntity entity  =  baseMapper.selectOne(
+            new LambdaQueryWrapper<TkApplicationEntity>()
+                    .eq(TkApplicationEntity::getKey, key)
+                    .eq(TkApplicationEntity::getSecret,secret));
+    if(null == entity){
+        throw  new RuntimeException("应用不存在");
+    }
+    ApplicationDTO dto  = new ApplicationDTO();
+    entity.copyToDTO(dto);
+    return dto;
+  }
+
+  @Override
+  public ApplicationDTO getDtoByUserId(String userId) {
+    TkApplicationEntity entity  =  baseMapper.selectOne(
+            new LambdaQueryWrapper<TkApplicationEntity>()
+                    .eq(TkApplicationEntity::getUserId, userId));
+    if(null == entity){
+      throw  new RuntimeException("应用不存在");
+    }
+    ApplicationDTO dto = new ApplicationDTO();
+    entity.copyToDTO(dto);
+    List<TkApplicationApiEntity> apis  = applicationApiMapper.selectList(
+            new LambdaQueryWrapper<TkApplicationApiEntity>()
+                    .eq(TkApplicationApiEntity::getApplicationId, entity.getId()));
+    if(!apis.isEmpty()){
+      dto.setApiList(apis.stream().map(r ->  r.getApiId()).collect(Collectors.toList()));
+    }
+    return dto;
+  }
+  // 生成指定长度的随机字符串
+  private static String generateRandomString(int length) {
+    byte[] randomBytes = new byte[length];
+    secureRandom.nextBytes(randomBytes);
+    return base64Encoder.encodeToString(randomBytes).substring(0, length);
+  }
+
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiContrlooerDTO;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiDTO;
+import org.thingsboard.server.common.data.yunteng.dto.ApiMenuDTO;
+import org.thingsboard.server.common.data.yunteng.utils.CopyUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkOpenApiEntity;
+import org.thingsboard.server.dao.yunteng.mapper.OpenApiMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.OpenApiService;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class OpenApiImpl extends AbstractBaseService<OpenApiMapper, TkOpenApiEntity>
+    implements OpenApiService {
+
+
+  @Override
+  public OpenApiDTO getDto(String id) {
+    TkOpenApiEntity entity  = baseMapper.selectById(id);
+    if(null == entity){
+      throw  new RuntimeException("Api不存在");
+    }
+    OpenApiDTO dto = new OpenApiDTO();
+    entity.copyToDTO(dto);
+    return dto;
+  }
+
+  @Override
+  public TkPageData<OpenApiDTO> page(Map<String, Object> queryMap) {
+    IPage<TkOpenApiEntity> iPage =
+        baseMapper.selectPage(
+            getPage(queryMap, "create_time", false),
+            new QueryWrapper<TkOpenApiEntity>()
+                .lambda()
+                .like(
+                    queryMap.get("name") != null,
+                    TkOpenApiEntity::getName,
+                    String.valueOf(queryMap.get("name")))
+                .like(
+                    queryMap.get("classify") != null,
+                    TkOpenApiEntity::getClassify,
+                    String.valueOf(queryMap.get("classify"))));
+    return getPageData(iPage, OpenApiDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public OpenApiDTO save(OpenApiDTO dto, String tenantId) {
+    TkOpenApiEntity openApi = new TkOpenApiEntity();
+    dto.copyToEntity(openApi);
+    openApi.setTenantId(tenantId);
+    baseMapper.insert(openApi);
+    return dto;
+  }
+
+  @Override
+  @Transactional
+  public boolean delete(Set<String> apiIds) {
+    return baseMapper.deleteBatchIds(apiIds) > 0;
+  }
+
+  @Override
+  @Transactional
+  public OpenApiDTO update(OpenApiDTO dto, String tenantId) {
+    TkOpenApiEntity openApi = baseMapper.selectById(dto.getId());
+    dto.copyToEntity(openApi);
+    baseMapper.updateById(openApi);
+    return dto;
+  }
+
+  @Override
+  public List<ApiMenuDTO> getMenu(String tenantId) {
+    List<TkOpenApiEntity> list  = baseMapper.selectList(new LambdaQueryWrapper<TkOpenApiEntity>()
+            .eq(TkOpenApiEntity::getTenantId,tenantId));
+    List<ApiMenuDTO> listDto =  new ArrayList<>();
+    if(!list.isEmpty()){
+      for (TkOpenApiEntity entity: list) {
+        OpenApiDTO apiDTO = new OpenApiDTO();
+        entity.copyToDTO(apiDTO);
+        // 查找 listDto 中是否已有相同 enum 的 entity
+        ApiMenuDTO existingDto = listDto.stream()
+                .filter(dto -> dto.getName().equals(entity.getClassify().name()))
+                .findFirst()
+                .orElse(null);
+        if (existingDto != null) {
+          // 如果存在，则将 entity 添加到对应的 dto
+          existingDto.getApis().add(apiDTO);
+        } else {
+          // 如果不存在，则创建新的 dto 并添加到 dtoList
+          List<OpenApiDTO> newEntityList = new ArrayList<>();
+          newEntityList.add(apiDTO);
+          ApiMenuDTO newDto = new ApiMenuDTO(entity.getClassify().name(), newEntityList);
+          listDto.add(newDto);
+        }
+      }
+    }
+    return listDto;
+  }
+
+  @Override
+  public List<OpenApiContrlooerDTO> getByListId(List<String> ids) {
+   List<TkOpenApiEntity> list  =  baseMapper.selectList(new LambdaQueryWrapper<TkOpenApiEntity>()
+      .in(TkOpenApiEntity::getId,ids));
+    return  list.stream().map(entity -> {
+              return CopyUtils.copyAndReturn(entity, new OpenApiContrlooerDTO());
+            }
+    ).collect(Collectors.toList());
+  }
+
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.dto.*;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkApplicationEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkOpenApiRecordEntity;
+import org.thingsboard.server.dao.yunteng.mapper.ApplicationMapper;
+import org.thingsboard.server.dao.yunteng.mapper.OpenApiRecordMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.OpenApiRecordService;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class OpenApiRecordImpl extends AbstractBaseService<OpenApiRecordMapper, TkOpenApiRecordEntity>
+    implements OpenApiRecordService {
+
+  private final ApplicationMapper applicationMapper;
+  @Override
+  public OpenApiRecordDTO getDto(String id) {
+    TkOpenApiRecordEntity entity  = baseMapper.selectById(id);
+    OpenApiRecordDTO dto = new OpenApiRecordDTO();
+    entity.copyToDTO(dto);
+    return dto;
+  }
+
+  @Override
+  public TkPageData<OpenApiRecordDTO> page(Map<String, Object> queryMap) {
+    IPage<TkOpenApiRecordEntity> iPage =
+        baseMapper.selectPage(
+            getPage(queryMap, "request_time", false),
+            new QueryWrapper<TkOpenApiRecordEntity>()
+                .lambda()
+                .eq(
+                        queryMap.get("tenantId") != null,
+                        TkOpenApiRecordEntity::getTenantId,
+                        String.valueOf(queryMap.get("tenantId")))
+                .like(
+                    queryMap.get("apiName") != null,
+                        TkOpenApiRecordEntity::getApiName,
+                    String.valueOf(queryMap.get("apiName")))
+                .like(
+                        queryMap.get("applicationName") != null,
+                        TkOpenApiRecordEntity::getApplicationName,
+                        String.valueOf(queryMap.get("applicationName")))
+                .eq(
+                    queryMap.get("classify") != null,
+                        TkOpenApiRecordEntity::getClassify,
+                    String.valueOf(queryMap.get("classify")))
+                .ge(
+                        queryMap.get("startTime") != null,
+                        TkOpenApiRecordEntity::getRequestTime,
+                        queryMap.get("startTime"))
+                .le(
+                        queryMap.get("endTime") != null,
+                        TkOpenApiRecordEntity::getRequestTime,
+                        queryMap.get("endTime"))
+                .eq(
+                    queryMap.get("state") != null,
+                    TkOpenApiRecordEntity::getState,
+                    queryMap.get("state")));
+    return getPageData(iPage, OpenApiRecordDTO.class);
+  }
+
+
+  @Override
+  @Transactional
+  public int save(TkOpenApiRecordEntity entity, String tenantId) {
+    entity.setTenantId(tenantId);
+    return  baseMapper.insert(entity);
+  }
+
+  @Override
+  public OpenApiRecordTopAllDTO getTop(String tenantId) {
+    List<OpenApiRecordTopDTO> tops =  baseMapper.getTop(tenantId,null,null);
+    OpenApiRecordTopAllDTO dto = new OpenApiRecordTopAllDTO();
+    AtomicInteger count = new AtomicInteger();
+    AtomicInteger successCount = new AtomicInteger();
+    AtomicInteger failCount = new AtomicInteger();
+    if(null!=tops&&!tops.isEmpty()){
+      dto.setTops(tops);
+      tops.stream().forEach(top-> {
+                count.set(count.get() + top.getRecordNum());
+                successCount.set(successCount.get() + top.getSuccessCount());
+                failCount.set(failCount.get() + top.getFailureCount());
+              }
+      );
+    }
+    dto.setCount(count.get());
+    dto.setSuccessCount(successCount.get());
+    dto.setFailCount(failCount.get());
+    return dto;
+  }
+
+  @Override
+  public TkPageData<OpenApiRecordTopDTO> getPage(String tenantId,Integer page,Integer pageSize) {
+    List<OpenApiRecordTopDTO> tops =  baseMapper.getTop(tenantId,page,pageSize);
+    Long count  = applicationMapper.selectCount(new LambdaQueryWrapper<TkApplicationEntity>()
+            .eq(TkApplicationEntity::getTenantId, tenantId));
+    return new TkPageData<>(tops, count);
+  }
+
+  @Override
+  public  List<OpenApiRecordClassifyAllDTO> getClassify(String tenantId,String type) {
+    List<OpenApiRecordClassifyDTO> tops =  baseMapper.getClassify(tenantId,type);
+    List<OpenApiRecordClassifyAllDTO> allList =new ArrayList<>();
+    if(!tops.isEmpty()){
+      for (OpenApiRecordClassifyDTO entity: tops) {
+        // 查找 listDto 中是否已有相同 enum 的 entity
+        OpenApiRecordClassifyAllDTO existingDto = allList.stream()
+                .filter(dto -> dto.getClassify().name().equals(entity.getClassify().name()))
+                .findFirst()
+                .orElse(null);
+        if (existingDto != null) {
+          // 如果存在，则将 entity 添加到对应的 dto
+          existingDto.getDts().add(entity);
+        } else {
+          // 如果不存在，则创建新的 dto 并添加到 dtoList
+          List<OpenApiRecordClassifyDTO> newEntityList = new ArrayList<>();
+          newEntityList.add(entity);
+          OpenApiRecordClassifyAllDTO newDto = new OpenApiRecordClassifyAllDTO(entity.getClassify(), newEntityList);
+          allList.add(newDto);
+        }
+      }
+    }
+    return allList;
+  }
+
+}

@@ -562,8 +562,10 @@ public class SysUserServiceImpl extends AbstractBaseService<UserMapper, SysUserE
     user.setPassword(passwordEncoder.encode(accountProperties.getDefaultPassword()));
     user.setPassword(passwordEncoder.encode(accountProperties.getDefaultPassword()));
     //判断是租户管理员还是普通租户
     //判断是租户管理员还是普通租户
     Integer level = null;
     Integer level = null;
-    if (null!=userDTO.getLevel()&&userDTO.getLevel()== FastIotConstants.MagicNumber.FOUR){
+    if (null!=userDTO.getLevel()&&userDTO.getLevel()== MagicNumber.FOUR){
       level = FastIotConstants.LevelValue.IS_CUSTOMER_TENANT;
       level = FastIotConstants.LevelValue.IS_CUSTOMER_TENANT;
+    }else if (null!=userDTO.getLevel()&&userDTO.getLevel()== MagicNumber.FIVE){
+      level = FastIotConstants.LevelValue.IS_OPENAPI_USER;
     }else{
     }else{
       level = FastIotConstants.LevelValue.IS_TENANT_ADMIN;
       level = FastIotConstants.LevelValue.IS_TENANT_ADMIN;
     }
     }
@@ -578,12 +580,21 @@ public class SysUserServiceImpl extends AbstractBaseService<UserMapper, SysUserE
     }
     }
     baseMapper.insert(user);
     baseMapper.insert(user);
     // 如果为普通租户绑定用户和组织的关系和角色
     // 如果为普通租户绑定用户和组织的关系和角色
-    if(null!=user.getLevel()&&user.getLevel()==FastIotConstants.LevelValue.IS_CUSTOMER_TENANT){
+    if(null!=level){
+      //如果是普通租户
+      if(level==FastIotConstants.LevelValue.IS_CUSTOMER_TENANT){
+        for (String tenantRole : userDTO.getRoleIds()) {
+          roleMapper.saveUserRoleMapping(user.getId(), tenantRole);
+        }
+      }
+      //如果是openapi用户
+      if(level==FastIotConstants.LevelValue.IS_OPENAPI_USER){
+        for (String tenantRole : userDTO.getRoleIds()) {
+          roleMapper.saveUserRoleMapping(user.getId(), tenantRole);
+        }
+      }
       organizationService.bindUserToOrganization(
       organizationService.bindUserToOrganization(
               tenantId, user.getId(), userDTO.getOrganizationIds());
               tenantId, user.getId(), userDTO.getOrganizationIds());
-      for (String tenantRole : userDTO.getRoleIds()) {
-        roleMapper.saveUserRoleMapping(user.getId(), tenantRole);
-      }
     }else{
     }else{
       //查询租户的角色
       //查询租户的角色
       List<SysTenantRoleEntity> tenantRoleList = validateTenantRole(userDTO.getTenantId());
       List<SysTenantRoleEntity> tenantRoleList = validateTenantRole(userDTO.getTenantId());

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.dao.yunteng.entities.TenantBaseEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkApplicationApiEntity;
+
+import java.util.Collection;
+import java.util.List;
+
+@Mapper
+public interface ApplicationApiMapper extends BaseMapper<TkApplicationApiEntity> {
+
+    int deleteByAppIds(@Param("applicationIds") Collection<String> applicationId);
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.common.data.yunteng.dto.SysDictItemDTO;
+import org.thingsboard.server.dao.yunteng.entities.SysDictItemEntity;
+import org.thingsboard.server.dao.yunteng.entities.TenantBaseEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkApplicationEntity;
+
+import java.util.List;
+
+@Mapper
+public interface ApplicationMapper extends BaseMapper<TkApplicationEntity> {
+
+}

+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.TkOpenApiEntity;
+
+@Mapper
+public interface OpenApiMapper extends BaseMapper<TkOpenApiEntity> {
+
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiRecordClassifyDTO;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiRecordTopDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkOpenApiRecordEntity;
+
+import java.util.List;
+
+@Mapper
+public interface OpenApiRecordMapper extends BaseMapper<TkOpenApiRecordEntity> {
+
+    List<OpenApiRecordTopDTO> getTop(@Param("tenantId") String tenantId,@Param("page")Integer page,@Param("pageSize")Integer pageSize);
+
+    List<OpenApiRecordClassifyDTO> getClassify(@Param("tenantId") String tenantId,
+                                               @Param("type") String type);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.ApplicationDTO;
+import org.thingsboard.server.common.data.yunteng.dto.SysDictDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkApplicationEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceProfileEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkMessageLogEntity;
+
+import java.util.Map;
+import java.util.Set;
+
+
+public interface ApplicationService  extends BaseService<TkApplicationEntity>{
+
+    ApplicationDTO getDto(String id);
+
+    TkPageData<ApplicationDTO> page(Map<String, Object> queryMap);
+
+    ApplicationDTO save(ApplicationDTO dto,String tenantId);
+
+    boolean delete(Set<String> applicationIds);
+
+    ApplicationDTO update(ApplicationDTO dto);
+
+    ApplicationDTO getByKeyAndSecret(String key,String Secret);
+
+    ApplicationDTO getDtoByUserId(String userId);
+
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.common.data.yunteng.dto.*;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkOpenApiRecordEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface OpenApiRecordService extends BaseService<TkOpenApiRecordEntity>{
+
+    OpenApiRecordDTO getDto(String id);
+
+    TkPageData<OpenApiRecordDTO> page(Map<String, Object> queryMap);
+
+    int save(TkOpenApiRecordEntity entity, String tenantId);
+
+    OpenApiRecordTopAllDTO getTop(String tenantId);
+
+    TkPageData<OpenApiRecordTopDTO> getPage(String tenantId,Integer page,Integer pageSize);
+
+    List<OpenApiRecordClassifyAllDTO> getClassify(String tenantId,String type);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiContrlooerDTO;
+import org.thingsboard.server.common.data.yunteng.dto.OpenApiDTO;
+import org.thingsboard.server.common.data.yunteng.dto.ApiMenuDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkOpenApiEntity;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface OpenApiService extends BaseService<TkOpenApiEntity>{
+
+    OpenApiDTO getDto(String id);
+
+    TkPageData<OpenApiDTO> page(Map<String, Object> queryMap);
+
+    OpenApiDTO save(OpenApiDTO dto, String tenantId);
+
+    boolean delete(Set<String> applicationIds);
+
+    OpenApiDTO update(OpenApiDTO dto, String tenantId);
+
+    List<ApiMenuDTO> getMenu(String tenantId);
+
+    List<OpenApiContrlooerDTO> getByListId(List<String> ids);
+
+
+}

+<?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.ApplicationApiMapper">
+    <resultMap type="org.thingsboard.server.dao.yunteng.entities.TkApplicationApiEntity" id="userRoleMap">
+        <result property="applicationId" column="application_id"/>
+        <result property="apiId" column="api_id"/>
+    </resultMap>
+
+    <delete id="deleteByAppIds">
+        DELETE FROM tk_application_api WHERE application_id IN
+        <foreach collection="applicationIds" item="applicationId" open="(" separator="," close=")">
+            #{applicationId}
+        </foreach>
+    </delete>
+
+</mapper>

+<?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.OpenApiRecordMapper">
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.OpenApiRecordTopDTO" id="DTOMap">
+        <result property="name" column="application_name"/>
+        <result property="recordNum" column="recordNum"/>
+        <result property="successCount" column="success_count"/>
+        <result property="failureCount" column="failure_count"/>
+        <result property="recordProportion" column="recordProportion"/>
+    </resultMap>
+
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.OpenApiRecordClassifyDTO" id="map">
+        <result property="classify" column="classify"/>
+        <result property="time" column="time_period"/>
+        <result property="count" column="call_count"/>
+
+    </resultMap>
+
+    <select id="getTop" resultMap="DTOMap">
+        SELECT
+        application_name,
+        COUNT(*) AS recordNum,
+        ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM tk_open_api_record), 2) AS recordProportion,
+        SUM(CASE WHEN state = 0 THEN 1 ELSE 0 END) AS success_count,
+        SUM(CASE WHEN state = 1 THEN 1 ELSE 0 END) AS failure_count
+        FROM  tk_open_api_record
+        WHERE tenant_id = #{tenantId}
+        GROUP BY application_name
+        ORDER BY recordNum desc
+        <if test="page != null">
+            LIMIT #{pageSize} OFFSET #{page}
+        </if>
+    </select>
+
+    <select id="getClassify" resultMap="map">
+        SELECT
+        classify,
+        <if test="type == 'hour'">
+            DATE_TRUNC('hour', request_time) AS time_period,
+        </if>
+        <if test="type == 'week'">
+            DATE_TRUNC('week', request_time) AS time_period,
+        </if>
+        <if test="type == 'month'">
+            DATE_TRUNC('month', request_time) AS time_period,
+        </if>
+        COUNT(*) AS call_count
+        FROM
+        tk_open_api_record
+        WHERE tenant_id = #{tenantId}
+        GROUP BY
+        classify,
+        <if test="type == 'hour'">
+        DATE_TRUNC('hour', request_time)
+        </if>
+        <if test="type == 'week'">
+            DATE_TRUNC('week', request_time)
+        </if>
+        <if test="type == 'month'">
+            DATE_TRUNC('month', request_time)
+        </if>
+        ORDER BY
+        time_period
+    </select>
+
+
+</mapper>