Merge branch 'ljl' into 'master'

refactor: 迁移代码

See merge request huang/thingsboard3.3.2!1

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmContactDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmContactService;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.thingsboard.server.common.data.yunteng.constant.FastIotConstants.DefaultOrder.CREATE_TIME;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE_SIZE;
+
+/** @Description 告警联系人 @Author cxy @Date 2021/11/2 14:54 */
+@RestController
+@RequestMapping("/api/yt/alarmContact")
+@RequiredArgsConstructor
+@Api(value = "告警联系人")
+public class YtAlarmContactController extends BaseController {
+  private final YtAlarmContactService alarmService;
+
+  @ApiOperation(value = "新增告警联系人")
+  @PostMapping
+  public ResponseEntity<AlarmContactDTO> saveAlarmContact(
+      @Validated(AddGroup.class) @RequestBody AlarmContactDTO alarmContactDTO) throws ThingsboardException {
+    AlarmContactDTO newAlarmContactDTO = alarmService.saveAlarmContact(getCurrentUser().getCurrentTenantId(), alarmContactDTO);
+    return Optional.ofNullable(newAlarmContactDTO)
+        .map(
+            dto -> {
+              URI location =
+                  ServletUriComponentsBuilder.fromCurrentRequest()
+                      .path("/{id}")
+                      .buildAndExpand(newAlarmContactDTO.getId())
+                      .toUri();
+              return ResponseEntity.created(location).body(newAlarmContactDTO);
+            })
+        .orElse(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
+  }
+
+  @ApiOperation(value = "查询全部告警联系人名单")
+  @PostMapping("/all")
+  public ResponseEntity<List<AlarmContactDTO>> findall(@RequestBody Map<String,Object> params) throws ThingsboardException {
+
+    List<AlarmContactDTO> all = alarmService.findAll(getCurrentUser().getCurrentTenantId(), params);
+    return ResponseEntity.ok(all);
+  }
+
+  @ApiOperation(value = "分页查询")
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public PageData<AlarmContactDTO> pageAlarm(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "username", required = false) String username,
+      @RequestParam(value = "organizationId", required = false) String organizationId,
+      @RequestParam(value = CREATE_TIME, required = false) String createtime) {
+    HashMap<String, Object> queryMap = new HashMap<>();
+    queryMap.put(PAGE_SIZE, pageSize);
+    queryMap.put(PAGE, page);
+    queryMap.put("username",username);
+    queryMap.put("organizationId",organizationId);
+    queryMap.put(CREATE_TIME, createtime);
+
+    return alarmService.page(queryMap);
+  }
+
+  @ApiOperation(value = "通过id来删除联系人")
+  @DeleteMapping
+  public void deleteById(@RequestBody String[] ids) {
+    if (ids.length == 0) {
+      throw new DataValidationException("please provide alarm ids to delete");
+    }
+    alarmService.delete(ids);
+  }
+
+  @ApiOperation(value = "修改告警联系人信息")
+  @PostMapping("/update")
+  public void update( @RequestBody AlarmContactDTO alarmContactDTO) {
+
+    alarmService.update(alarmContactDTO);
+  }
+
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmInfoDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmInfoService;
+
+import java.util.HashMap;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE_SIZE;
+
+/**
+ * @Description 告警中心
+ * @Author cxy
+ * @Date 2021/11/11 9:23
+ */
+@RestController
+@RequestMapping("/api/yt/alarmInfo")
+@RequiredArgsConstructor
+@Api(value = "告警中心")
+public class YtAlarmInfoController {
+
+    private final YtAlarmInfoService alarmInfoService;
+
+    /*@ApiOperation(value = "增加或修改告警中心")
+    @PostMapping
+    @PreAuthorize("hasRole('ROLE_TENANT_ADMIN')")
+    public ResponseEntity<AlarmInfoDTO> saveAlarmInfo(@RequestBody AlarmInfoDTO alarmInfoDto){
+
+        AlarmInfoDTO newalarmInfoDto = alarmInfoService.insertOrUpdate(alarmInfoDto);
+        return Optional.ofNullable(newalarmInfoDto)
+                .map(
+                        dto -> {
+                            URI location =
+                                    ServletUriComponentsBuilder.fromCurrentRequest()
+                                            .path("/{id}")
+                                            .buildAndExpand(newalarmInfoDto.getId())
+                                            .toUri();
+                            return ResponseEntity.created(location).body(newalarmInfoDto);
+                        })
+                .orElse(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
+    }
+
+*/
+    //分页测试通过
+    @ApiOperation(value="分页查询告警中心数据")
+    @GetMapping(params = {PAGE_SIZE, PAGE})
+    public PageData<AlarmInfoDTO> pageAlarmInfo(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestParam(value = "sortProperty", required = false) String sortProperty,
+            @RequestParam(value = "status", required = false) String status,
+            @RequestParam(value = "sortOrder", required = false) String sortOrder,
+            @RequestParam(value = "searchStatus", required = false) String searchStatus,
+            @RequestParam(value = "textSearch", required = false) String textSearch,
+            @RequestParam(value = "startTime", required = false) String startTime,
+            @RequestParam(value = "fetchOriginator", required = false) String fetchOriginator,
+            @RequestParam(value = "endTime", required = false) String endTime){
+        HashMap<String, Object> queryMap = new HashMap<>();
+        queryMap.put(PAGE_SIZE, pageSize);
+        queryMap.put(PAGE, page);
+        queryMap.put("sortProperty", sortProperty);
+        queryMap.put("sortOrder", sortOrder);
+        queryMap.put("searchStatus", searchStatus);
+        queryMap.put("status", status);
+        queryMap.put("textSearch", textSearch);
+        queryMap.put("startTime", startTime);
+        queryMap.put("endTime", endTime);
+        queryMap.put("fetchOriginator", fetchOriginator);
+        return alarmInfoService.page(queryMap);
+    }
+    /*@ApiOperation(value = "删除告警中心数据")
+    @DeleteMapping
+    public void deleteAlarmInfo(@Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO){
+
+        alarmInfoService.deleteAlarm(deleteDTO.getIds());
+    }*/
+
+
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmProfileDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmProfileService;
+
+@RestController
+@RequestMapping("/api/yt/alarmProfile")
+@RequiredArgsConstructor
+public class YtAlarmProfileController extends BaseController {
+  private final YtAlarmProfileService alarmProfileService;
+
+  @PostMapping
+  public ResponseEntity<AlarmProfileDTO> saveAlarmProfile(
+      @RequestBody AlarmProfileDTO alarmProfileDTO) throws ThingsboardException {
+    return ResponseEntity.ok(alarmProfileService.saveOrUpdateAlarmProfile(getCurrentUser().getCurrentTenantId(), alarmProfileDTO));
+  }
+
+  @DeleteMapping
+  public ResponseEntity<Boolean> deleteAlarmProfile(
+          @RequestBody DeleteDTO deleteDTO) {
+    return ResponseEntity.ok(alarmProfileService.deleteAlarmProfile(deleteDTO.getIds()));
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.common.YtCommonService;
+import org.thingsboard.server.controller.BaseController;
+
+@RequiredArgsConstructor
+@RequestMapping("/api/yt/common")
+@RestController
+public class YtCommonController extends BaseController {
+    private final YtCommonService commonService;
+
+    @GetMapping
+    @ApiOperation(value = "生成随机设备Token")
+    public ResponseEntity<String> generateDeviceToken() throws ThingsboardException {
+        return ResponseEntity.ok(commonService.generateDeviceToken(getCurrentUser().getCurrentTenantId()));
+    }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
+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.core.exception.FastIotException;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.enums.DeviceState;
+import org.thingsboard.server.common.data.yunteng.enums.DeviceTypeEnum;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceService;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Optional;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("api/yt/device")
+public class YtDeviceController extends BaseController {
+  private final YtDeviceService deviceService;
+
+  @PostMapping
+  public ResponseEntity<DeviceDTO> saveDevice(@Validated(AddGroup.class)@RequestBody DeviceDTO deviceDTO)
+          throws FastIotException, ThingsboardException {
+    DeviceDTO newDeviceDTO = deviceService.insertOrUpdate(getCurrentUser().getCurrentTenantId(), deviceDTO);
+    return Optional.ofNullable(newDeviceDTO)
+        .map(
+            dto -> {
+              URI location =
+                  ServletUriComponentsBuilder.fromCurrentRequest()
+                      .path("/{id}")
+                      .buildAndExpand(newDeviceDTO.getId())
+                      .toUri();
+              return ResponseEntity.created(location).body(newDeviceDTO);
+            })
+        .orElse(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
+  }
+
+  @GetMapping("{id}")
+  public ResponseEntity<DeviceDTO> getDevice(@PathVariable("id") String id) throws ThingsboardException {
+    return ResponseEntity.of(deviceService.getDevice(getCurrentUser().getCurrentTenantId(), id));
+  }
+
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public PageData<DeviceDTO> pageDevice(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "name", required = false) String name,
+      @RequestParam(value = "deviceState", required = false) DeviceState deviceState,
+      @RequestParam(value = "deviceType", required = false) DeviceTypeEnum deviceType,
+      @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 (deviceState != null) {
+      queryMap.put("deviceState", deviceState.name());
+    }
+    if (deviceType != null) {
+      queryMap.put("deviceType", deviceType.name());
+    }
+    if(!StringUtils.isEmpty(organizationId)){
+      queryMap.put("organizationId", organizationId);
+    }
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return deviceService.page(getCurrentUser().getCurrentTenantId(), queryMap);
+  }
+
+  @DeleteMapping
+  public void deleteDevices(@Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) throws ThingsboardException {
+    deviceService.deleteDevices(getCurrentUser().getCurrentTenantId(), deleteDTO.getIds());
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+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.springframework.web.servlet.support.ServletUriComponentsBuilder;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.common.DeleteGroup;
+import org.thingsboard.server.common.data.yunteng.core.exception.FastIotException;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceProfileService;
+
+import java.net.URI;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("api/yt/deviceProfile")
+public class YtDeviceProfileController extends BaseController {
+  private final YtDeviceProfileService deviceProfileService;
+
+  @PostMapping
+  @PreAuthorize("hasRole('ROLE_TENANT_ADMIN')")
+  public ResponseEntity<DeviceProfileDTO> saveDeviceProfile(
+      @RequestBody DeviceProfileDTO deviceProfileDTO) throws FastIotException, ThingsboardException {
+    DeviceProfileDTO newDeviceProfileDTO = deviceProfileService.insertOrUpdate(getCurrentUser().getCurrentTenantId(), deviceProfileDTO);
+    return Optional.ofNullable(newDeviceProfileDTO)
+        .map(
+            dto -> {
+              URI location =
+                  ServletUriComponentsBuilder.fromCurrentRequest()
+                      .path("/{id}")
+                      .buildAndExpand(newDeviceProfileDTO.getId())
+                      .toUri();
+              return ResponseEntity.created(location).body(newDeviceProfileDTO);
+            })
+        .orElse(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
+  }
+
+  @GetMapping("{id}")
+  public ResponseEntity<DeviceProfileDTO> getDevice(@PathVariable("id") String id) throws ThingsboardException {
+    return ResponseEntity.of(deviceProfileService.getDeviceProfile(getCurrentUser().getCurrentTenantId(), id));
+  }
+
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public PageData<DeviceProfileDTO> pageDevice(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "name", required = false) String name,
+      @RequestParam(value = "transportType", required = false) String transportType,
+      @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("transportType", transportType);
+    queryMap.put("name", name);
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return deviceProfileService.page(getCurrentUser().getCurrentTenantId(), queryMap);
+  }
+
+  @DeleteMapping
+  public void deleteDevices(@Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) throws ThingsboardException {
+    deviceProfileService.deleteDeviceProfiles(getCurrentUser().getCurrentTenantId(), deleteDTO.getIds());
+  }
+
+  @GetMapping("/me")
+  public ResponseEntity<List<DeviceProfileDTO>> findCurrentTenantDeviceProfiles() throws ThingsboardException {
+    DeviceProfileDTO deviceProfileDTO = new DeviceProfileDTO();
+    deviceProfileDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+    return ResponseEntity.ok(deviceProfileService.findDeviceProfile(getCurrentUser().getCurrentTenantId(), deviceProfileDTO));
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+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.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceTypeDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceTypeService;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("api/yt/device_type")
+@RequiredArgsConstructor
+@Api(value = "设备类型")
+public class YtDeviceTypeController extends BaseController {
+  private final YtDeviceTypeService deviceTypeService;
+
+  @GetMapping
+  @ApiOperation(value = "获取当前用户的设备类型树形")
+  @ApiParam(name = "tenantCode",value = "租户Code")
+  public ResponseEntity<List<DeviceTypeDTO>> getDeviceTypeTree(String tenantCode){
+    return ResponseEntity.ok(deviceTypeService.getDeviceTypeTree(tenantCode));
+  }
+
+  @PostMapping
+  @ApiOperation(value = "保存设备类型")
+  public ResponseEntity<DeviceTypeDTO> saveDeviceType(
+      @Validated({AddGroup.class}) @RequestBody DeviceTypeDTO deviceTypeDTO) throws ThingsboardException {
+    return ResponseEntity.ok(deviceTypeService.saveDeviceTye(getCurrentUser().getCurrentTenantId(), deviceTypeDTO));
+  }
+
+  @PutMapping
+  @ApiOperation(value = "修改设备类型")
+  public ResponseEntity<DeviceTypeDTO> updateDeviceType(
+      @Validated({UpdateGroup.class}) @RequestBody DeviceTypeDTO deviceTypeDTO) {
+    return ResponseEntity.ok(deviceTypeService.updateDeviceType(deviceTypeDTO));
+  }
+
+  @DeleteMapping
+  @ApiOperation(value = "删除设备类型")
+  public ResponseResult<Boolean> deleteDeviceType(
+      @Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) {
+    return ResponseResult.success(deviceTypeService.deleteDeviceType(deleteDTO));
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+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.MailLogDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtMailLogService;
+
+import java.util.HashMap;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@RestController
+@RequestMapping("api/yt/mailLog")
+@RequiredArgsConstructor
+public class YtMailLogController extends BaseController {
+
+    private final YtMailLogService mailLogService;
+
+    @GetMapping(params = {PAGE_SIZE, PAGE})
+    public PageData<MailLogDTO> pageMessageConfig(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestParam(value = "emailSubject", required = false) String emailSubject,
+            @RequestParam(value = "startTime", required = false) String startTime,
+            @RequestParam(value = "endTime", required = false) String endTime,
+            @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("emailSubject", emailSubject);
+        queryMap.put("startTime", startTime);
+        queryMap.put("endTime", endTime);
+        if (orderType != null) {
+            queryMap.put(ORDER_TYPE, orderType.name());
+        }
+        return mailLogService.page(getCurrentUser().getCurrentTenantId(), queryMap);
+    }
+
+    @DeleteMapping
+    public ResponseResult<String> deleteMailLog(@RequestBody DeleteDTO deleteDTO) {
+        return mailLogService.deleteMailLog(deleteDTO.getIds())
+                ? ResponseResult.success(FastIotConstants.StateValue.DELETE_SUCCESS)
+                : ResponseResult.failed(FastIotConstants.StateValue.DELETE_FAILED);
+    }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+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.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.MessageConfigDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtMessageConfigService;
+
+import java.util.HashMap;
+import java.util.List;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@RestController
+@RequestMapping("api/yt/message")
+@RequiredArgsConstructor
+public class YtMessageConfigController extends BaseController {
+
+  private final YtMessageConfigService messageConfigService;
+
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public PageData<MessageConfigDTO> pageMessageConfig(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "platformType", required = false) String platformType,
+      @RequestParam(value = "messageType", required = false) String messageType,
+      @RequestParam(value = "status", required = false) Integer status,
+      @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("platformType", platformType);
+    queryMap.put("messageType", messageType);
+    queryMap.put("status",status);
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return messageConfigService.page(getCurrentUser().getCurrentTenantId(),queryMap);
+  }
+
+  @PostMapping
+  public ResponseResult<MessageConfigDTO> saveMessageConfig(
+          @Validated({AddGroup.class})@RequestBody MessageConfigDTO configDTO) throws ThingsboardException {
+    MessageConfigDTO newDTO = messageConfigService.saveMessageConfig(getCurrentUser().getCurrentTenantId(),configDTO);
+    return ResponseResult.success(newDTO);
+  }
+
+  @GetMapping("/{id}")
+  public ResponseResult<MessageConfigDTO> findMessageConfigById(@PathVariable String id){
+    return ResponseResult.success(messageConfigService.findMessageConfigById(id));
+  }
+  @DeleteMapping
+  public ResponseResult<String> deleteMessageConfig(@Validated({DeleteGroup.class})@RequestBody DeleteDTO deleteDTO) {
+    return messageConfigService.deleteMessageConfig(deleteDTO.getIds())
+            ? ResponseResult.success(FastIotConstants.StateValue.DELETE_SUCCESS)
+            : ResponseResult.failed(FastIotConstants.StateValue.DELETE_FAILED);
+  }
+
+  @PutMapping
+  public MessageConfigDTO updateMessageConfig(@Validated({UpdateGroup.class})@RequestBody MessageConfigDTO configDTO) throws ThingsboardException {
+    return messageConfigService.updateMessageConfig(getCurrentUser().getCurrentTenantId(), configDTO);
+  }
+
+  @PostMapping("/find")
+  public ResponseEntity<List<MessageConfigDTO>> findMessageInfo(@RequestBody MessageConfigDTO configDTO){
+    return ResponseEntity.ok(messageConfigService.findMessageInfo(configDTO));
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.util.Assert;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+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.MessageTemplateDTO;
+import org.thingsboard.server.common.data.yunteng.dto.request.EmailReqDTO;
+import org.thingsboard.server.common.data.yunteng.dto.request.SmsReqDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.enums.ResponseCodeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.common.data.yunteng.utils.tools.ResponseResult;
+import org.thingsboard.server.dao.yunteng.service.YtMailService;
+import org.thingsboard.server.dao.yunteng.service.YtMessageTemplateService;
+import org.thingsboard.server.dao.yunteng.service.YtSmsService;
+
+import java.util.HashMap;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@RestController
+@RequestMapping("api/yt/template")
+@RequiredArgsConstructor
+public class YtMessageTemplateController {
+
+  private final YtMessageTemplateService messageTemplateService;
+
+  private final YtSmsService smsService;
+
+  private final YtMailService mailService;
+
+  @GetMapping(params = {PAGE_SIZE, PAGE})
+  public PageData<MessageTemplateDTO> pageMessageTemplate(
+      @RequestParam(PAGE_SIZE) int pageSize,
+      @RequestParam(PAGE) int page,
+      @RequestParam(value = "templateCode", required = false) String templateCode,
+      @RequestParam(value = "templateName", required = false) String templateName,
+      @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("templateCode", templateCode);
+    queryMap.put("templateName", templateName);
+    if (orderType != null) {
+      queryMap.put(ORDER_TYPE, orderType.name());
+    }
+    return messageTemplateService.page(queryMap);
+  }
+
+  @PostMapping
+  public ResponseResult<MessageTemplateDTO> saveMessageTemplate(
+      @Validated({AddGroup.class}) @RequestBody MessageTemplateDTO templateDTO) {
+    MessageTemplateDTO newDTO = messageTemplateService.saveMessageTemplate(templateDTO);
+    return ResponseResult.success(newDTO);
+  }
+
+  @DeleteMapping
+  public ResponseResult<String> deleteMessageTemplate(
+      @Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) {
+    return messageTemplateService.deleteMessageTemplate(deleteDTO.getIds())
+        ? ResponseResult.success(FastIotConstants.StateValue.DELETE_SUCCESS)
+        : ResponseResult.failed(FastIotConstants.StateValue.DELETE_FAILED);
+  }
+
+  @PutMapping
+  public MessageTemplateDTO updateMessageTemplate(
+      @Validated({UpdateGroup.class}) @RequestBody MessageTemplateDTO templateDTO) {
+    Assert.notNull(templateDTO.getId(), "messageTemplate id cannot be null");
+    return messageTemplateService.updateMessageTemplate(templateDTO);
+  }
+
+  @PostMapping("/sendSms")
+  public ResponseResult<String> sendSms(
+      @Validated({AddGroup.class}) @RequestBody SmsReqDTO smsReqDTO) {
+    boolean result = smsService.sendSms(smsReqDTO);
+    String message = result ? ResponseCodeEnum.SUCCESS.name() : ResponseCodeEnum.FAILED.name();
+    return ResponseResult.success(message);
+  }
+
+  @PostMapping("/sendEmail")
+  public ResponseResult<String> sendEmail(
+      @Validated({AddGroup.class}) @RequestBody EmailReqDTO emailReqDTO) {
+    boolean result = mailService.sendEmail(emailReqDTO);
+    String message = result ? ResponseCodeEnum.SUCCESS.name() : ResponseCodeEnum.FAILED.name();
+    return ResponseResult.success(message);
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.util.Assert;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.server.dao.yunteng.service.YtSmsService;
+
+import static org.thingsboard.server.common.data.yunteng.constant.FastIotConstants.CHINA_MOBILE_PATTERN;
+
+@RestController
+@RequestMapping("api/yt/noauth")
+@RequiredArgsConstructor
+public class YtNoAuthController {
+
+  private final YtSmsService smsService;
+
+  @PostMapping("/sendLoginSmsCode/{phoneNumber}")
+  public boolean sendVerificationCode(@PathVariable("phoneNumber") String phoneNumber) {
+    Assert.isTrue(
+        CHINA_MOBILE_PATTERN.matcher(phoneNumber).matches(), "please input correct phone number");
+    return smsService.sendLoginSmsCode(phoneNumber);
+  }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.jsonwebtoken.*;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.authentication.BadCredentialsException;
+import org.springframework.util.Assert;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmInfoDTO;
+import org.thingsboard.server.dao.yunteng.service.YtNoticeService;
+import org.thingsboard.server.service.security.exception.JwtExpiredTokenException;
+
+import java.net.InetAddress;
+
+/**
+ * @version V1.0
+ * @Description :
+ * 1.其它地方抛出异常，交由控制层统一处理
+ * 2.服务层注意持久化的事务管理
+ * @Dependency: 依赖包
+ * @Author: junlianglee
+ * @Date Created in 2021/11/23$
+ * @Copyright 2016-2018  - Powered By 云腾五洲
+ */
+@RestController
+@RequestMapping("/api/yt/notice")
+@RequiredArgsConstructor
+@Slf4j
+public class YtNoticeController {
+
+    private final YtNoticeService service;
+
+    @PostMapping("/alert")
+    public void alermNotice(@RequestParam(value = "token", required = true) String token,
+                            @RequestBody AlarmInfoDTO alarmInfo){
+        Assert.notNull(token, "token cannot be null");
+        Assert.notNull(alarmInfo, "alarm info cannot be null");
+        if(parseTokenClaims(token,alarmInfo)){
+            service.alert(token,alarmInfo);
+        }
+    }
+
+
+
+    private boolean parseTokenClaims(String token,AlarmInfoDTO alarmInfo) {
+        try {
+            Claims claims = Jwts.parser()
+                    .setSigningKey(alarmInfo.getSeverity())
+                    .parseClaimsJws(token)
+                    .getBody();
+            if(claims.get("deviceId").equals(alarmInfo.getDeviceId())
+                    &&claims.get("tenantId").equals(alarmInfo.getTenantId())
+                    &&claims.get("ip").equals(InetAddress.getLocalHost().getHostAddress())){
+                return true;
+            }
+            return false;
+        } catch (UnsupportedJwtException | MalformedJwtException | IllegalArgumentException | SignatureException ex) {
+            log.debug("Invalid JWT Token", ex);
+            throw new BadCredentialsException("Invalid JWT token: ", ex);
+        } catch (ExpiredJwtException expiredEx) {
+            log.debug("JWT Token is expired", expiredEx);
+            throw new JwtExpiredTokenException(expiredEx.getMessage());
+        } catch (Exception e) {
+            log.error("not allowed send notice",e);
+        }
+        return false;
+    }
+}

@@ -17,7 +17,6 @@ package org.thingsboard.server.dao.device;
 
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfileInfo;
-import org.thingsboard.server.common.data.EntityInfo;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;

@@ -2,7 +2,7 @@ package org.thingsboard.server.common.data.yunteng.common;
 
 import org.thingsboard.server.common.data.yunteng.dto.SysDictItemDTO;
 
-public interface CommonService {
+public interface YtCommonService {
   /**
    * 通过dict表的Code和dictItem的codeText查询字典表的值
    *

@@ -12,7 +12,7 @@ import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Pointcut;
 import org.springframework.stereotype.Component;
 import org.thingsboard.common.util.JacksonUtil;
-import org.thingsboard.server.common.data.yunteng.common.CommonService;
+import org.thingsboard.server.common.data.yunteng.common.YtCommonService;
 import org.thingsboard.server.common.data.yunteng.common.aspect.annotation.AutoDict;
 import org.thingsboard.server.common.data.yunteng.dto.SysDictItemDTO;
 import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
@@ -31,7 +31,7 @@ import java.util.List;
 @RequiredArgsConstructor
 public class SysDictAspect {
 
-  private final CommonService commonService;
+  private final YtCommonService commonService;
 
   /** 表对应字段加上_dictText即可显示出文本 */
   private static final String DICT_TEXT_SUFFIX = "DictText";

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+
+import javax.validation.constraints.NotEmpty;
+
+/**
+ * @Description 告警联系人实体表返回给前端视图
+ * @Author cxy
+ * @Date 2021/11/2 13:49
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class AlarmContactDTO extends TenantDTO {
+
+    @ApiModelProperty(value = "用户名", required = true)
+    @NotEmpty(message = "用户名不能为空或字符串", groups = AddGroup.class)
+    private String username;
+
+    @ApiModelProperty(value = "组织")
+    private String organizationId;
+
+    @NotEmpty(message = "电话不能为空或字符串", groups = AddGroup.class)
+    @ApiModelProperty(value = "电话", required = true)
+    private String phone;
+
+    @ApiModelProperty(value = "电子邮件")
+    private String email;
+
+    @ApiModelProperty(value = "微信")
+    private String wechat;
+
+    @ApiModelProperty(value = "钉钉")
+    private String dingtalk;
+    /**
+     * Include.NON_NULL 属性为NULL 不序列化 ,不显示出字段
+     */
+    @ApiModelProperty(value = "备注")
+    @JsonInclude(JsonInclude.Include.NON_NULL)
+    private String remark;
+
+    @ApiModelProperty(value = "添加人")
+    private String addPeople;
+
+
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.validation.constraints.NotEmpty;
+
+/** @Description @Author cxy @Date 2021/11/16 17:49 */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class AlarmInfoDTO extends TenantDTO {
+  @ApiModelProperty(value = "告警时间")
+  private long createTs;
+
+  @ApiModelProperty(value = "告警类型")
+  private String type;
+
+  @ApiModelProperty(value = "告警详情")
+  private String details;
+
+
+  @ApiModelProperty(value = "告警开始时间")
+  private long startTs;
+
+  @ApiModelProperty(value = "告警结束时间")
+  private long endTs;
+
+  @ApiModelProperty(value = "告警状态")
+  private String status;
+
+  @ApiModelProperty(value = "告警程度")
+  private String severity;
+
+
+
+  @ApiModelProperty(value = "告警设备名称")
+  private String deviceName;
+  @ApiModelProperty(value = "告警设备ID")
+  @NotEmpty(message = "设备ID不能为空")
+  private String deviceId;
+}

+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.utils.tree.TreeDTO;
+
+import javax.validation.constraints.NotEmpty;
+import java.util.ArrayList;
+import java.util.List;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class DeviceTypeDTO extends TenantDTO implements TreeDTO<DeviceTypeDTO> {
+
+    @NotEmpty(message = "名称不能不空或者空字符串")
+    @ApiModelProperty(value = "设备类型名称")
+    private String name;
+
+    @ApiModelProperty(value = "父ID")
+    private String parentId;
+
+    @NotEmpty(message = "图片地址不能为空或者空字符串",groups = AddGroup.class)
+    @ApiModelProperty(value = "图片地址")
+    private String path;
+
+    @ApiModelProperty(value = "排序")
+    private Integer sort;
+
+    @ApiModelProperty(value = "描述")
+    private String description;
+
+    @ApiModelProperty(value = "下级列表")
+    private List<DeviceTypeDTO> children;
+
+    public DeviceTypeDTO(){
+        this.children = new ArrayList<>();
+    }
+
+    @Override
+    public int compareTo(DeviceTypeDTO o) {
+        return this.getSort()-o.getSort();
+    }
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import org.thingsboard.server.common.data.yunteng.common.aspect.annotation.AutoDict;
+
+import java.time.LocalDateTime;
+
+@Data
+public class MailLogDTO extends BaseDTO{
+    /** 发件人 */
+    private String emailFrom;
+
+    /** 收件人 */
+    private JsonNode emailTo;
+
+    /** 抄送人 */
+    private JsonNode emailCc;
+
+    /** 密送人 */
+    private JsonNode emailBcc;
+
+    /** 邮件主题 */
+    private String emailSubject;
+
+    /** 邮件内容 */
+    private String emailBody;
+
+    /** 状态:ResponseCodeEnum枚举值 */
+    private String status;
+
+    /** 发送时间 */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime sendTime;
+
+    /** 租户Code */
+    private String tenantCode;
+
+    /** 模板ID */
+    private String messageTemplateId;
+
+    /**备注*/
+    private String remark;
+
+    /**用途*/
+    @AutoDict(dictCode = "template_purpose")
+    private String templatePurpose;
+}

@@ -14,7 +14,6 @@ import java.time.LocalDateTime;
 public class TenantDTO extends BaseDTO {
   private String name;
   private String icon;
-  private String tenantCode;
   private boolean enabled;
   private String description;
   private String defaultConfig;

+package org.thingsboard.server.common.data.yunteng.enums;
+
+/**
+ * @version V1.0
+ * @Description :  资源状态，
+ * 例如：消息模板等。
+ * 1.其它地方抛出异常，交由控制层统一处理
+ * 2.服务层注意持久化的事务管理
+ * @Dependency: 依赖包
+ * @Author: junlianglee
+ * @Date Created in 2021/11/24$
+ * @Copyright 2016-2018  - Powered By 云腾五洲
+ */
+public enum AssetStatusEnum {
+    DISABLED,
+    ENABLE
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+/**
+ * 部门状态
+ */
+public enum DeptStatusEnum {
+  ENABLE,
+  DISABLED
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum EmailFormatEnum {
+    TEXT,
+    HTML
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum TransportTypeEnum {
+  DEFAULT,
+  TCP,
+  MQTT,
+  COAP
+}

@@ -44,7 +44,7 @@ public class MailLog extends BaseEntity {
   private LocalDateTime sendTime;
 
   /** 租户Code */
-  private String tenantCode;
+  private String tenantId;
 
   /** 模板ID */
   private String messageTemplateId;

@@ -13,7 +13,7 @@ public class TenantBaseEntity extends BaseEntity {
 
   private static final long serialVersionUID = -4315734960161684909L;
 
-  private String tenantCode;
+  private String tenantId;
 
   @TableField(fill = FieldFill.INSERT)
   private String creator;

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.FieldStrategy;
+import com.baomidou.mybatisplus.annotation.TableField;
+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.TransportTypeEnum;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName(ModelConstants.Table.IOTFS_DEVICE_PROFILE_TABLE_NAME)
+public class YtDeviceProfile extends TenantBaseEntity {
+  private String name;
+  private String description;
+  /** 转换脚本：TCP才会使用 */
+  private String convertJs;
+
+  private TransportTypeEnum transportType;
+  private String tenantCode;
+  /** TB的设备配置文件 */
+  @TableField(updateStrategy = FieldStrategy.IGNORED)
+  private String tbProfileId;
+}

@@ -38,7 +38,7 @@ public class MenuServiceImpl extends AbstractBaseService<MenuMapper, Menu> imple
 
     List<Menu> menus =
         baseMapper.selectList(
-            new QueryWrapper<Menu>().lambda().eq(Menu::getTenantCode, tenantId));
+            new QueryWrapper<Menu>().lambda().eq(Menu::getTenantId, tenantId));
     Map<String, MenuDTO> menuDTOMap = new LinkedHashMap<>(menus.size());
     menus.forEach(menu -> menuDTOMap.put(menu.getId(), menu.getDTO(MenuDTO.class)));
     return buildMenuDTOTree(menuDTOMap);
@@ -144,7 +144,7 @@ public class MenuServiceImpl extends AbstractBaseService<MenuMapper, Menu> imple
         baseMapper.selectCount(
             new QueryWrapper<Menu>()
                 .lambda()
-                .ne(Menu::getTenantCode, tenantId)
+                .ne(Menu::getTenantId, tenantId)
                 .in(Menu::getId, ids));
     if (notTenantMenuCount > 0) {
       throw new AccessDeniedException("cannot delete menu that not create by you");

@@ -7,7 +7,6 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.boot.actuate.endpoint.SecurityContext;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -63,7 +62,7 @@ public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> imple
                     RoleEnum.ROLE_SYS_ADMIN)
                 .eq(
                     !isSysadmin,
-                    Role::getTenantCode,
+                    Role::getTenantId,
                     tenantId)
                 .like(
                     queryMap.get("roleName") != null,
@@ -80,7 +79,7 @@ public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> imple
         baseMapper.selectCount(
             new QueryWrapper<Role>()
                 .lambda()
-                .ne(Role::getTenantCode, tenantId)
+                .ne(Role::getTenantId, tenantId)
                 .in(Role::getId, ids));
     if (notTenantMenuCount > 0) {
       throw new AccessDeniedException("cannot delete role that not create by you");
@@ -155,7 +154,7 @@ public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> imple
                     .eq(Role::getId, roleId)
                     .eq(
                         !isSysadmin,
-                        Role::getTenantCode,
+                        Role::getTenantId,
                         tenantId)))
         .ifPresent(
             role -> {
@@ -188,7 +187,7 @@ public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> imple
                   .eq(Role::getId, roleReqDTO.getId())
                   .eq(
                       !isSysadmin,
-                      Role::getTenantCode,
+                      Role::getTenantId,
                       tenantId));
       if (role == null) {
         return null;
@@ -206,7 +205,7 @@ public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> imple
       role.setRemark(roleReqDTO.getRemark());
       role.setName(roleReqDTO.getName());
       role.setEnabled(roleReqDTO.getStatus() == 1);
-      role.setTenantCode(tenantId);
+      role.setTenantId(tenantId);
       baseMapper.insert(role);
     }
     // do update or save menu associate with this roleId
@@ -245,8 +244,8 @@ public class RoleServiceImpl extends AbstractBaseService<RoleMapper, Role> imple
 
   @Override
   public List<RoleDTO> findRoleInfo(boolean isTenantAdmin,String tenantId,String userId,RoleDTO roleDTO) {
-    if (StringUtils.isEmpty(roleDTO.getTenantCode())) {
-      roleDTO.setTenantCode(tenantId);
+    if (StringUtils.isEmpty(roleDTO.getTenantId())) {
+      roleDTO.setTenantId(tenantId);
     }
     if (isTenantAdmin) {
       // 租户管理员既要查询自己拥有的角色，也要查询自己创建的角色

+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 org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmContactDTO;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.dao.yunteng.entities.AlarmContact;
+import org.thingsboard.server.dao.yunteng.mapper.AlarmContactMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmContactService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/** @Description 告警联系人业务实现 @Author cxy @Date 2021/11/2 14:47 */
+@Service
+@RequiredArgsConstructor
+public class YtAlarmContactServiceImpl extends AbstractBaseService<AlarmContactMapper, AlarmContact>
+    implements YtAlarmContactService {
+  /** mapper注入 自带方法加入,继承的baseMapper */
+  private final AlarmContactMapper alarmContactMapper;
+
+  /**
+   * 查询全部的告警联系人
+   *
+   * @param params 传参
+   * @return List
+   */
+  @Override
+  public List<AlarmContactDTO> findAll(String tenantId,Map<String, Object> params) {
+    // 查询当前租户
+    List<AlarmContact> list =
+        alarmContactMapper.selectList(
+            new QueryWrapper<AlarmContact>()
+                .lambda()
+                .eq(AlarmContact::getTenantId, tenantId)
+                .like(
+                    params.containsKey("username"),
+                    AlarmContact::getUsername,
+                    String.valueOf(params.get("username")))
+                .or()
+                .like(
+                    params.containsKey("department"),
+                    AlarmContact::getOrganizationId,
+                    String.valueOf(params.get("organizationId"))));
+    System.out.println(list);
+    return ReflectUtils.sourceToTarget(list, AlarmContactDTO.class);
+  }
+
+  /**
+   * 新增租户
+   *
+   * @param tenantCode  租户编码
+   * @return alarmContactDTO
+   */
+  private LambdaQueryWrapper<AlarmContact> tenantWapper(String tenantCode) {
+    return new QueryWrapper<AlarmContact>().lambda().eq(AlarmContact::getTenantId, tenantCode);
+  }
+
+  @Override
+  @Transactional
+  public AlarmContactDTO saveAlarmContact(String tenantId,AlarmContactDTO alarmContactDTO) {
+    LambdaQueryWrapper<AlarmContact> Wrapper =
+        tenantWapper(tenantId).eq(AlarmContact::getUsername, alarmContactDTO.getUsername());
+    int Count = baseMapper.selectCount(Wrapper);
+    if (Count > 0) {
+      throw new DataValidationException("department for this name is exited");
+    }
+    alarmContactDTO.setTenantId(tenantId);
+    AlarmContact alarmContact = alarmContactDTO.getEntity(AlarmContact.class);
+    int insertCount = baseMapper.insert(alarmContact);
+    if (insertCount > 0) {
+      alarmContact.copyToDTO(alarmContactDTO);
+      return alarmContactDTO;
+    }
+    return null;
+  }
+
+  /**
+   * 删除告警联系人,byId
+   *
+   * @param alarmIds 通过列表id
+   * @return Integer
+   */
+  @Override
+  @Transactional
+  public boolean delete(String[] alarmIds) {
+    Set<String> ids = Set.of(alarmIds);
+    baseMapper.deleteBatchIds(ids);
+    return true;
+  }
+
+  /**
+   * 修改告警联系人数据
+   *
+   * @param alarmContactDTO 对象
+   * @return Integer
+   */
+  @Override
+  @Transactional
+  public boolean update(AlarmContactDTO alarmContactDTO) {
+
+    // 得到对象
+    AlarmContact alarmContact = baseMapper.selectById(alarmContactDTO.getId());
+    if (alarmContact == null) {
+      throw new DataValidationException("此数据不存在");
+    } else {
+      AlarmContact entity = alarmContactDTO.getEntity(AlarmContact.class);
+      System.out.println(alarmContact);
+      baseMapper.updateById(entity);
+      alarmContact.copyToDTO(alarmContactDTO);
+      return true;
+    }
+  }
+
+
+
+  /**
+   * @param queryMap 查询集合
+   * @return PageData
+   */
+  @Override
+  @Transactional
+  public PageData<AlarmContactDTO> page(Map<String, Object> queryMap) {
+    // 查询分页,加入条模糊条件查询
+    IPage<AlarmContact> iPage =
+        alarmContactMapper.selectPage(
+            getPage(queryMap, "create_time", false),
+            new QueryWrapper<AlarmContact>()
+                .lambda()
+                .like(
+                    StringUtils.isNoneBlank((String) queryMap.get("username")),
+                    AlarmContact::getUsername,
+                    queryMap.get("username"))
+                .eq(
+                    StringUtils.isNoneBlank((String) queryMap.get("organizationId")),
+                    AlarmContact::getOrganizationId,
+                    queryMap.get("organizationId")));
+    return getPageData(iPage, AlarmContactDTO.class);
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.yunteng.core.exception.FastIotException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmInfoDTO;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TBPageData;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmInfoService;
+
+import java.util.List;
+import java.util.Map;
+
+/** @Description 告警中心业务实现 @Author cxy @Date 2021/11/10 16:56 */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class YtAlarmInfoServiceImpl implements YtAlarmInfoService {
+//  private final TBConfig tbConfig;
+//  private final TBConnectService tbConnectService;
+//
+//
+//
+//  private LambdaQueryWrapper<YtAlarmInfo> tenantWapper(String tenantCode) {
+//    return new QueryWrapper<AlarmInfo>().lambda().eq(AlarmInfo::getTenantCode, tenantCode);
+//  }
+
+  /**
+   * 封装修改
+   *
+   * @param alarmInfoDto 告警对象
+   * @return return alarmInfo.getDTO(AlarmInfoDto.class);
+   */
+ /* private AlarmInfoDTO update(AlarmInfoDTO alarmInfoDto) {
+    AlarmInfo alarmInfo = baseMapper.selectById(alarmInfoDto.getId());
+    if (!alarmInfo.getTenantCode().equals(SecurityContext.getCurrentUser().getTenantCode())) {
+      return null;
+    }
+    alarmInfoDto.copyToEntity(alarmInfo);
+    baseMapper.updateById(alarmInfo);
+    alarmInfo.copyToDTO(alarmInfoDto);
+    return alarmInfo.getDTO(AlarmInfoDTO.class);
+  }*/
+  /**
+   * 封装新增
+   *
+   * @param alarmInfoDto 告警对象
+   * @return alarmInfoDto
+   */
+  /*private AlarmInfoDTO insert(AlarmInfoDTO alarmInfoDto) {
+    String tenantCode = SecurityContext.getCurrentUser().getTenantCode();
+    LambdaQueryWrapper<AlarmInfo> Wrapper =
+        tenantWapper(tenantCode)
+            .eq(AlarmInfo::getStatus, alarmInfoDto.getStatus())
+            .eq(AlarmInfo::getSeverity, alarmInfoDto.getSeverity());
+    int Count = baseMapper.selectCount(Wrapper);
+    if (Count > 0) {
+      throw new DataValidationException("告警中心数据已经存在");
+    }
+    // 保存租户编码
+    alarmInfoDto.setTenantCode(tenantCode);
+    AlarmInfo alarmInfo = alarmInfoDto.getEntity(AlarmInfo.class);
+
+    int insertCount = baseMapper.insert(alarmInfo);
+    if (insertCount > 0) {
+      alarmInfo.copyToDTO(alarmInfoDto);
+      return alarmInfoDto;
+    }
+
+    return alarmInfoDto;
+  }
+*/
+  /**
+   * 新增或者修改告警中心
+   *
+   * @param alarmInfoDto 告警对象
+   * @return alarmInfoDto
+   */
+  /*@Override
+  @Transactional
+  public AlarmInfoDTO insertOrUpdate(AlarmInfoDTO alarmInfoDto) {
+    // 判断为空,则新增告警信息
+    if (StringUtils.isBlank(alarmInfoDto.getId())) {
+      return insert(alarmInfoDto);
+    } else {
+      // 不为空则执行修改操作
+      return update(alarmInfoDto);
+    }
+  }*/
+
+  /**
+   * 删除告警中心数据
+   *
+   * @param
+   * @return boolean
+   */
+ /* @Override
+  public boolean deleteAlarm(Set<String> alarmIds) {
+    LambdaQueryWrapper<AlarmInfo> queryWrapper =
+        new QueryWrapper<AlarmInfo>()
+            .lambda()
+            .eq(AlarmInfo::getTenantCode, SecurityContext.getCurrentUser().getTenantCode())
+            .in(AlarmInfo::getId, alarmIds);
+    baseMapper.delete(queryWrapper);
+    return true;
+  }*/
+
+    /**
+     * 分页查询数据
+     *
+     * @param queryMap 集合
+     * @return PageData
+     */
+  @Override
+  public PageData<AlarmInfoDTO> page(Map<String, Object> queryMap) {
+  /*  queryMap.put("tenantCode", SecurityContext.getCurrentUser().getTenantCode());
+    IPage<AlarmInfo> page = getPage(queryMap, FastIotConstants.DefaultOrder.CREATE_TIME,false);
+    IPage<AlarmInfo> alarmInfoIPage = alarmInfoBaseMapper.selectPage(page,queryMap);*/
+
+    try {
+      TBPageData tbPageData = null;//tbConnectService.getAlarmInfos(queryMap).get();
+      System.out.println("==================tbPageData:" + tbPageData);
+      List<AlarmInfoDTO> alarmInfoDTOS = ReflectUtils.sourceToTarget(tbPageData.getData(), AlarmInfoDTO.class);
+      PageData<AlarmInfoDTO> pageData = new PageData();
+      pageData.setItems(alarmInfoDTOS);
+
+      System.out.println("==================alarmInfoDTOS:" + alarmInfoDTOS);
+      return pageData;
+    } catch (Exception e) {
+      log.error("create TBAlarmInfo error {}", e.getMessage());
+      throw new FastIotException(ErrorMessage.CONNECT_TO_TB_ERROR);
+    }
+    //return getPageData(alarmInfoIPage,AlarmInfoDTO.class);
+  }
+
+
+
+  /**
+   * 查询告警中心集合
+   *
+   * @param alarmInfoDto 过滤参数
+   * @return AlarmInfoDto
+   */
+  /*@Override
+  public List<AlarmInfoDTO> findAlarmInfo(AlarmInfoDTO alarmInfoDto) {
+    List<AlarmInfo> alarmInfoList =
+            baseMapper.selectList(
+                    new QueryWrapper<AlarmInfo>()
+                            .lambda()
+                            .eq(AlarmInfo::getTenantCode, SecurityContext.getCurrentUser().getTenantCode())
+                            .like(
+                                    StringUtils.isNotBlank(alarmInfoDto.getStatus()),
+                                    AlarmInfo::getStatus,
+                                    alarmInfoDto.getStatus()));
+    return ReflectUtils.sourceToTarget(alarmInfoList, AlarmInfoDTO.class);
+  }*/
+
+  /**
+   * 创建调用TBAlarmInfo需要的参数
+   *
+   * @param alarmInfoDto 页面接收的参数
+   * @return 封装的tbAlarmInfo
+   */
+//  private TBAlarmInfo buildTbAlarmInfoFromAlarmInfoDto(AlarmInfoDTO alarmInfoDto) {
+//    // 新建tbAlarmInfo对象获取数据
+//    TBAlarmInfo tbAlarmInfo = new TBAlarmInfo();
+//    tbAlarmInfo.setDetails(alarmInfoDto.getDetails());
+//    tbAlarmInfo.setEndTs(alarmInfoDto.getEndTs());
+//    tbAlarmInfo.setSeverity(alarmInfoDto.getSeverity());
+//    tbAlarmInfo.setStatus(alarmInfoDto.getStatus());
+//    tbAlarmInfo.setType(alarmInfoDto.getType());
+//    tbAlarmInfo.setStartTs(alarmInfoDto.getStartTs());
+//    Id alarmInfoId = new Id();
+//    alarmInfoId.setEntityType(EntityType.TENANT);
+//    alarmInfoId.setId(alarmInfoId.getId());
+//    Id id = new Id();
+//    id.setId(alarmInfoId.getId());
+//    tbAlarmInfo.setTenantId(id);
+//    return tbAlarmInfo;
+//  }
+
+  /**
+   * 调用TB来保存
+   *
+   * @param alarmInfoDto 告警对象
+   */
+  private void saveOrUpdateTblarmInfo(AlarmInfoDTO alarmInfoDto) throws InterruptedException {
+    // 启用则创建连接对象
+//    if (tbConfig.isEnabled()) {
+//      TBAlarmInfo tbAlarmInfo = buildTbAlarmInfoFromAlarmInfoDto(alarmInfoDto);
+//      try {
+//        // 得到连接对象
+//        TBAlarmInfo newtbAlarmInfo = tbConnectService.saveOrUpdateAlarmInfo(tbAlarmInfo).get();
+//        // 为空
+//        if (null == newtbAlarmInfo) {
+//          throw new FastIotException(
+//              ErrorMessage.CONNECT_TO_TB_ERROR.setMessage("update tb alarmInfo error"));
+//        }
+//      } catch (ExecutionException e) {
+//        log.error("create TBAlarmInfo error {}", e.getMessage());
+//        throw new FastIotException(ErrorMessage.CONNECT_TO_TB_ERROR);
+//      }
+//    }
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmProfileDTO;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.dao.yunteng.entities.AlarmProfile;
+import org.thingsboard.server.dao.yunteng.mapper.AlarmProfileMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmProfileService;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class YtAlarmProfileServiceImpl extends AbstractBaseService<AlarmProfileMapper, AlarmProfile>
+    implements YtAlarmProfileService {
+
+  @Override
+  @Transactional
+  public AlarmProfileDTO saveOrUpdateAlarmProfile(String tenantId,AlarmProfileDTO alarmProfileDTO) {
+    AlarmProfile alarmProfile = new AlarmProfile();
+    alarmProfileDTO.copyToEntity(alarmProfile);
+    if (StringUtils.isEmpty(alarmProfileDTO.getId())) {
+      alarmProfile.setTenantId(tenantId);
+      baseMapper.insert(alarmProfile);
+    } else {
+      baseMapper.updateById(alarmProfile);
+    }
+    alarmProfile.copyToDTO(alarmProfileDTO);
+    return alarmProfileDTO;
+  }
+
+  @Override
+  @Transactional
+  public boolean deleteAlarmProfile(Set<String> ids) {
+    return baseMapper.deleteBatchIds(ids) > 0;
+  }
+
+  @Override
+  public AlarmProfileDTO findAlarmProfileByDeviceProfileId(String tenantId,String deviceProfileId) {
+    if (StringUtils.isEmpty(deviceProfileId)) {
+      throw new DataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+    }
+    List<AlarmProfile> alarmProfileList =
+        baseMapper.selectList(
+            new QueryWrapper<AlarmProfile>()
+                .lambda()
+                .eq(AlarmProfile::getDeviceProfileId, deviceProfileId)
+                .eq(AlarmProfile::getTenantId, tenantId));
+    return Optional.ofNullable(alarmProfileList)
+        .filter(alarmProfiles -> alarmProfiles.size() > 0)
+        .map(
+            alarmProfiles ->
+                ReflectUtils.sourceToTarget(alarmProfileList, AlarmProfileDTO.class).get(0))
+        .orElse(null);
+  }
+}

+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 org.apache.commons.lang3.StringUtils;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmContactDTO;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.dao.yunteng.entities.AlarmContact;
+import org.thingsboard.server.dao.yunteng.mapper.AlarmContactMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+
+/**
+ * @Description 告警联系人业务实现
+ * @Author cxy
+ * @Date 2021/11/2 14:47
+ */
+@Service
+@RequiredArgsConstructor
+public class YtAlarmServiceImpl extends AbstractBaseService<AlarmContactMapper, AlarmContact> implements YtAlarmService {
+    /**
+     * mapper注入 自带方法加入,继承的baseMapper
+     */
+
+
+    private final AlarmContactMapper alarmContactMapper;
+
+    /**
+     * 查询全部的告警联系人
+     *
+     * @param alarmContactDTO 对象
+     * @return List
+     */
+    @Override
+    public List<AlarmContactDTO> findAll(String tenantId,AlarmContactDTO alarmContactDTO) {
+        //查询当前租户
+        List<AlarmContact> list = alarmContactMapper.selectList(
+
+                new QueryWrapper<AlarmContact>()
+                        .lambda().eq(AlarmContact::getTenantId,tenantId));
+        System.out.println(list);
+        return ReflectUtils.sourceToTarget(list, AlarmContactDTO.class);
+    }
+
+    /**
+     * 新增租户
+     * @param tenantCode
+     * @return alarmContactDTO
+     */
+    private LambdaQueryWrapper<AlarmContact> tenantWapper(String tenantCode) {
+        return new QueryWrapper<AlarmContact>().lambda()
+                .eq(AlarmContact::getTenantId, tenantCode);
+    }
+    @Override
+    @Transactional
+    public AlarmContactDTO saveAlarmContact(String tenantId,AlarmContactDTO alarmContactDTO) {
+       LambdaQueryWrapper<AlarmContact> Wrapper = tenantWapper(tenantId)
+                .eq( AlarmContact::getUsername, alarmContactDTO.getUsername());
+        int Count = baseMapper.selectCount(Wrapper);
+        if (Count > 0) {
+            throw new DataValidationException("department for this name is exited");
+        }
+        alarmContactDTO.setTenantId(tenantId);
+        AlarmContact alarmContact = alarmContactDTO.getEntity(AlarmContact.class);
+        int insertCount = baseMapper.insert(alarmContact);
+        if (insertCount > 0) {
+            alarmContact.copyToDTO(alarmContactDTO);
+            return alarmContactDTO;
+        }
+        return null;
+    }
+
+    /**
+     * 删除告警联系人,byId
+     *
+     * @param Alarmids 通过列表id
+     * @return Integer
+     */
+    @Override
+
+    public boolean delete(String[] Alarmids) {
+
+        Set<String> ids = Set.of(Alarmids);
+        baseMapper.deleteBatchIds(ids);
+
+        return true;
+    }
+
+    /**
+     * 修改告警联系人数据
+     *
+     * @param alarmContactDTO 对象
+     * @return Integer
+     */
+    @Override
+    @Transactional
+    public AlarmContactDTO update(boolean istenantAdmin,String tenantId,AlarmContactDTO alarmContactDTO) {
+        //先获取id
+        AlarmContact alarmContact = alarmContactMapper.selectById(alarmContactDTO.getId());
+        if (alarmContact == null) {
+            //为空则抛出无效参数的异常
+            throw new DataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+        } else {
+            if (!istenantAdmin) {
+                if (!tenantId.equals(alarmContactDTO.getTenantId())) {
+                    throw new AccessDeniedException(ErrorMessage.HAVE_NO_PERMISSION.getMessage());
+                }
+            }
+            //复制到alarmContact
+            alarmContactDTO.copyToEntity(alarmContact);
+            baseMapper.updateById(alarmContact);
+            alarmContact.copyToDTO(alarmContactDTO);
+        }
+        return alarmContactDTO;
+    }
+
+    /**
+     * @param queryMap 查询集合
+     * @return PageData
+     */
+    @Override
+    @Transactional
+    public PageData<AlarmContactDTO> page(Map<String, Object> queryMap) {
+//查询分页,加入条模糊条件查询
+        IPage<AlarmContact> iPage = alarmContactMapper.selectPage(getPage(queryMap, "create_time", false),
+                new QueryWrapper<AlarmContact>().lambda().
+                        like(StringUtils.isNoneBlank((CharSequence) queryMap.get("username"))
+                                , AlarmContact::getUsername, queryMap.get("username")));
+
+        return getPageData(iPage, AlarmContactDTO.class);
+    }
+
+
+}

@@ -4,7 +4,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.springframework.stereotype.Service;
-import org.thingsboard.server.common.data.yunteng.common.CommonService;
+import org.thingsboard.server.common.data.yunteng.common.YtCommonService;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.SysDictItemDTO;
 import org.thingsboard.server.dao.yunteng.mapper.SysDictItemMapper;
@@ -13,7 +13,7 @@ import org.thingsboard.server.dao.yunteng.service.YtDeviceService;
 @Slf4j
 @Service
 @RequiredArgsConstructor
-public class CommonServiceImpl implements CommonService {
+public class YtCommonServiceImpl implements YtCommonService {
 
   private final SysDictItemMapper sysDictItemMapper;
   private final YtDeviceService deviceService;

+package org.thingsboard.server.dao.yunteng.impl;
+
+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.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.core.cache.CacheUtils;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmProfileDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.enums.TransportTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.dao.yunteng.entities.YtDevice;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceProfile;
+import org.thingsboard.server.dao.yunteng.mapper.DeviceMapper;
+import org.thingsboard.server.dao.yunteng.mapper.DeviceProfileMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtAlarmProfileService;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceProfileService;
+
+import java.util.*;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class YtDeviceProfileServiceImpl
+    extends AbstractBaseService<DeviceProfileMapper, org.thingsboard.server.dao.yunteng.entities.YtDeviceProfile>
+    implements YtDeviceProfileService {
+
+  private final DeviceMapper deviceMapper;
+  private final YtAlarmProfileService alarmProfileService;
+  private final CacheUtils cacheUtils;
+
+  @Override
+  @Transactional
+  public DeviceProfileDTO insertOrUpdate(String tenantId,DeviceProfileDTO deviceProfileDTO) {
+    if (StringUtils.isBlank(deviceProfileDTO.getId())) {
+      return insert(tenantId,deviceProfileDTO);
+    } else {
+      return update(tenantId,deviceProfileDTO);
+    }
+  }
+
+  private DeviceProfileDTO update(String tenantId,DeviceProfileDTO deviceProfileDTO) {
+    YtDeviceProfile deviceProfile = baseMapper.selectById(deviceProfileDTO.getId());
+    if (!deviceProfile.getTenantId().equals(tenantId)) {
+      return null;
+    }
+    deviceProfileDTO.copyToEntity(deviceProfile);
+    // 如果原来不是TCP或者更新也不是TCP 那就需要check
+    if (!deviceProfile.getTransportType().equals(TransportTypeEnum.TCP)
+        || !deviceProfileDTO.getTransportType().equals(TransportTypeEnum.TCP)) {
+      checkDeviceProfile(deviceProfileDTO, deviceProfile);
+    }
+    baseMapper.updateById(deviceProfile);
+    Optional.ofNullable(deviceProfileDTO.getAlarmProfile())
+        .filter(alarmProfileDTO -> StringUtils.isNotBlank(alarmProfileDTO.getId()))
+        .map(alarmProfileDTO -> alarmProfileService.saveOrUpdateAlarmProfile(tenantId,alarmProfileDTO));
+    return deviceProfile.getDTO(DeviceProfileDTO.class);
+  }
+
+  private DeviceProfileDTO insert(String tenantId,DeviceProfileDTO deviceProfileDTO) {
+    YtDeviceProfile deviceProfile = new YtDeviceProfile();
+    // 判断数据库是否已存在名字相同的设备配置
+    if (findDeviceProfile(tenantId,deviceProfileDTO).size() > 0) {
+      throw new DataValidationException(ErrorMessage.NAME_ALREADY_EXISTS.getMessage());
+    }
+    deviceProfileDTO.copyToEntity(deviceProfile);
+    deviceProfile.setTenantId(tenantId);
+    saveOrUpdateTBDeviceProfile(deviceProfileDTO, deviceProfile);
+    baseMapper.insert(deviceProfile);
+    Optional.ofNullable(deviceProfileDTO.getAlarmProfile())
+        .map(
+            alarmProfileDTO -> {
+              alarmProfileDTO.setDeviceProfileId(deviceProfile.getId());
+              return alarmProfileService.saveOrUpdateAlarmProfile(tenantId,alarmProfileDTO);
+            });
+    return deviceProfile.getDTO(DeviceProfileDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public void deleteDeviceProfiles(String tenantId,Set<String> ids) {
+    // check if ids bind to device
+    int count =
+        deviceMapper.selectCount(new QueryWrapper<YtDevice>().lambda().in(YtDevice::getProfileId, ids));
+    if (count > 0) {
+      throw new DataValidationException("有设备使用待删除配置，请先删除设备或者修改设备配置");
+    }
+    // TODO check if ids bind to iotfs_key_value_mapping
+    // 删除本地时,先删除TB的DeviceProfile
+    for (String id : ids) {
+      YtDeviceProfile deviceProfile = baseMapper.selectById(id);
+//        if (!tbConnectService.deleteDeviceProfile(deviceProfile.getTbProfileId()).get()) {
+//          log.error("delete TBProfile error {}", deviceProfile.getTbProfileId());
+//          throw new FastIotException(ErrorMessage.INVALID_PARAMETER);
+//        }
+      // 删除设备配置同时需要删除对应的告警配置
+      AlarmProfileDTO alarmProfileDTO = alarmProfileService.findAlarmProfileByDeviceProfileId(tenantId,id);
+      Optional.ofNullable(alarmProfileDTO)
+          .filter(alarm -> StringUtils.isNotBlank(alarm.getId()))
+          .map(
+              alarm -> {
+                Set<String> alarmList = new HashSet<>();
+                alarmList.add(alarm.getId());
+                return alarmProfileService.deleteAlarmProfile(alarmList);
+              });
+    }
+    baseMapper.delete(
+        new QueryWrapper<YtDeviceProfile>()
+            .lambda()
+            .eq(YtDeviceProfile::getTenantId, tenantId)
+            .in(YtDeviceProfile::getId, ids));
+  }
+
+  @Override
+  public Optional<DeviceProfileDTO> getDeviceProfile(String tenantId,String id) {
+    return Optional.ofNullable(
+            baseMapper.selectOne(
+                new QueryWrapper<YtDeviceProfile>()
+                    .lambda()
+                    .eq(
+                        YtDeviceProfile::getTenantId,
+                        tenantId)
+                    .eq(YtDeviceProfile::getId, id)))
+        .map(deviceProfile -> deviceProfile.getDTO(DeviceProfileDTO.class));
+  }
+
+  @Override
+  public PageData<DeviceProfileDTO> page(String tenantId,Map<String, Object> queryMap) {
+    String transportType = (String) queryMap.get("transportType");
+    TransportTypeEnum type = null;
+    if (StringUtils.isNotBlank(transportType)) {
+      type =
+          Arrays.stream(TransportTypeEnum.values())
+              .filter(s -> s.name().equalsIgnoreCase(transportType))
+              .findAny()
+              .orElse(null);
+    }
+    IPage<YtDeviceProfile> deviceIPage =
+        baseMapper.selectPage(
+            getPage(queryMap, "create_time", false),
+            new QueryWrapper<YtDeviceProfile>()
+                .lambda()
+                .eq(YtDeviceProfile::getTenantId, tenantId)
+                .eq(type != null, YtDeviceProfile::getTransportType, type)
+                .like(
+                    StringUtils.isNotBlank((String) queryMap.get("name")),
+                    YtDeviceProfile::getName,
+                    String.valueOf(queryMap.get("name"))));
+    return getPageData(deviceIPage, DeviceProfileDTO.class);
+  }
+
+  @Override
+  public List<DeviceProfileDTO> findDeviceProfile(String tenantId,DeviceProfileDTO deviceProfileDTO) {
+    List<YtDeviceProfile> deviceProfileList =
+        baseMapper.selectList(
+            new QueryWrapper<YtDeviceProfile>()
+                .lambda()
+                .eq(YtDeviceProfile::getTenantId, tenantId)
+                .like(
+                    StringUtils.isNotBlank(deviceProfileDTO.getName()),
+                    YtDeviceProfile::getName,
+                    deviceProfileDTO.getName()));
+    return ReflectUtils.sourceToTarget(deviceProfileList, DeviceProfileDTO.class);
+  }
+
+  /**
+   * 构造调用TBDeviceProfile需要的参数
+   *
+   * @param deviceProfileDTO 页面接收的参数
+   * @return 封装好的TBDeviceProfile
+
+  private TBDeviceProfile buildTbDeviceProfileFromDeviceProfileDTO(
+      DeviceProfileDTO deviceProfileDTO) {
+    TBDeviceProfile tbDeviceProfile = new TBDeviceProfile();
+    if (StringUtils.isNotBlank(deviceProfileDTO.getId())) {
+      List<DeviceProfileDTO> deviceProfile = baseMapper.getDeviceProfileInfo(deviceProfileDTO);
+      tbDeviceProfile.setId(
+          new Id(EntityType.DEVICE_PROFILE, deviceProfile.get(0).getTbProfileId()));
+    }
+    tbDeviceProfile.setName(deviceProfileDTO.getName());
+    // 传输类型默认都是Default
+    tbDeviceProfile.setTransportType(TransportTypeEnum.DEFAULT.name());
+    // 获取当前租户的默认规则链
+    tbDeviceProfile.setDefaultRuleChainId(
+        new Id(EntityType.RULE_CHAIN, getCurrentUserDefaultRuleChains()));
+    tbDeviceProfile.setDefaultQueueName(TbConnectConstant.RuleEngine.MAIN);
+    tbDeviceProfile.setProvisionType(ProvisionTypeEnum.DISABLED.name());
+    tbDeviceProfile.setCreatedTime(
+        LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
+    TBDeviceProfile.DeviceProfileData deviceProfileData = new TBDeviceProfile.DeviceProfileData();
+    deviceProfileData.setConfiguration(new TBDeviceProfile.DeviceProfileConfiguration());
+    deviceProfileData.setProvisionConfiguration(
+        new TBDeviceProfile.DeviceProfileProvisionConfiguration());
+    deviceProfileData.setTransportConfiguration(
+        new TBDeviceProfile.DeviceProfileTransportConfiguration());
+    if (null != deviceProfileDTO.getAlarms()) {
+      List<TBDeviceProfile.DeviceProfileAlarm> list = new ArrayList<>();
+      TBDeviceProfile.DeviceProfileAlarm deviceProfileAlarm =  JacksonUtil.convertValue(deviceProfileDTO.getAlarms(),TBDeviceProfile.DeviceProfileAlarm.class);
+      list.add(deviceProfileAlarm);
+      deviceProfileData.setAlarms(list);
+    }
+    tbDeviceProfile.setProfileData(deviceProfileData);
+    return tbDeviceProfile;
+  }   */
+
+  /**
+   * 检查设备配置然后进行相应的操作
+   *
+   * @param target 用户新选择的配置
+   * @param source 用户以前选择的配置
+   */
+  private void checkDeviceProfile(DeviceProfileDTO target, YtDeviceProfile source) {
+    // 原来是TCP => Default、MQTT或其他 需要新增TB设备配置文件
+    if (source.getTransportType().equals(TransportTypeEnum.TCP)
+        && !target.getTransportType().equals(TransportTypeEnum.TCP)) {
+      saveOrUpdateTBDeviceProfile(target, source);
+    }
+    if (!source.getTransportType().equals(TransportTypeEnum.TCP)) {
+      // 原来不是TCP => 更新值或者更换TB设备配置文件
+      if (!target.getTransportType().equals(TransportTypeEnum.TCP)) {
+        // 目标不是TCP则进行修改名称
+        saveOrUpdateTBDeviceProfile(target, source);
+      } else {
+        // 目标是TCP则删除原来的TBDeviceProfile
+//        tbConnectService.deleteDeviceProfile(source.getTbProfileId());
+        source.setTbProfileId(null);
+      }
+    }
+  }
+
+  /**
+   * 调用TB保存设备配置
+   *
+   * @param target 用户新选择的配置
+   * @param source 用户以前选择的配置
+   */
+  private void saveOrUpdateTBDeviceProfile(DeviceProfileDTO target, YtDeviceProfile source) {
+//    if (tbConfig.isEnabled()) {
+//      try {
+//        TBDeviceProfile tbDeviceProfile = buildTbDeviceProfileFromDeviceProfileDTO(target);
+//        tbDeviceProfile = tbConnectService.saveOrUpdateDeviceProfile(tbDeviceProfile).get();
+//        if (null == tbDeviceProfile) {
+//          throw new FastIotException(ErrorMessage.INVALID_PARAMETER);
+//        }
+//        source.setTbProfileId(tbDeviceProfile.getId().getId());
+//      } catch (ExecutionException | InterruptedException e) {
+//        log.error("create TBDeviceProfile error {}", e.getMessage());
+//        throw new FastIotException(ErrorMessage.CONNECT_TO_TB_ERROR);
+//      }
+//    }
+  }
+
+  private String getCurrentUserDefaultRuleChains() {
+    String defaultId;
+//    Optional<String> result =
+//            cacheUtils
+//                .get(
+//                    FastIotConstants.CacheConfigKey.DEFAULT_RULE_CHAIN,
+//                    SecurityContext.getCurrentUser().getTenantCode());
+//    if (null != result && result.isPresent()) {
+//      return result.get();
+//    }
+//    try {
+//      if (tbConfig.isEnabled()) {
+//        TBPageData tbPageData = tbConnectService.getRuleChains(10, 0).get();
+//        if (null == tbPageData || null == tbPageData.getData()) {
+//          throw new FastIotException(ErrorMessage.NONE_DEFAULT_RULE_CHAIN);
+//        }
+//        TBPageData convert = new TBPageData().getPageData(tbPageData,TBRuleChain.class);
+//        List<TBRuleChain> data = (List<TBRuleChain>) convert.getData();
+//        for (TBRuleChain tbRuleChain : data) {
+//          if (tbRuleChain.isRoot()) {
+//            defaultId = tbRuleChain.getId().getId();
+//            cacheUtils.put(
+//                FastIotConstants.CacheConfigKey.DEFAULT_RULE_CHAIN,
+//                SecurityContext.getCurrentUser().getTenantCode(),
+//                defaultId);
+//            return defaultId;
+//          }
+//        }
+//      }
+//    } catch (ExecutionException | InterruptedException e) {
+//      throw new FastIotException(ErrorMessage.CONNECT_TO_TB_ERROR);
+//    }
+    return null;
+  }
+}

@@ -9,7 +9,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
 import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
 import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
@@ -22,6 +21,7 @@ import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
 import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
 import org.thingsboard.server.dao.yunteng.entities.Organization;
 import org.thingsboard.server.dao.yunteng.entities.YtDevice;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceProfile;
 import org.thingsboard.server.dao.yunteng.mapper.DeviceMapper;
 import org.thingsboard.server.dao.yunteng.mapper.DeviceProfileMapper;
 import org.thingsboard.server.dao.yunteng.mapper.OrganizationMapper;
@@ -56,7 +56,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
 
   private DeviceDTO update(String tenantId,DeviceDTO deviceDTO) {
     YtDevice device = baseMapper.selectById(deviceDTO.getId());
-    if (!device.getTenantCode().equals(tenantId)) {
+    if (!device.getTenantId().equals(tenantId)) {
       return null;
     }
     validateDeviceDTO(tenantId,deviceDTO, false);
@@ -208,7 +208,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
       }
     }
     // 验证数据profileId的正确性
-    DeviceProfile deviceProfile = deviceProfileMapper.selectById(deviceDTO.getProfileId());
+    YtDeviceProfile deviceProfile = deviceProfileMapper.selectById(deviceDTO.getProfileId());
     Organization organization = organizationMapper.selectById(deviceDTO.getOrganizationId());
     if (null == deviceProfile || null == organization) {
       throw new DataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
@@ -217,7 +217,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
     } else if (!deviceProfile
             .getTenantId()
             .equals(tenantId)
-        || !organization.getTenantCode().equals(tenantId)) {
+        || !organization.getTenantId().equals(tenantId)) {
       throw new DataValidationException(ErrorMessage.TENANT_MISMATCHING.getMessage());
     }
   }
@@ -246,7 +246,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
         ModelConstants.TablePropertyMapping.CREATE_TIME,
         ModelConstants.TablePropertyMapping.UPDATE,
         ModelConstants.TablePropertyMapping.UPDATE_TIME);
-    device.setTenantCode(tenantId);
+    device.setTenantId(tenantId);
     // First insert into TB
 //    if (tbConfig.isEnabled()) {
 //      Device tbDevice = buildTbDeviceFromDeviceDTO(deviceDTO);
@@ -316,7 +316,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
     LambdaQueryWrapper<YtDevice> queryWrapper =
         new QueryWrapper<YtDevice>()
             .lambda()
-            .eq(YtDevice::getTenantCode, tenantId)
+            .eq(YtDevice::getTenantId, tenantId)
             .in(YtDevice::getId, ids);
 
     List<String> tbDeviceIds =
@@ -336,7 +336,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
             baseMapper.selectOne(
                 new QueryWrapper<YtDevice>()
                     .lambda()
-                    .eq(YtDevice::getTenantCode, tenantId)
+                    .eq(YtDevice::getTenantId, tenantId)
                     .eq(YtDevice::getId, id)))
         .map(device -> device.getDTO(DeviceDTO.class));
   }
@@ -374,7 +374,7 @@ public class YtDeviceServiceImpl extends AbstractBaseService<DeviceMapper, YtDev
                     StringUtils.isNotBlank(deviceDTO.getDeviceToken()),
                     YtDevice::getDeviceToken,
                     deviceDTO.getDeviceToken())
-                .eq(true, YtDevice::getTenantCode, tenantId)
+                .eq(true, YtDevice::getTenantId, tenantId)
                 .like(
                     StringUtils.isNotBlank(deviceDTO.getName()),
                     YtDevice::getName,

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceTypeDTO;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tree.TreeUtils;
+import org.thingsboard.server.dao.yunteng.entities.DeviceType;
+import org.thingsboard.server.dao.yunteng.mapper.DeviceTypeMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceTypeService;
+
+import java.util.List;
+
+@Service
+public class YtDeviceTypeServiceImpl extends AbstractBaseService<DeviceTypeMapper, DeviceType>
+    implements YtDeviceTypeService {
+  @Override
+  public List<DeviceTypeDTO> getDeviceTypeTree(String tenantId) {
+    if (StringUtils.isEmpty(tenantId)) {
+      if (StringUtils.isEmpty(tenantId)) {
+        throw new DataValidationException(ErrorMessage.INVALID_PARAMETER.getMessage());
+      }
+    }
+    List<DeviceType> typeList = baseMapper.selectList(
+        new QueryWrapper<DeviceType>()
+            .lambda()
+            .eq(StringUtils.isNoneEmpty(tenantId), DeviceType::getTenantId, tenantId));
+    return TreeUtils.buildTree(ReflectUtils.sourceToTarget(typeList,DeviceTypeDTO.class));
+  }
+
+  @Override
+  @Transactional
+  public DeviceTypeDTO saveDeviceTye(String tenantId,DeviceTypeDTO deviceTypeDTO) {
+    deviceTypeDTO.setTenantId(tenantId);
+    DeviceType deviceType = deviceTypeDTO.getEntity(DeviceType.class);
+    int insertCount = baseMapper.insert(deviceType);
+    if (insertCount > 0) {
+      deviceType.copyToDTO(deviceTypeDTO);
+      return deviceTypeDTO;
+    }
+    return null;
+  }
+
+  @Override
+  public DeviceTypeDTO updateDeviceType(DeviceTypeDTO deviceTypeDTO) {
+    DeviceType deviceType = deviceTypeDTO.getEntity(DeviceType.class);
+    int insertCount = baseMapper.updateById(deviceType);
+    if (insertCount > 0) {
+      deviceType.copyToDTO(deviceTypeDTO);
+      return deviceTypeDTO;
+    }
+    return null;
+  }
+
+  @Override
+  public boolean deleteDeviceType(DeleteDTO deleteDTO) {
+    return baseMapper.deleteBatchIds(deleteDTO.getIds()) > 0;
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+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.MailLogDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.dao.yunteng.entities.MailLog;
+import org.thingsboard.server.dao.yunteng.mapper.MaiLogMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtMailLogService;
+
+import java.util.Map;
+import java.util.Set;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class YtMailLogServiceImpl extends AbstractBaseService<MaiLogMapper, MailLog>
+    implements YtMailLogService {
+  @Override
+  public PageData<MailLogDTO> page(String tenantId,Map<String, Object> queryMap) {
+    IPage<MailLog> configIPage =
+        baseMapper.selectPage(
+            getPage(queryMap, "send_time", false),
+            new QueryWrapper<MailLog>()
+                .lambda()
+                .eq(MailLog::getTenantId, tenantId)
+                .like(
+                    queryMap.get("emailSubject") != null,
+                    MailLog::getEmailSubject,
+                    String.valueOf(queryMap.get("emailSubject")))
+                .between(
+                    queryMap.get("startTime") != null && queryMap.get("endTime") != null,
+                    MailLog::getSendTime,
+                    queryMap.get("startTime"),
+                    queryMap.get("endTime")));
+    return getPageData(configIPage, MailLogDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public boolean deleteMailLog(Set<String> ids) {
+    return baseMapper.deleteBatchIds(ids) > 0;
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import jakarta.mail.*;
+import jakarta.mail.internet.InternetAddress;
+import jakarta.mail.internet.MimeBodyPart;
+import jakarta.mail.internet.MimeMessage;
+import jakarta.mail.internet.MimeMultipart;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.yunteng.config.email.EmailConfiguration;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.exception.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.request.EmailReqDTO;
+import org.thingsboard.server.common.data.yunteng.enums.EmailFormatEnum;
+import org.thingsboard.server.common.data.yunteng.enums.ResponseCodeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
+import org.thingsboard.server.dao.yunteng.entities.MailLog;
+import org.thingsboard.server.dao.yunteng.entities.MessageConfig;
+import org.thingsboard.server.dao.yunteng.entities.MessageTemplate;
+import org.thingsboard.server.dao.yunteng.mapper.MaiLogMapper;
+import org.thingsboard.server.dao.yunteng.mapper.MessageConfigMapper;
+import org.thingsboard.server.dao.yunteng.mapper.MessageTemplateMapper;
+import org.thingsboard.server.dao.yunteng.service.YtMailService;
+
+import java.io.File;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.util.Date;
+import java.util.Properties;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class YtMailServiceImpl implements YtMailService {
+
+  private final MessageTemplateMapper messageTemplateMapper;
+
+  private final MessageConfigMapper messageConfigMapper;
+
+  private final MaiLogMapper maiLogMapper;
+
+  @Override
+  public boolean sendEmail(EmailReqDTO emailReqDTO) {
+    boolean result =false;
+    //查询模板信息
+    MessageTemplate messageTemplate = messageTemplateMapper.selectById(emailReqDTO.getId());
+    if(null == messageTemplate){
+      throw new DataValidationException("invalid parameters");
+    }
+    MessageConfig messageConfig =messageConfigMapper.selectById(messageTemplate.getMessageConfigId());
+    if (messageConfig.getStatus() != FastIotConstants.StateValue.ENABLE) {
+      throw new DataValidationException("messageConfig is disable");
+    }
+    JsonNode configNode = messageConfig.getConfig();
+    EmailConfiguration emailConfiguration = JacksonUtil.convertValue(configNode, EmailConfiguration.class);
+     if(emailConfiguration !=null){
+      Properties props = new Properties();
+      // 要连接的SMTP服务器
+      props.put("mail.smtp.host", emailConfiguration.getHost());
+      // 如果 connect()方法未明确指定一个，则要连接的SMTP服务器端口。默认为25
+      props.put("mail.smtp.port", emailConfiguration.getPort());
+      props.put("mail.smtp.user", emailConfiguration.getUsername());
+      props.put("mail.smtp.pass", emailConfiguration.getPassword());
+      props.put("mail.smtp.ssl.enable", "true");
+      // 如果为true，请尝试使用AUTH命令对用户进行身份验证。默认为false。
+      props.put("mail.smtp.auth", "true");
+      // 使用ssl
+      props.put("mail.smtp.ssl.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
+      props.put("mail.smtp.socketFactory.port",emailConfiguration.getPort());
+
+      try {
+        Session session =
+                Session.getInstance(
+                        props,
+                        new Authenticator() {
+                          @Override
+                          protected PasswordAuthentication getPasswordAuthentication() {
+                            if (Boolean.parseBoolean(props.getProperty("mail.smtp.auth"))) {
+                              // 需要认证
+                              return new PasswordAuthentication(
+                                      props.getProperty("mail.smtp.user"),
+                                      props.getProperty("mail.smtp.pass"));
+                            }
+                            return super.getPasswordAuthentication();
+                          }
+                        });
+
+        MimeMessage mimeMessage = new MimeMessage(session);
+        // 邮件发送人
+        mimeMessage.setFrom(new InternetAddress(emailConfiguration.getUsername()));
+        setRecipients(emailReqDTO,mimeMessage);
+        // 邮件主题
+        mimeMessage.setSubject(emailReqDTO.getSubject());
+        // 邮件内容部分
+        MimeBodyPart mimeBodyPart = new MimeBodyPart();
+        String chartSet = "text/html;charset=utf-8";
+        if (emailReqDTO.getEmailFormatEnum().equals(EmailFormatEnum.TEXT.name())) {
+          mimeBodyPart.setText(emailReqDTO.getBody());
+        } else {
+          mimeBodyPart.setContent(emailReqDTO.getBody(), chartSet);
+        }
+        Multipart multipart = new MimeMultipart();
+        multipart.addBodyPart(mimeBodyPart);
+
+        //如果有附件就添加附件
+        if(null != emailReqDTO.getFiles() && emailReqDTO.getFiles().length>0){
+          addFiles(multipart,emailReqDTO.getFiles());
+        }
+        mimeMessage.setContent(multipart);
+        mimeMessage.setSentDate(new Date());
+        Transport.send(mimeMessage);
+        result = true;
+      } catch (Exception exception){
+        log.error("send email failed",exception);
+      }
+       MailLog mailLog = new MailLog();
+       mailLog.setEmailFrom(emailConfiguration.getUsername());
+       mailLog.setEmailTo(JacksonUtil.toJsonNode(JacksonUtil.toString(emailReqDTO.getTo())));
+       mailLog.setEmailCc(JacksonUtil.toJsonNode(JacksonUtil.toString(emailReqDTO.getCc())));
+       mailLog.setEmailBcc(JacksonUtil.toJsonNode(JacksonUtil.toString(emailReqDTO.getBcc())));
+       mailLog.setEmailSubject(emailReqDTO.getSubject());
+       mailLog.setEmailBody(emailReqDTO.getBody());
+       mailLog.setTenantId(messageTemplate.getTenantId());
+       mailLog.setSendTime(LocalDateTime.now());
+       mailLog.setMessageTemplateId(messageTemplate.getId());
+       mailLog.setStatus(result ? ResponseCodeEnum.SUCCESS.name() : ResponseCodeEnum.FAILED.name());
+       mailLog.setRemark(emailReqDTO.getRemark());
+       mailLog.setTemplatePurpose(emailReqDTO.getTemplatePurpose());
+       maiLogMapper.insert(mailLog);
+       return result;
+    }
+    return false;
+  }
+
+  /**
+   * 添加接收人、抄送人、密送人
+   * @param emailReqDTO 邮件参数
+   * @param mimeMessage 邮件消息体
+   * @throws MessagingException 消息发送失败异常
+   */
+  private void setRecipients(EmailReqDTO emailReqDTO, MimeMessage mimeMessage)
+      throws MessagingException {
+    // 邮件接收人多个
+    InternetAddress[] toAddress = addInternetAddress(emailReqDTO.getTo());
+    mimeMessage.setRecipients(Message.RecipientType.TO, toAddress);
+
+    if(null != emailReqDTO.getCc() && emailReqDTO.getCc().length>0){
+      // 邮件抄送人多个
+      InternetAddress[] ccAddress = addInternetAddress(emailReqDTO.getCc());
+      mimeMessage.setRecipients(Message.RecipientType.CC, ccAddress);
+    }
+    if(null != emailReqDTO.getBcc() &&emailReqDTO.getBcc().length>0){
+      // 邮件密送人多个
+      InternetAddress[] bccAddress = addInternetAddress(emailReqDTO.getBcc());
+      mimeMessage.setRecipients(Message.RecipientType.BCC, bccAddress);
+    }
+  }
+
+  /**
+   * 添加收件人地址
+   * @param content 接收人、抄送人、密送人数组
+   * @return 添加收件人地址
+   * @throws MessagingException 地址异常
+   */
+  private InternetAddress[] addInternetAddress(String[] content)
+          throws MessagingException {
+    InternetAddress[] address = new InternetAddress[content.length];
+    for (int i = 0,j = content.length;i<j; i++) {
+      address[i] = new InternetAddress(content[i]);
+    }
+    return address;
+  }
+
+  /**
+   * 添加附件
+   * @param multipart Multipart
+   * @param files 附件
+   * @throws MessagingException 消息发送失败异常
+   * @throws IOException IO流异常
+   */
+  private void addFiles(Multipart multipart,File[] files) throws MessagingException, IOException {
+    for (File file : files) {
+      MimeBodyPart attachment = new MimeBodyPart();
+      attachment.attachFile(file);
+      multipart.addBodyPart(attachment);
+    }
+  }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+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.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.DataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.MessageConfigDTO;
+import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+import org.thingsboard.server.dao.yunteng.entities.MessageConfig;
+import org.thingsboard.server.dao.yunteng.mapper.MessageConfigMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtMessageConfigService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class YtMessageConfigServiceImpl
+    extends AbstractBaseService<MessageConfigMapper, MessageConfig>
+    implements YtMessageConfigService {
+
+  @Override
+  public PageData<MessageConfigDTO> page(String tenantId,Map<String, Object> queryMap) {
+    IPage<MessageConfig> configIPage =
+        baseMapper.selectPage(
+            getPage(queryMap, "create_time", false),
+            new QueryWrapper<MessageConfig>()
+                .lambda()
+                .eq(
+                    queryMap.get("platformType") != null,
+                    MessageConfig::getPlatformType,
+                    String.valueOf(queryMap.get("platformType")))
+                .eq(
+                    queryMap.get("messageType") != null,
+                    MessageConfig::getMessageType,
+                    String.valueOf(queryMap.get("messageType")))
+                .eq(
+                    queryMap.get("status") != null,
+                    MessageConfig::getStatus,
+                    String.valueOf(queryMap.get("status")))
+                .eq(
+                    true,
+                    MessageConfig::getTenantId,tenantId));
+    return getPageData(configIPage, MessageConfigDTO.class);
+  }
+
+  @Override
+  @Transactional
+  public MessageConfigDTO saveMessageConfig(String tenantId,MessageConfigDTO configDTO) {
+    checkMessageConfig(configDTO, tenantId);
+    MessageConfig config = new MessageConfig();
+    configDTO.copyToEntity(config);
+    config.setTenantId(tenantId);
+    baseMapper.insert(config);
+    config.copyToDTO(configDTO);
+    return configDTO;
+  }
+
+  @Override
+  @Transactional
+  public boolean deleteMessageConfig(Set<String> ids) {
+    return baseMapper.deleteBatchIds(ids) > 0;
+  }
+
+  @Override
+  @Transactional
+  public MessageConfigDTO updateMessageConfig(String tenantId,MessageConfigDTO configDTO) {
+    MessageConfig config = baseMapper.selectById(configDTO.getId());
+    if (configDTO.getStatus() == FastIotConstants.StateValue.ENABLE) {
+      if (StringUtils.isEmpty(config.getId())) {
+        throw new DataValidationException("invalid parameters");
+      }
+      checkMessageConfig(configDTO, tenantId);
+    }
+    configDTO.copyToEntity(config);
+    config.setTenantId(tenantId);
+
+    baseMapper.updateById(config);
+    config.copyToDTO(configDTO);
+    return configDTO;
+  }
+
+  /**
+   * 通过租户Code、消息类型和平台类型获取启用的配置
+   *
+   * @param messageType 消息类型
+   * @param platform 平台类型
+   * @param tenantCode 租户Code
+   * @return 启用的配置信息
+   */
+  @Override
+  public MessageConfigDTO getEnableConfigByMessageAndPlatform(
+      String messageType, String platform, String tenantCode) {
+    return baseMapper.getEnableConfigByMessageAndPlatform(messageType, platform, tenantCode);
+  }
+
+  /**
+   * 通过ID查询MessageConfig信息
+   *
+   * @param id 主键ID
+   * @return 返回类型：MessageConfigDTO
+   */
+  @Override
+  public MessageConfigDTO findMessageConfigById(String id) {
+    MessageConfigDTO messageConfigDTO = new MessageConfigDTO();
+    MessageConfig messageConfig = baseMapper.selectById(id);
+    if (null == messageConfig) {
+      return null;
+    }
+    messageConfig.copyToDTO(messageConfigDTO);
+    return messageConfigDTO;
+  }
+
+  @Override
+  public List<MessageConfigDTO> findMessageInfo(MessageConfigDTO configDTO) {
+    return ReflectUtils.sourceToTarget(
+        baseMapper.selectList(
+            new QueryWrapper<MessageConfig>()
+                .lambda()
+                .eq(
+                    configDTO.getMessageType() != null,
+                    MessageConfig::getMessageType,
+                    configDTO.getMessageType())),
+        MessageConfigDTO.class);
+  }
+
+  /**
+   * 检查MessageConfig状态
+   *
+   * @param configDTO MessageConfig配置
+   * @param tenantCode 租户Code
+   */
+  private void checkMessageConfig(MessageConfigDTO configDTO, String tenantCode) {
+    // 查询该租户下是否有相同消息类型和平台的配置已经启用
+    MessageConfigDTO enableConfig =
+        getEnableConfigByMessageAndPlatform(
+            configDTO.getMessageType(), configDTO.getPlatformType(), tenantCode);
+    if (null != enableConfig && !enableConfig.getId().equalsIgnoreCase(configDTO.getId())) {
+      throw new DataValidationException("enabled config is existed");
+    }
+  }
+}

@@ -13,7 +13,7 @@ import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
 import org.thingsboard.server.dao.yunteng.entities.MessageTemplate;
 import org.thingsboard.server.dao.yunteng.mapper.MessageTemplateMapper;
 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
-import org.thingsboard.server.dao.yunteng.service.MessageTemplateService;
+import org.thingsboard.server.dao.yunteng.service.YtMessageTemplateService;
 
 import java.util.List;
 import java.util.Map;
@@ -22,9 +22,9 @@ import java.util.Set;
 @Service
 @Slf4j
 @RequiredArgsConstructor
-public class MessageTemplateServiceImpl
+public class YtMessageTemplateServiceImpl
     extends AbstractBaseService<MessageTemplateMapper, MessageTemplate>
-    implements MessageTemplateService {
+    implements YtMessageTemplateService {
   @Override
   public PageData<MessageTemplateDTO> page(Map<String, Object> queryMap) {
 //    queryMap.put("tenantCode",SecurityContext.getCurrentUser().getTenantCode());

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.yunteng.dto.AlarmInfoDTO;
+import org.thingsboard.server.common.data.yunteng.dto.request.EmailReqDTO;
+import org.thingsboard.server.common.data.yunteng.dto.request.SmsReqDTO;
+import org.thingsboard.server.common.data.yunteng.enums.AssetStatusEnum;
+import org.thingsboard.server.common.data.yunteng.enums.MessageTypeEnum;
+import org.thingsboard.server.common.data.yunteng.enums.MsgTemplatePurposeEnum;
+import org.thingsboard.server.dao.yunteng.entities.*;
+import org.thingsboard.server.dao.yunteng.mapper.*;
+import org.thingsboard.server.dao.yunteng.service.YtNoticeService;
+import org.thingsboard.server.dao.yunteng.service.YtMailService;
+import org.thingsboard.server.dao.yunteng.service.YtSmsService;
+
+import java.time.LocalDateTime;
+import java.time.OffsetDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @version V1.0
+ * @Description :
+ * 1.其它地方抛出异常，交由控制层统一处理
+ * 2.服务层注意持久化的事务管理
+ * @Dependency: 依赖包
+ * @Author: junlianglee
+ * @Date Created in 2021/11/23$
+ * @Copyright 2016-2018  - Powered By 云腾五洲
+ */
+@Service
+@RequiredArgsConstructor
+public class YtNoticeServiceImpl implements YtNoticeService {
+
+    private final DeviceMapper deviceMapper;
+    private final OrganizationMapper organizationMapper;
+    private final AlarmProfileMapper alarmProfileMapper;
+    private final AlarmContactMapper alarmContactMapper;
+    private final MessageTemplateMapper messageTemplateMapper;
+
+    private final YtSmsService smsService;
+    private final YtMailService mailService;
+
+    @Override
+    public void alert(String token, AlarmInfoDTO alarmInfo) {
+
+        //TODO   查找设备和设备所属组织
+        QueryWrapper<YtDevice> queryWrapper=new QueryWrapper<YtDevice>();
+        queryWrapper.lambda()
+                .eq(YtDevice::getTbDeviceId, alarmInfo.getDeviceId());
+        YtDevice device = deviceMapper.selectOne(queryWrapper);
+
+
+        //TODO   查找告警配置 ,与设备配置一一对应。
+         if(device == null){
+             return;
+         }
+        QueryWrapper<Organization> organizationQueryWrapper=new QueryWrapper<Organization>();
+        organizationQueryWrapper.lambda()
+                .eq(Organization::getId, device.getOrganizationId());
+        Organization organization = organizationMapper.selectOne(organizationQueryWrapper);
+
+        QueryWrapper<AlarmProfile> alarmProfileQueryWrapper=new QueryWrapper<AlarmProfile>();
+        alarmProfileQueryWrapper.lambda()
+                .eq(AlarmProfile::getDeviceProfileId, device.getProfileId());
+        AlarmProfile alarmProfile = alarmProfileMapper.selectOne(alarmProfileQueryWrapper);
+
+
+        //TODO   查找告警通知联系人
+        if(alarmProfile == null || alarmProfile.getAlarmContactId().isEmpty() || alarmProfile.getMessageMode().isEmpty()){
+            return;
+        }
+        String messageCode = alarmProfile.getMessageMode();
+        List<AlarmContact> alarmContactList = alarmContactMapper.selectBatchIds(Arrays.stream(alarmProfile.getAlarmContactId().split(",")).distinct().collect(Collectors.toList()));
+        noticeAll(messageCode, alarmContactList,alarmInfo,organization);
+
+
+    }
+
+    /**
+     * 通知所有联系人
+     * @param messageCode       通知类型
+     * @param alarmContactList  通知联系人
+     * @param alarmInfo         通知内容
+     * @param organization      设备所属组织
+     */
+    private void noticeAll(String messageCode, List<AlarmContact> alarmContactList, AlarmInfoDTO alarmInfo, Organization organization) {
+        Optional.ofNullable(alarmContactList).ifPresent(contacts ->{
+            QueryWrapper<MessageTemplate> messageTemplateQueryWrapper=new QueryWrapper<MessageTemplate>();
+            messageTemplateQueryWrapper.lambda()
+//                    .eq(MessageTemplate::getTenantCode, SecurityContext.getCurrentUser().getTenantCode())
+                    .eq(MessageTemplate::getTemplatePurpose, MsgTemplatePurposeEnum.FOR_ALARM_NOTICE.name())
+                    .eq(MessageTemplate::getStatus, AssetStatusEnum.ENABLE.ordinal());
+            List<MessageTemplate>templateList = messageTemplateMapper.selectList(messageTemplateQueryWrapper);
+            Map<String,String> templatesMap = new HashMap<>();
+            Optional.ofNullable(templateList).ifPresent(all ->{
+                for(MessageTemplate item: all){
+                    templatesMap.put(item.getMessageType(),item.getId());
+                }
+            });
+            contacts.stream().parallel().forEach(item ->{
+                if(messageCode.contains(MessageTypeEnum.PHONE_MESSAGE.name())
+                        &&templatesMap.containsKey(MessageTypeEnum.PHONE_MESSAGE.name())
+                        && !item.getPhone().isEmpty()){
+
+
+
+
+                    SmsReqDTO info = new SmsReqDTO();
+                    info.setId(templatesMap.get(MessageTypeEnum.PHONE_MESSAGE.name()));
+                    info.setPhoneNumbers(item.getPhone());
+                    LinkedHashMap<String, String> params = new LinkedHashMap<>();
+                    //name-其他；device_name-其他；level-其他；location-其他；alarm_value-其他；
+                    params.put("type", alarmInfo.getType());
+                    params.put("device_name", alarmInfo.getDeviceName());
+                    params.put("severity", alarmInfo.getSeverity());
+                    params.put("organization", organization!=null?organization.getName():"");
+                    LocalDateTime createTime = LocalDateTime.ofEpochSecond(alarmInfo.getCreateTs()/1000,0, OffsetDateTime.now().getOffset());
+                    params.put("createtime", createTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                    info.setParams(params);
+                    smsService.sendSms(info);
+                }
+
+                if(messageCode.contains(MessageTypeEnum.EMAIL_MESSAGE.name())
+                        &&templatesMap.containsKey(MessageTypeEnum.EMAIL_MESSAGE.name())
+                        && !item.getEmail().isEmpty()){
+                    EmailReqDTO info = new EmailReqDTO();
+                    mailService.sendEmail(info);
+                }
+
+
+                if(messageCode.contains(MessageTypeEnum.DING_TALK_MESSAGE.name())
+                        &&templatesMap.containsKey(MessageTypeEnum.DING_TALK_MESSAGE.name())
+                        && !item.getDingtalk().isEmpty()){
+
+                }
+
+                if(messageCode.contains(MessageTypeEnum.WECHAT_MESSAGE.name())
+                        &&templatesMap.containsKey(MessageTypeEnum.WECHAT_MESSAGE.name())
+                        && !item.getWechat().isEmpty()){
+
+                }
+            });
+        });
+    }
+}

@@ -20,15 +20,15 @@ import org.thingsboard.server.dao.yunteng.mapper.OrganizationMapper;
 import org.thingsboard.server.dao.yunteng.mapper.UserMapper;
 import org.thingsboard.server.dao.yunteng.mapper.UserOrganizationMappingMapper;
 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
-import org.thingsboard.server.dao.yunteng.service.OrganizationService;
+import org.thingsboard.server.dao.yunteng.service.YtOrganizationService;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor
-public class OrganizationServiceImpl extends AbstractBaseService<OrganizationMapper, Organization>
-    implements OrganizationService {
+public class YtOrganizationServiceImpl extends AbstractBaseService<OrganizationMapper, Organization>
+    implements YtOrganizationService {
 
   private final UserOrganizationMappingMapper userOrganizationMappingMapper;
   private final UserMapper userMapper;
@@ -44,7 +44,7 @@ public class OrganizationServiceImpl extends AbstractBaseService<OrganizationMap
         throw new DataValidationException("parent organization not exist!");
       } else {
         if (!organization
-            .getTenantCode()
+            .getTenantId()
             .equals(null)) {//TODO getCurrentUser().getTenantCode()
           throw new DataValidationException("parent organization not exist.");
         }

@@ -8,7 +8,6 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.common.util.JacksonUtil;
@@ -98,7 +97,7 @@ public class YtSmsServiceImpl implements YtSmsService {
         smsLog.setMessageTemplateId(messageTemplate.getId());
         smsLog.setTemplateParam(JacksonUtil.toJsonNode(JacksonUtil.toString(templateParam)));
         smsLog.setSendTime(LocalDateTime.now());
-        smsLog.setTenantCode(messageTemplate.getTenantCode());
+        smsLog.setTenantCode(messageTemplate.getTenantId());
         smsLog.setTemplatePurpose(smsReqDTO.getTemplatePurpose());
         smsLogMapper.insert(smsLog);
         return ResponseCodeEnum.SUCCESS.name().equals(result);

@@ -46,7 +46,7 @@ public class YtTenantServiceImpl extends AbstractBaseService<TenantMapper, Tenan
     baseMapper.insert(tenant);
     // 调用TB API
     tenant.copyToDTO(tenantDTO);
-    saveTenantMapping(tenantDTO.getTenantCode(), tenantReqDTO.getRoleIds());
+    saveTenantMapping(tenantDTO.getTenantId(), tenantReqDTO.getRoleIds());
     return tenantDTO;
   }
 
@@ -76,20 +76,20 @@ public class YtTenantServiceImpl extends AbstractBaseService<TenantMapper, Tenan
   }
 
   private void processTenantCode(TenantDTO tenantDTO) {
-    if (tenantDTO.getTenantCode() != null) {
-      if (tenantDTO.getTenantCode().length() > 30) {
+    if (tenantDTO.getTenantId() != null) {
+      if (tenantDTO.getTenantId().length() > 30) {
         throw new DataValidationException("tenant code too long");
       }
       int count =
           baseMapper.selectCount(
               new QueryWrapper<Tenant>()
                   .lambda()
-                  .eq(Tenant::getTenantCode, tenantDTO.getTenantCode()));
+                  .eq(Tenant::getTenantCode, tenantDTO.getTenantId()));
       if (count > 0) {
         throw new DataValidationException("tenant code already exist");
       }
     } else {
-      tenantDTO.setTenantCode(RandomStringUtils.randomAlphabetic(20));
+      tenantDTO.setTenantId(RandomStringUtils.randomAlphabetic(20));
     }
   }
 
@@ -130,7 +130,7 @@ public class YtTenantServiceImpl extends AbstractBaseService<TenantMapper, Tenan
       menuMapper.deleteTenantMenuMappingByMenuIds(allMenuIds);
     }
     // 4. DELETE USER
-    userMapper.delete(new QueryWrapper<User>().lambda().in(User::getTenantCode, tenantCodes));
+    userMapper.delete(new QueryWrapper<User>().lambda().in(User::getTenantId, tenantCodes));
     // 5. TELL RULE ENGINE TO STOP TENANT
     // 6. DELETE OTHER RESOURCES IF ANY
     // 7. DELETE TENANT

@@ -59,8 +59,8 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
   private final TenantRoleMapper tenantRoleMapper;
 
   private final YtSmsService ytSmsService;
-  private final MessageTemplateService messageTemplateService;
-  private final OrganizationService groupService;
+  private final YtMessageTemplateService messageTemplateService;
+  private final YtOrganizationService groupService;
 
   public static final String ACTIVATE_URL_PATTERN = "%s/api/noauth/activate?activateToken=%s";
   private final PasswordEncoder passwordEncoder;
@@ -98,7 +98,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
     if (isAdminOperate) {
       // 添加的租户管理员
       if (StringUtils.isNotBlank(userDTO.getTenantCode())) {
-        user.setTenantCode(userDTO.getTenantCode());
+        user.setTenantId(userDTO.getTenantCode());
         user.setPassword(passwordEncoder.encode(DEFAULT_PWD));
         int tenantExist =
             tenantMapper.selectCount(
@@ -111,24 +111,24 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
       } else {
         // 添加的平台系统其他用户
         user.setLevel(FastIotConstants.LevelValue.IS_OTHER_ADMIN);
-        user.setTenantCode(tenantId);
+        user.setTenantId(tenantId);
       }
       userExist =
           baseMapper.selectCount(
                   new QueryWrapper<User>()
                       .lambda()
                       .eq(User::getUsername, userDTO.getUsername())
-                      .eq(User::getTenantCode, userDTO.getTenantCode()))
+                      .eq(User::getTenantId, userDTO.getTenantCode()))
               > 0;
     } else {
       user.setLevel(FastIotConstants.LevelValue.IS_NORMAL);
-      user.setTenantCode(tenantId);
+      user.setTenantId(tenantId);
       userExist =
           baseMapper.selectCount(
                   new QueryWrapper<User>()
                       .lambda()
                       .eq(User::getUsername, userDTO.getUsername())
-                      .eq(User::getTenantCode, tenantId))
+                      .eq(User::getTenantId, tenantId))
               > 0;
     }
     if (userExist) {
@@ -170,7 +170,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
   public String getActivationLink(String userId,boolean isSysadmin,String tenantId) {
     User user = baseMapper.selectById(userId);
     if (!isSysadmin
-        && tenantId.equals(user.getTenantCode())) {
+        && tenantId.equals(user.getTenantId())) {
       throw new AccessDeniedException(
           "you don't have permission to get activation link for this user");
     }
@@ -224,7 +224,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
       UserDTO userDTO = new UserDTO();
       user.copyToDTO(userDTO, PASSWORD, ACTIVATE_TOKEN);
       if (!isSysadmin
-          && !tenantId.equals(user.getTenantCode())) {
+          && !tenantId.equals(user.getTenantId())) {
         return Optional.empty();
       }
       return Optional.of(userDTO);
@@ -239,7 +239,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
     Assert.notNull(userDTO.getId(), "user is must be specified");
     User user = baseMapper.selectById(userDTO.getId());
     if (!isSysadmin
-        && !user.getTenantCode().equals(tenantId)) {
+        && !user.getTenantId().equals(tenantId)) {
       throw new NoneTenantAssetException("this user not belong to current tenant");
     }
     if (!user.getUsername().equals(userDTO.getUsername())) {
@@ -325,7 +325,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
           baseMapper.selectCount(
               new QueryWrapper<User>()
                   .lambda()
-                  .ne(User::getTenantCode, tenantId)
+                  .ne(User::getTenantId, tenantId)
                   .in(User::getId, userIds));
       if (notTenantUserCount > 0) {
         throw new AccessDeniedException("cannot delete user that not belong to your tenant");
@@ -388,7 +388,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
       if (user == null) {
         return;
       }
-      if (tenantId.equals(user.getTenantCode())) {
+      if (tenantId.equals(user.getTenantId())) {
         baseMapper.setPassword2NullAndInsertActiveToken(
             userId, RandomStringUtils.randomAlphabetic(10));
       }
@@ -434,7 +434,7 @@ public class YtUserServiceImpl extends AbstractBaseService<UserMapper, User> imp
   public Optional<List<UserDTO>> getOrganizationUserByOrganizationId(String groupId,String tenantId) {
     Organization group = organizationMapper.selectById(groupId);
     if (group == null
-        || !group.getTenantCode().equals(tenantId)) {
+        || !group.getTenantId().equals(tenantId)) {
       return Optional.empty();
     }
     Set<String> userIds =

@@ -3,13 +3,13 @@ package org.thingsboard.server.dao.yunteng.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Mapper;
-import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceProfile;
 
 import java.util.List;
 
 @Mapper
-public interface DeviceProfileMapper extends BaseMapper<DeviceProfile> {
+public interface DeviceProfileMapper extends BaseMapper<YtDeviceProfile> {
 
     List<DeviceProfileDTO> getDeviceProfileInfo(DeviceProfileDTO deviceProfileDTO);
 }

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.AlarmContactDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * @Description 告警联系人的操作方法
+ * @Author cxy
+ * @Date 2021/11/2 14:46
+ */
+
+public interface YtAlarmContactService {
+    /**
+     * 查询全部的告警联系人
+     *
+     * @param
+     * @return List
+     */
+    List<AlarmContactDTO> findAll(String tenantId,Map<String,Object> params);
+
+    /**
+     * 添加告警联系人
+     *
+     * @param alarmContactDTO 对象
+     * @return AlarmContactDTO
+     */
+    AlarmContactDTO saveAlarmContact(String tenantId,AlarmContactDTO alarmContactDTO);
+
+    /**
+     * 删除告警联系人
+     *
+     * @param ids 通过列表id
+     * @return i
+     */
+    boolean delete(String[]ids);
+
+
+    /**
+     * 修改告警联系人数据
+     *
+     * @param alarmContactDTO 对象
+     * @return Integer
+     */
+    boolean update(AlarmContactDTO alarmContactDTO);
+
+    /**
+     * 分页查询
+     *
+     * @param queryMap 查询集合
+     * @return PageData
+     */
+    PageData<AlarmContactDTO> page(Map<String, Object> queryMap);
+
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.AlarmInfoDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+
+import java.util.Map;
+
+/** @Description 告警中心数据业务层 @Author cxy @Date 2021/11/10 16:51 */
+public interface YtAlarmInfoService {
+
+  /**
+   * 新增或修改告警中心数据
+   *
+   * @param alarmInfoDto 对象
+   * @return alarmInfoDto
+   */
+/*  AlarmInfoDTO insertOrUpdate(AlarmInfoDTO alarmInfoDto);*/
+
+  /**
+   * 删除告警中心数据
+   *
+   * @param ids id
+   * @return true和false
+   */
+  /*boolean deleteAlarm(Set<String> ids);*/
+
+  /**
+   * 分页数据
+   *
+   * @param queryMap 集合对象
+   * @return AlarmInfoDto
+   */
+  PageData<AlarmInfoDTO> page(Map<String, Object> queryMap);
+  /**
+   * 查询告警中心所有数据
+   *
+   * @param alarmInfoDto 过滤参数
+   * @return List<AlarmCenterDto>
+   */
+  /*List<AlarmInfoDTO> findAlarmInfo(AlarmInfoDTO alarmInfoDto);*/
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.AlarmProfileDTO;
+
+import java.util.Set;
+
+public interface YtAlarmProfileService {
+    /**
+     * 保存告警设置
+     * @param alarmProfileDTO 告警设置相关信息
+     * @return AlarmProfileDTO
+     */
+    AlarmProfileDTO saveOrUpdateAlarmProfile(String tenantId,AlarmProfileDTO alarmProfileDTO);
+
+    /**
+     * 删除告警配置
+     * @param ids 删除的ids
+     * @return 删除结果：true 成功 false 失败
+     */
+    boolean deleteAlarmProfile(Set<String> ids);
+
+    /**
+     * 根据设备配置ID查询告警配置信息
+     * @param deviceProfileId 设备配置ID
+     * @return 告警配置信息
+     */
+    AlarmProfileDTO findAlarmProfileByDeviceProfileId(String tenantId,String deviceProfileId);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.AlarmContactDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * @Description 告警联系人的操作方法
+ * @Author cxy
+ * @Date 2021/11/2 14:46
+ */
+
+public interface YtAlarmService {
+    /**
+     * 查询全部的告警联系人
+     *
+     * @param alarmContactDTO 对象
+     * @return List
+     */
+    List<AlarmContactDTO> findAll(String tenantId,AlarmContactDTO alarmContactDTO);
+
+    /**
+     * 添加告警联系人
+     *
+     * @param alarmContactDTO 对象
+     * @return AlarmContactDTO
+     */
+    AlarmContactDTO saveAlarmContact(String tenantId,AlarmContactDTO alarmContactDTO);
+
+    /**
+     * 删除告警联系人
+     *
+     * @param ids 通过列表id
+     * @return i
+     */
+    boolean delete(String[] ids);
+
+
+    /**
+     * 修改告警联系人数据
+     *
+     * @param alarmContactDTO 对象
+     * @return Integer
+     */
+    AlarmContactDTO update(boolean istenantAdmin,String tenantId,AlarmContactDTO alarmContactDTO);
+
+    /**
+     * 分页查询
+     *
+     * @param queryMap 查询集合
+     * @return PageData
+     */
+    PageData<AlarmContactDTO> page(Map<String, Object> queryMap);
+
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+public interface YtDeviceProfileService {
+  DeviceProfileDTO insertOrUpdate(String tenantId,DeviceProfileDTO deviceProfileDTO);
+
+  void deleteDeviceProfiles(String tenantId,Set<String> ids);
+
+  Optional<DeviceProfileDTO> getDeviceProfile(String tenantId,String id);
+
+  PageData<DeviceProfileDTO> page(String tenantId, Map<String, Object> queryMap);
+
+  List<DeviceProfileDTO> findDeviceProfile(String tenantId,DeviceProfileDTO deviceProfileDTO);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceTypeDTO;
+
+import java.util.List;
+
+public interface YtDeviceTypeService {
+    /**
+     * 获取当前租户设备类型的树形结构
+     * @param tenantId 租户Code
+     * @return 树形结构
+     */
+    List<DeviceTypeDTO> getDeviceTypeTree(String tenantId);
+
+    /**
+     * 保存设备类型
+     * @param deviceTypeDTO 设备类型参数
+     * @return 设备类型
+     */
+    DeviceTypeDTO saveDeviceTye(String tenantId,DeviceTypeDTO deviceTypeDTO);
+
+    /**
+     * 修改设备类型
+     * @param deviceTypeDTO 设备参数类型
+     * @return 设备类型
+     */
+    DeviceTypeDTO updateDeviceType(DeviceTypeDTO deviceTypeDTO);
+
+    /**
+     * 删除设备类型
+     * @param deleteDTO 删除设备IDS
+     * @return true or false 删除成功或失败
+     */
+    boolean deleteDeviceType(DeleteDTO deleteDTO);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.MailLogDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+
+import java.util.Map;
+import java.util.Set;
+
+public interface YtMailLogService {
+    PageData<MailLogDTO> page(String tenantId,Map<String, Object> queryMap);
+
+    boolean deleteMailLog(Set<String> ids);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.request.EmailReqDTO;
+
+public interface YtMailService {
+    boolean sendEmail(EmailReqDTO emailReqDTO);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.MessageConfigDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.PageData;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface YtMessageConfigService {
+
+  PageData<MessageConfigDTO> page(String tenantId,Map<String, Object> queryMap);
+
+  MessageConfigDTO saveMessageConfig(String tenantId,MessageConfigDTO configDTO);
+
+  boolean deleteMessageConfig(Set<String> ids);
+
+  MessageConfigDTO updateMessageConfig(String tenantId,MessageConfigDTO configDTO);
+
+  MessageConfigDTO getEnableConfigByMessageAndPlatform(
+      String messageType, String platform, String tenantCode);
+
+  MessageConfigDTO findMessageConfigById(String id);
+
+  List<MessageConfigDTO> findMessageInfo(MessageConfigDTO configDTO);
+}

@@ -9,7 +9,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-public interface MessageTemplateService {
+public interface YtMessageTemplateService {
 
   PageData<MessageTemplateDTO> page(Map<String, Object> queryMap);
 

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.AlarmInfoDTO;
+
+/**
+ * @version V1.0
+ * @Description :
+ * 1.其它地方抛出异常，交由控制层统一处理
+ * 2.服务层注意持久化的事务管理
+ * @Dependency: 依赖包
+ * @Author: junlianglee
+ * @Date Created in 2021/11/23$
+ * @Copyright 2016-2018  - Powered By 云腾五洲
+ */
+public interface YtNoticeService {
+
+    /**
+     * 设备告警通知负责人
+     *      * @param alarmInfo
+     * @param token      告警通知鉴权信息
+     * @param alarmInfo  告警数据
+     */
+    public void alert(String token, AlarmInfoDTO alarmInfo);
+
+}

@@ -8,7 +8,7 @@ import org.thingsboard.server.common.data.yunteng.dto.OrganizationDTO;
 import java.util.List;
 import java.util.Set;
 
-public interface OrganizationService {
+public interface YtOrganizationService {
   OrganizationDTO saveOrganization(OrganizationDTO organizationDTO);
 
   boolean deleteOrganizations(DeleteDTO deleteDTO);