优化代码

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/controller/PermissionController.java

 
 import com.tuoheng.admin.dto.GetPermissionRoleIdListByApiUrlDto;
 import com.tuoheng.admin.entity.OpPermissions;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.query.RoleClientQuery;
 import com.tuoheng.admin.service.permissions.OpPermissionsService;
-import com.tuoheng.common.core.common.BaseController;
 import com.tuoheng.common.core.utils.JsonResult;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
      */
     @DeleteMapping("/delete/{id}")
     public JsonResult delete(@PathVariable("id") Integer id) {
-        boolean flag = permissionService.update().eq("id",id).set("mark", 0).update();
+        boolean flag = permissionService.update().eq("id",id).set("mark", MarkEnum.NOTVALID.getCode()).update();
         if (flag) {
             return JsonResult.success();
         } else {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/enums/MarkTypeEnum.java → tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/enums/MarkEnum.java

  * 逻辑删除标记类型
  * @author chenyukun
  */
-public enum MarkTypeEnum {
 
+public enum MarkEnum {
     VALID(1,"有效"),
+
     NOTVALID(0,"失效");
 
-    MarkTypeEnum(int code, String description){
+    MarkEnum(int code, String description){
         this.code = code;
         this.description = description;
     }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/business/BusinessServiceImpl.java

 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.Business;
 import com.tuoheng.admin.entity.Inspection;
-import com.tuoheng.admin.enums.MarkTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.mapper.BusinessMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
 import com.tuoheng.admin.utils.CurrentUserUtil;
         business.setUpdateUser(CurrentUserUtil.getUserId());
         business.setUpdateTime(DateUtils.now());
         business.setTenantId(CurrentUserUtil.getTenantId());
-        business.setMark(MarkTypeEnum.VALID.getCode());
+        business.setMark(MarkEnum.VALID.getCode());
         log.info("thbusiness：{}", JacksonUtil.obj2StringPretty(business));
         // 查询任务是否存在
         int result = businessMapper.selectCount(new LambdaQueryWrapper<Business>()
                 .eq(Business::getMsgId, msgId)
                 .eq(Business::getTenantId, CurrentUserUtil.getTenantId())
-                .eq(Business::getMark, MarkTypeEnum.VALID.getCode()));
+                .eq(Business::getMark, MarkEnum.VALID.getCode()));
         if(result > 0){
             log.info("更新");
             businessMapper.update(business, new LambdaQueryWrapper<Business>()
                     .eq(Business::getMsgId, msgId)
                     .eq(Business::getTenantId, CurrentUserUtil.getTenantId())
-                    .eq(Business::getMark, MarkTypeEnum.VALID.getCode()));
+                    .eq(Business::getMark, MarkEnum.VALID.getCode()));
         } else {
             log.info("插入");
             businessMapper.insert(business);
         business.setUpdateUser(inspection.getUpdateUser());
         business.setUpdateTime(DateUtils.now());
         business.setTenantId(inspection.getTenantId());
-        business.setMark(MarkTypeEnum.VALID.getCode());
+        business.setMark(MarkEnum.VALID.getCode());
         log.info("thbusiness：{}", JacksonUtil.obj2StringPretty(business));
 
         // 查询任务是否存在
         int result = businessMapper.selectCount(new LambdaQueryWrapper<Business>()
                 .eq(Business::getMsgId, msgId)
                 .eq(Business::getTenantId, inspection.getTenantId())
-                .eq(Business::getMark, MarkTypeEnum.VALID.getCode()));
+                .eq(Business::getMark, MarkEnum.VALID.getCode()));
         if(result > 0){
             log.info("更新");
             businessMapper.update(business, new LambdaQueryWrapper<Business>()
                     .eq(Business::getMsgId, msgId)
                     .eq(Business::getTenantId, inspection.getTenantId())
-                    .eq(Business::getMark, MarkTypeEnum.VALID.getCode()));
+                    .eq(Business::getMark, MarkEnum.VALID.getCode()));
         } else {
             log.info("插入");
             businessMapper.insert(business);

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/dept/add/AddDeptService.java

 import com.tuoheng.admin.constant.SystemConstant;
 import com.tuoheng.admin.dto.RoadSectionDto;
 import com.tuoheng.admin.entity.*;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.dept.AddDeptCodeEnum;
 import com.tuoheng.admin.mapper.DeptMapper;
 import com.tuoheng.admin.mapper.RoadDeptMapper;
             Integer count = deptMapper.selectCount(new LambdaQueryWrapper<Dept>()
                     .eq(Dept::getTenantId, tenantId)
                     .eq(Dept::getPid, addDeptRequest.getPid())
-                    .eq(Dept::getMark, 1));
+                    .eq(Dept::getMark, MarkEnum.VALID.getCode()));
 
             // 顶级部门只能创建一个
             if (count > 0) {
             Integer count = deptMapper.selectCount(new LambdaQueryWrapper<Dept>()
                     .eq(Dept::getTenantId, tenantId)
                     .eq(Dept::getId, addDeptRequest.getPid())
-                    .eq(Dept::getMark, 1));
+                    .eq(Dept::getMark, MarkEnum.VALID.getCode()));
             if (count <= 0) {
                 return JsonResult.error(AddDeptCodeEnum.PARENT_DEPT_IS_NOT_EXIST.getCode(), AddDeptCodeEnum.PARENT_DEPT_IS_NOT_EXIST.getMsg());
             }
                     .eq(Dept::getTenantId, tenantId)
                     .eq(Dept::getPid, addDeptRequest.getPid())
                     .eq(Dept::getName, addDeptRequest.getName())
-                    .eq(Dept::getMark, 1));
+                    .eq(Dept::getMark, MarkEnum.VALID.getCode()));
 
             // 系统中已存在
             if (count > 0) {
         List<User> userList = userMapper.selectList(new LambdaQueryWrapper<User>()
                 .eq(User::getTenantId, tenantId)
                 .eq(User::getRoleId, 1)
-                .eq(User::getMark, 1));
+                .eq(User::getMark, MarkEnum.VALID.getCode()));
         if (CollectionUtils.isEmpty(userList)) {
             log.info("用户为空");
             return;

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/dept/delete/DeleteDeptService.java

 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.*;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.dept.DeleteDeptCodeEnum;
 import com.tuoheng.admin.mapper.DeptMapper;
 import com.tuoheng.admin.mapper.RoadDeptMapper;
         Dept dept = deptMapper.selectOne(new LambdaQueryWrapper<Dept>()
                 .eq(Dept::getTenantId, tenantId)
                 .eq(Dept::getId, id)
-                .eq(Dept::getMark, 1));
+                .eq(Dept::getMark, MarkEnum.VALID.getCode()));
         if (null == dept) {
             return JsonResult.error(DeleteDeptCodeEnum.DEPT_IS_NOT_EXIST.getCode(), DeleteDeptCodeEnum.DEPT_IS_NOT_EXIST.getMsg());
         }
         Integer count = userMapper.selectCount(new LambdaQueryWrapper<User>()
                 .eq(User::getTenantId, tenantId)
                 .eq(User::getDeptId, id)
-                .eq(User::getMark, 1));
+                .eq(User::getMark, MarkEnum.VALID.getCode()));
         if (count > 0) {
             return JsonResult.error(DeleteDeptCodeEnum.DEPT_IEXIST_USER.getCode(), DeleteDeptCodeEnum.DEPT_IEXIST_USER.getMsg());
         }
         count = deptMapper.selectCount(new LambdaQueryWrapper<Dept>()
                 .eq(Dept::getTenantId, tenantId)
                 .eq(Dept::getPid, id)
-                .eq(Dept::getMark, 1));
+                .eq(Dept::getMark, MarkEnum.VALID.getCode()));
         if (count > 0) {
             return JsonResult.error(DeleteDeptCodeEnum.DEPT_IEXIST_CHILDREN_DEPT.getCode(), DeleteDeptCodeEnum.DEPT_IEXIST_CHILDREN_DEPT.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/dept/query/QueryChildListService.java

 import cn.hutool.core.collection.CollectionUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.Dept;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.dept.QueryDeptChildListCodeEnum;
 import com.tuoheng.admin.mapper.DeptMapper;
 import com.tuoheng.admin.utils.CurrentUserUtil;
         Integer count = deptMapper.selectCount(new LambdaQueryWrapper<Dept>()
                 .eq(Dept::getTenantId, tenantId)
                 .eq(Dept::getId, id)
-                .eq(Dept::getMark, 1));
+                .eq(Dept::getMark, MarkEnum.VALID.getCode()));
         if (count <= 0) {
             return JsonResult.error(QueryDeptChildListCodeEnum.DEPT_IS_NOT_EXIST.getCode(), QueryDeptChildListCodeEnum.DEPT_IS_NOT_EXIST.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/add/AddInspectionService.java

 import com.tuoheng.admin.entity.*;
 import com.tuoheng.admin.enums.InspectionStatusEnum;
 import com.tuoheng.admin.enums.InspectionTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.AddInspectionCodeEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.admin.request.inspection.AddInspectionRequest;
         Integer roadCount = roadInformationMapper.selectCount(Wrappers.<RoadInformation>lambdaQuery()
                 .eq(RoadInformation::getTenantId, tenantId)
                 .eq(RoadInformation::getId, addInspectionRequest.getRoadId())
-                .eq(RoadInformation::getMark, 1));
+                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode()));
 
         if (roadCount <= 0) {
             return JsonResult.error(AddInspectionCodeEnum.ROAD_IS_NOT_EXIST.getCode(), AddInspectionCodeEnum.ROAD_IS_NOT_EXIST.getMsg());
         Integer sectionCount = sectionMapper.selectCount(Wrappers.<Section>lambdaQuery()
                 .eq(Section::getTenantId, tenantId)
                 .eq(Section::getId, addInspectionRequest.getSectionId())
-                .eq(Section::getMark, 1));
+                .eq(Section::getMark, MarkEnum.VALID.getCode()));
         if (sectionCount <= 0) {
             return JsonResult.error(AddInspectionCodeEnum.SECTION_IS_NOT_EXIST.getCode(), AddInspectionCodeEnum.SECTION_IS_NOT_EXIST.getMsg());
         }
         User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                 .eq(User::getTenantId, tenantId)
                 .eq(User::getId, userId)
-                .eq(User::getMark, 1));
+                .eq(User::getMark, MarkEnum.VALID.getCode()));
         if (null == user) {
             return JsonResult.error(AddInspectionCodeEnum.USER_IS_NOT_EXIST.getCode(), AddInspectionCodeEnum.USER_IS_NOT_EXIST.getMsg());
         }
         Dept dept = deptMapper.selectOne(new LambdaQueryWrapper<Dept>()
                 .eq(Dept::getTenantId, tenantId)
                 .eq(Dept::getId, user.getDeptId())
-                .eq(Dept::getMark, 1));
+                .eq(Dept::getMark, MarkEnum.VALID.getCode()));
         if (null == dept) {
             return JsonResult.error(AddInspectionCodeEnum.DEPT_IS_NOT_EXIST.getCode(), AddInspectionCodeEnum.DEPT_IS_NOT_EXIST.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/query/QueryInspectionByIdService.java

 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.Inspection;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.QueryInspectionInfoByIdCodeEnum;
 import com.tuoheng.admin.mapper.InspectionHistoryMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
         Inspection inspection = inspectionMapper.selectOne(new LambdaQueryWrapper<Inspection>()
                                     .eq(Inspection::getTenantId, tenantId)
                                     .eq(Inspection::getId, id)
-                                    .eq(Inspection::getMark, 1));
+                                    .eq(Inspection::getMark, MarkEnum.VALID.getCode()));
         if (null == inspection) {
             return JsonResult.error(QueryInspectionInfoByIdCodeEnum.INSPECTION_IS_NOT_EXIST.getCode(), QueryInspectionInfoByIdCodeEnum.INSPECTION_IS_NOT_EXIST.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/query/QueryInspectionDetailsByIdService.java

 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.entity.InspectionHistory;
 import com.tuoheng.admin.enums.InspectionStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.QueryInspectionDetailsByIdCodeEnum;
 import com.tuoheng.admin.mapper.InspectionHistoryMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
         Inspection inspection = inspectionMapper.selectOne(new LambdaQueryWrapper<Inspection>()
                 .eq(Inspection::getTenantId, tenantId)
                 .eq(Inspection::getId, id)
-                .eq(Inspection::getMark, 1));
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode()));
 
         if (null == inspection) {
             return JsonResult.error(QueryInspectionDetailsByIdCodeEnum.INSPECTION_IS_NOT_EXIST.getCode(), QueryInspectionDetailsByIdCodeEnum.INSPECTION_IS_NOT_EXIST.getMsg());
     private List<InspectionHistory> getInspectionHistoryList(String id) {
         List<InspectionHistory> inspectionHistoryList = inspectionHistoryMapper.selectList(new LambdaQueryWrapper<InspectionHistory>()
                 .eq(InspectionHistory::getInspectionId, id)
-                .eq(InspectionHistory::getMark, 1));
+                .eq(InspectionHistory::getMark, MarkEnum.VALID.getCode()));
         return inspectionHistoryList;
     }
 

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/query/QueryInspectionListService.java

 import com.tuoheng.admin.dto.InspectionDto;
 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.entity.User;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.QueryInspectionListServiceEnum;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
             return JsonResult.error(QueryInspectionListServiceEnum.QUERY_IS_FAILED.getCode(),QueryInspectionListServiceEnum.QUERY_IS_FAILED.getMsg());
         }
         User user = userMapper.selectOne(Wrappers.<User>lambdaQuery()
-                .eq(User::getMark, 1).eq(User::getStatus,1)
+                .eq(User::getMark, MarkEnum.VALID.getCode()).eq(User::getStatus,1)
                 .eq(User::getUsername,username));
 
         if(ObjectUtil.isNull(user)){
             return JsonResult.error(QueryInspectionListServiceEnum.DEPT_ID_IS_NULL.getCode(),QueryInspectionListServiceEnum.DEPT_ID_IS_NULL.getMsg());
         }
         List<Inspection> inspections = inspectionMapper.selectList(new LambdaQueryWrapper<Inspection>()
-                .eq(Inspection::getMark, 1)
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode())
                 .eq(Inspection::getTenantId, CurrentUserUtil.getTenantId())
                 .eq(Inspection::getDeptId, deptId)
                 .eq(Inspection::getAirportId, dto.getAirportId())

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/query/QueryNewInspectionListService.java

 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.entity.User;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.RoleEnum;
 import com.tuoheng.admin.enums.code.inspection.QueryInspectionListServiceEnum;
 import com.tuoheng.admin.enums.code.inspectionfile.ListByDeptUserTypeEnum;
         if (RoleEnum.SUPER_ADMIN.getCode() == user.getRoleId()) {
             List<Inspection> inspectionList = inspectionMapper.selectList(Wrappers.<Inspection>lambdaQuery()
                     .eq(Inspection::getTenantId, tenantId)
-                    .eq(Inspection::getMark, 1)
+                    .eq(Inspection::getMark, MarkEnum.VALID.getCode())
                     .orderByDesc(Inspection::getCreateTime)
                     .last("limit 5"));
             if (CollectionUtil.isEmpty(inspectionList)) {
             List<Inspection> inspectionList = inspectionMapper.selectList(new LambdaQueryWrapper<Inspection>()
                     .eq(Inspection::getTenantId, tenantId)
                     .eq(Inspection::getDeptId, deptId)
-                    .eq(Inspection::getMark, 1)
+                    .eq(Inspection::getMark, MarkEnum.VALID.getCode())
                     .orderByDesc(Inspection::getCreateTime)
                     .last("limit 5"));
             if (CollectionUtil.isEmpty(inspectionList)) {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/query/handle/ProblemCountHandle.java

 import com.tuoheng.admin.entity.InspectionFile;
 import com.tuoheng.admin.entity.User;
 import com.tuoheng.admin.enums.InspectionFileStatusEnum;
-import com.tuoheng.admin.enums.InspectionStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
 import com.tuoheng.admin.vo.inspection.InspectionVo;
 import lombok.extern.slf4j.Slf4j;
 //        log.info("处理问题数字段");
         List<InspectionFile> inspectionFileList = inspectionFileMapper.selectList(new LambdaQueryWrapper<InspectionFile>()
                 .eq(InspectionFile::getInspectionId, inspectionVo.getId())
-                .eq(InspectionFile::getMark, 1));
+                .eq(InspectionFile::getMark, MarkEnum.VALID.getCode()));
         Integer confirmedProblemCount = 0;
         Integer discoverProblemCount = 0;
         if (CollectionUtil.isNotEmpty(inspectionFileList)) {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/resubmit/ResubmitInspectionService.java

 import com.tuoheng.admin.entity.*;
 import com.tuoheng.admin.enums.InspectionStatusEnum;
 import com.tuoheng.admin.enums.InspectionTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.ResubmitInspectionCodeEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.admin.request.inspection.EditInspectionRequest;
         Integer roadCount = roadInformationMapper.selectCount(Wrappers.<RoadInformation>lambdaQuery()
                                 .eq(RoadInformation::getTenantId, tenantId)
                                 .eq(RoadInformation::getId, request.getRoadId())
-                                .eq(RoadInformation::getMark, 1));
+                                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode()));
 
         if (roadCount <= 0) {
             return JsonResult.error(ResubmitInspectionCodeEnum.ROAD_IS_NOT_EXIST.getCode(), ResubmitInspectionCodeEnum.ROAD_IS_NOT_EXIST.getMsg());
         Integer sectionCount = sectionMapper.selectCount(Wrappers.<Section>lambdaQuery()
                                 .eq(Section::getTenantId, tenantId)
                                 .eq(Section::getId, request.getSectionId())
-                                .eq(Section::getMark, 1));
+                                .eq(Section::getMark, MarkEnum.VALID.getCode()));
         if (sectionCount <= 0) {
             return JsonResult.error(ResubmitInspectionCodeEnum.SECTION_IS_NOT_EXIST.getCode(), ResubmitInspectionCodeEnum.SECTION_IS_NOT_EXIST.getMsg());
         }
         Dept dept = deptMapper.selectOne(new LambdaQueryWrapper<Dept>()
                 .eq(Dept::getTenantId, tenantId)
                 .eq(Dept::getId, user.getDeptId())
-                .eq(Dept::getMark, 1));
+                .eq(Dept::getMark, MarkEnum.VALID.getCode()));
         if (null == dept) {
             return JsonResult.error(ResubmitInspectionCodeEnum.DEPT_IS_NOT_EXIST.getCode(), ResubmitInspectionCodeEnum.DEPT_IS_NOT_EXIST.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/update/status/UpdateExecuteTaskStatusService.java

 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.entity.InspectionHistory;
 import com.tuoheng.admin.enums.InspectionStatusEnum;
-import com.tuoheng.admin.enums.MarkTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.mapper.InspectionHistoryMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
 import com.tuoheng.admin.request.inspection.ExecuteTaskStatusRequest;
     private JsonResult check(ExecuteTaskStatusRequest executeTaskStatusRequest) {
         //查询出对应的巡检任务
         Inspection inspection = inspectionMapper.selectOne(new LambdaQueryWrapper<Inspection>()
-                .eq(Inspection::getMark, MarkTypeEnum.VALID.getCode())
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode())
                 .eq(Inspection::getId, executeTaskStatusRequest.getRequestId()));
         if (ObjectUtil.isEmpty(inspection)) {
             log.info("任务不存在, inspectionId:{}", executeTaskStatusRequest.getRequestId());

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/update/status/UpdateFlightStatusService.java

 
 import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.tuoheng.admin.entity.LiveChannel;
 import com.tuoheng.admin.entity.Report;
 import com.tuoheng.admin.enums.InspectionStatusEnum;
-import com.tuoheng.admin.enums.MarkTypeEnum;
-import com.tuoheng.admin.enums.TaskStatusEnum;
-import com.tuoheng.admin.enums.code.inspection.EditInspectionStatusCodeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.admin.request.inspection.MissionStatusRequest;
 import com.tuoheng.admin.service.third.dsp.IDspService;
 import com.tuoheng.common.core.utils.JsonResult;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 
 @Slf4j
         // 查验是否存在
         LiveChannel liveChannelQuery = liveChannelMapper.selectOne(new LambdaQueryWrapper<LiveChannel>()
                 .eq(LiveChannel::getInspectionId, inspection.getId())
-                .eq(LiveChannel::getMark, MarkTypeEnum.VALID.getCode()));
+                .eq(LiveChannel::getMark, MarkEnum.VALID.getCode()));
         if (liveChannelQuery == null) {
             // 添加通道使用记录
             liveChannel.setCreateTime(DateUtils.now());
     private void updateReport(Inspection inspection) {
         Report report = reportMapper.selectOne(Wrappers.<Report>lambdaQuery()
                 .eq(Report::getInspectionId, inspection.getId())
-                .eq(Report::getMark, 1));
+                .eq(Report::getMark, MarkEnum.VALID.getCode()));
         if (ObjectUtil.isNull(report)) {
             log.info("该任务还没有生成报告，不需要修改报告的完成时间和状态");
             return;

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/update/status/UpdateInspectionStatusService.java

 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.enums.AirPortTaskStatusEnum;
-import com.tuoheng.admin.enums.MarkTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.EditInspectionStatusCodeEnum;
 import com.tuoheng.admin.mapper.InspectionMapper;
 import com.tuoheng.admin.request.inspection.MissionStatusRequest;
     private JsonResult check(MissionStatusRequest missionStatusRequest) {
         //查询出对应的巡检任务
         Inspection inspection = inspectionMapper.selectOne(new LambdaQueryWrapper<Inspection>()
-                .eq(Inspection::getMark, MarkTypeEnum.VALID.getCode())
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode())
                 .eq(Inspection::getId, missionStatusRequest.getRequestId())
                 .eq(Inspection::getInspectionLine, missionStatusRequest.getId()));
         if (ObjectUtil.isEmpty(inspection)) {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/update/status/UpdateWaittStatusService.java

 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.tuoheng.admin.constant.SystemConstant;
 import com.tuoheng.admin.entity.*;
-import com.tuoheng.admin.enums.AiAnalyseStatusEnum;
-import com.tuoheng.admin.enums.MarkTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.TaskStatusEnum;
 import com.tuoheng.admin.enums.code.inspection.EditInspectionStatusCodeEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.common.core.utils.*;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
 
         List<Business> businessList = businessMapper.selectList(new LambdaQueryWrapper<Business>()
                                         .eq(Business::getTypeId, inspection.getId())
-                                        .eq(Business::getMark, MarkTypeEnum.VALID.getCode())
+                                        .eq(Business::getMark, MarkEnum.VALID.getCode())
                                         .orderByDesc(Business::getCreateTime));
 
         if (CollectionUtil.isEmpty(businessList)) {
         Integer flightDataCount = flightDataMapper.selectCount(new LambdaQueryWrapper<FlightData>()
                 .eq(FlightData::getInspectionId, inspection.getId())
                 .eq(FlightData::getTenantId, inspection.getTenantId())
-                .eq(FlightData::getMark, MarkTypeEnum.VALID.getCode()));
+                .eq(FlightData::getMark, MarkEnum.VALID.getCode()));
         log.info("坐标数据，flightDataCount:{}", flightDataCount);
         if (flightDataCount > 0) {
             int index = (int) Math.ceil((double) flightDataCount / 2);
             FlightData flightData = flightDataMapper.selectOne(new LambdaQueryWrapper<FlightData>()
                     .eq(FlightData::getInspectionId, inspection.getId())
                     .eq(FlightData::getTenantId, inspection.getTenantId())
-                    .eq(FlightData::getMark, MarkTypeEnum.VALID.getCode())
+                    .eq(FlightData::getMark, MarkEnum.VALID.getCode())
                     .orderByDesc(FlightData::getTimestamp)
                     .last("limit " + index + ",1"));
             if (ObjectUtil.isNotNull(flightData)) {
     private void updateReport(Inspection inspection) {
         Report report = reportMapper.selectOne(Wrappers.<Report>lambdaQuery()
                 .eq(Report::getInspectionId, inspection.getId())
-                .eq(Report::getMark, 1));
+                .eq(Report::getMark, MarkEnum.VALID.getCode()));
         if (ObjectUtil.isNull(report)) {
             log.info("该任务还没有生成报告，不需要修改报告的完成时间和状态");
             return;

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspection/upload/UploadFlightUrlService.java

 import com.tuoheng.admin.entity.InspectionFile;
 import com.tuoheng.admin.enums.AiAnalyseStatusEnum;
 import com.tuoheng.admin.enums.AiAnalyseTypeEnum;
-import com.tuoheng.admin.enums.MarkTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.TaskStatusEnum;
 import com.tuoheng.admin.mapper.FlightDataMapper;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
 import com.tuoheng.admin.service.flightdata.AsyncService;
 import com.tuoheng.admin.service.business.IBusinessService;
 import com.tuoheng.admin.service.third.dsp.IDspService;
-import com.tuoheng.admin.utils.CurrentUserUtil;
 import com.tuoheng.admin.utils.SrtDataUtil;
 import com.tuoheng.common.core.config.common.CommonConfig;
 import com.tuoheng.common.core.enums.HttpStatusEnum;
 import javax.annotation.Resource;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * 上传离线视频业务层处理
         }
         Inspection inspection = inspectionMapper.selectOne(new LambdaQueryWrapper<Inspection>()
                 .eq(Inspection::getCode, request.getTaskCode())
-                .eq(Inspection::getMark, MarkTypeEnum.VALID.getCode()));
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode()));
         if (ObjectUtils.isEmpty(inspection)) {
             log.info("巡检任务不存在！");
             throw new ServiceException(ServiceExceptionEnum.TASK_DOES_NOT_EXIST);
             flightDataMapper.delete(new LambdaQueryWrapper<FlightData>()
                     .eq(FlightData::getInspectionId, inspectionId)
                     .eq(FlightData::getTenantId, tenantId)
-                    .eq(FlightData::getMark, MarkTypeEnum.VALID.getCode()));
+                    .eq(FlightData::getMark, MarkEnum.VALID.getCode()));
             List<List> lists = this.splitList(flightDataList, 100);
             //线程池使用多线程插入数据
             for (List list : lists) {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspectionfile/confirm/InspectionFileConfirmService.java

 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.InspectionFile;
 import com.tuoheng.admin.enums.InspectionFileStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspectionfile.InspectionFileConfirmCodeEnum;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
         // 判断任务是否存在
         List<InspectionFile> inspectionFileList = inspectionFileMapper.selectList(new LambdaQueryWrapper<InspectionFile>()
                 .in(InspectionFile::getId, idList)
-                .eq(InspectionFile::getMark, 1));
+                .eq(InspectionFile::getMark, MarkEnum.VALID.getCode()));
 
         if (CollectionUtil.isEmpty(inspectionFileList)) {
             return JsonResult.error(InspectionFileConfirmCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getCode(), InspectionFileConfirmCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getMsg());

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspectionfile/handle/QueryInspectionFileHandleByInspectionFileIdService.java

 import com.tuoheng.admin.entity.InspectionFileHandle;
 import com.tuoheng.admin.entity.QuestionType;
 import com.tuoheng.admin.entity.User;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspectionfilehandle.QueryInspectionFileHandleByInspectionFileIdCodeEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.admin.vo.inspection.InspectionFileHandleVo;
 
         InspectionFileHandle inspectionFileHandle = inspectionFileHandleMapper.selectOne(new LambdaQueryWrapper<InspectionFileHandle>()
                 .eq(InspectionFileHandle::getInspectionFileId, id)
-                .eq(InspectionFileHandle::getMark, 1));
+                .eq(InspectionFileHandle::getMark, MarkEnum.VALID.getCode()));
 
         InspectionFileHandleVo inspectionFileHandleVo = this.buildInspectionFileHandleVo(inspectionFile, inspectionFileHandle);
 
         // 判断任务是否存在
         InspectionFile inspectionFile = inspectionFileMapper.selectOne(new LambdaQueryWrapper<InspectionFile>()
                 .eq(InspectionFile::getId, id)
-                .eq(InspectionFile::getMark, 1));
+                .eq(InspectionFile::getMark, MarkEnum.VALID.getCode()));
 
         if (null == inspectionFile) {
             return JsonResult.error(QueryInspectionFileHandleByInspectionFileIdCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getCode(), QueryInspectionFileHandleByInspectionFileIdCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getMsg());
         }
         QuestionType questionType = questionTypeMapper.selectOne(new LambdaQueryWrapper<QuestionType>()
                 .eq(QuestionType::getCode, inspectionFile.getQuestionCode())
-                .eq(QuestionType::getMark, 1));
+                .eq(QuestionType::getMark, MarkEnum.VALID.getCode()));
         if (null != questionType) {
             inspectionFileHandleVo.setQuestionName(questionType.getContent());
         }
         if (StringUtils.isNotEmpty(inspectionFileHandleVo.getHandlerUser())) {
             User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                     .eq(User::getId, inspectionFileHandleVo.getHandlerUser())
-                    .eq(User::getMark, 1));
+                    .eq(User::getMark, MarkEnum.VALID.getCode()));
             if (ObjectUtil.isNotNull(user)) {
                 inspectionFileHandleVo.setHandlerUsername(user.getRealname());
             }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspectionfile/ignore/InspectionFileIgnoreService.java

 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.InspectionFile;
 import com.tuoheng.admin.enums.InspectionFileStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspectionfile.InspectionFileIgnoreCodeEnum;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
 import com.tuoheng.admin.mapper.InspectionMapper;
         // 判断任务是否存在
         List<InspectionFile> inspectionFileList = inspectionFileMapper.selectList(new LambdaQueryWrapper<InspectionFile>()
                 .in(InspectionFile::getId, idList)
-                .eq(InspectionFile::getMark, 1));
+                .eq(InspectionFile::getMark, MarkEnum.VALID.getCode()));
 
         if (CollectionUtil.isEmpty(inspectionFileList)) {
             return JsonResult.error(InspectionFileIgnoreCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getCode(), InspectionFileIgnoreCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getMsg());

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspectionfile/processing/InspectionFileProcessingService.java

 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.*;
 import com.tuoheng.admin.enums.InspectionFileStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.WorkOrderStatusEnum;
 import com.tuoheng.admin.enums.code.inspectionfilehandle.InspectionFileProcessingCodeEnum;
 import com.tuoheng.admin.mapper.*;
         // 判断工单是否存在
         WorkOrder workOrder = workOrderMapper.selectOne(new LambdaQueryWrapper<WorkOrder>()
                                 .eq(WorkOrder::getId, request.getWorkOrderId())
-                                .eq(WorkOrder::getMark, 1));
+                                .eq(WorkOrder::getMark, MarkEnum.VALID.getCode()));
         if (null == workOrder) {
             return JsonResult.error(InspectionFileProcessingCodeEnum.WORK_ORDER_IS_NOT_EXIST.getCode(), InspectionFileProcessingCodeEnum.WORK_ORDER_IS_NOT_EXIST.getMsg());
         }
         // 判断任务问题是否存在
         InspectionFile inspectionFile = inspectionFileMapper.selectOne(new LambdaQueryWrapper<InspectionFile>()
                 .eq(InspectionFile::getId, request.getInspectionFileId())
-                .eq(InspectionFile::getMark, 1));
+                .eq(InspectionFile::getMark, MarkEnum.VALID.getCode()));
         if (null == inspectionFile) {
             log.info("任务问题不存在，inspectionFileId:{}", request.getInspectionFileId());
             return JsonResult.error(InspectionFileProcessingCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getCode(), InspectionFileProcessingCodeEnum.INSPECTION_FILE_IS_NOT_EXIST.getMsg());

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/inspectionfile/query/QueryInspectionFilePageListByInspectionIdService.java

 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.entity.InspectionFile;
 import com.tuoheng.admin.entity.QuestionType;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.inspection.QueryInspectionPageListCodeEnum;
 import com.tuoheng.admin.enums.code.inspectionfile.QueryInspectionFilePageListByInspectionIdCodeEnum;
 import com.tuoheng.admin.mapper.*;
         // 判断任务是否存在
         Inspection inspection = inspectionMapper.selectOne(new LambdaQueryWrapper<Inspection>()
                 .eq(Inspection::getId, request.getInspectionId())
-                .eq(Inspection::getMark, 1));
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode()));
 
         if (null == inspection) {
             return JsonResult.error(QueryInspectionFilePageListByInspectionIdCodeEnum.INSPECTION_IS_NOT_EXIST.getCode(), QueryInspectionFilePageListByInspectionIdCodeEnum.INSPECTION_IS_NOT_EXIST.getMsg());
      */
     private List<InspectionFilePageListByInspectionIdVo> buildInspectionFilePageListVoList(List<InspectionFile> inspectionFileList) {
         List<QuestionType> questionTypeList = questionTypeMapper.selectList(new LambdaQueryWrapper<QuestionType>()
-                .eq(QuestionType::getMark, 1));
+                .eq(QuestionType::getMark, MarkEnum.VALID.getCode()));
         List<InspectionFilePageListByInspectionIdVo> inspectionFilePageListVoList = InspectionFileConverMapper.INSTANCE.fromInspectionFileListToInspectionFilePageByInspectionIdListVoList(inspectionFileList);
         for (InspectionFilePageListByInspectionIdVo inspectionFilePageListVo : inspectionFilePageListVoList) {
 

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/questiontype/query/QueryQuestionTypeListService.java

 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.tuoheng.admin.entity.QuestionType;
 import com.tuoheng.admin.entity.Structure;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.mapper.QuestionTypeMapper;
 import com.tuoheng.common.core.utils.JsonResult;
 import lombok.extern.slf4j.Slf4j;
     public JsonResult getist() {
         log.info("进入查询问题类型列表业务");
         List<QuestionType> questionTypeList = questionTypeMapper.selectList(new LambdaQueryWrapper<QuestionType>()
-                .eq(QuestionType::getMark, 1));
+                .eq(QuestionType::getMark, MarkEnum.VALID.getCode()));
         return JsonResult.success(questionTypeList);
     }
 

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/report/export/ExportInspectionHandleReportService.java

 import com.tuoheng.admin.entity.Report;
 import com.tuoheng.admin.entity.Tenant;
 import com.tuoheng.admin.enums.InspectionFileStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.report.ExportInspectionHandleReportCodeEnum;
 import com.tuoheng.admin.mapper.InspectionFileHandleMapper;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
         }
         Report report = reportMapper.selectOne(Wrappers.<Report>lambdaQuery()
                 .eq(Report::getId, id)
-                .eq(Report::getMark, 1));
+                .eq(Report::getMark, MarkEnum.VALID.getCode()));
         if (null == report) {
             return JsonResult.error(ExportInspectionHandleReportCodeEnum.REPORT_IS_NOT_EXIST.getCode(), ExportInspectionHandleReportCodeEnum.REPORT_IS_NOT_EXIST.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/report/export/ExportInspectionReportService.java

 import com.tuoheng.admin.entity.Report;
 import com.tuoheng.admin.entity.Tenant;
 import com.tuoheng.admin.enums.InspectionFileStatusEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.report.ExportInspectionReportReportCodeEnum;
 import com.tuoheng.admin.mapper.InspectionFileHandleMapper;
 import com.tuoheng.admin.mapper.InspectionFileMapper;
         }
         Report report = reportMapper.selectOne(Wrappers.<Report>lambdaQuery()
                 .eq(Report::getId, id)
-                .eq(Report::getMark, 1));
+                .eq(Report::getMark, MarkEnum.VALID.getCode()));
         if (null == report) {
             return JsonResult.error(ExportInspectionReportReportCodeEnum.REPORT_IS_NOT_EXIST.getCode(), ExportInspectionReportReportCodeEnum.REPORT_IS_NOT_EXIST.getMsg());
         }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/road/RoadInformationServiceImpl.java

 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.tuoheng.admin.entity.*;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.RoleEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.admin.query.RoadInformationQuery;
         //获取分页数据
         IPage<RoadInformation> page = new Page<>(query.getPage(), query.getLimit());
         IPage<RoadInformation> pageData = roadInformationMapper.selectPage(page, Wrappers.<RoadInformation>lambdaQuery()
-                .eq(RoadInformation::getMark, 1)
+                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode())
                 .eq(RoadInformation::getTenantId, tenantId)
                 .orderByDesc(RoadInformation::getCreateTime));
         List<RoadInformation> records = pageData.getRecords();
         }
         //当前租户下所有公路信息
         List<RoadInformation> roadInformationList = roadInformationMapper.selectList(new LambdaQueryWrapper<RoadInformation>()
-                .eq(RoadInformation::getMark, 1)
+                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode())
                 .eq(RoadInformation::getTenantId, tenantId));
         List<RoadInformation> list = new ArrayList<>();
         for (RoadInformation roadInformation : roadInformationList) {
     private boolean getInformationListByCode(RoadInformation entity) {
         List<RoadInformation> roadInformationList = roadInformationMapper.selectList(new LambdaQueryWrapper<RoadInformation>()
                 .eq(RoadInformation::getTenantId, CurrentUserUtil.getTenantId())
-                .eq(RoadInformation::getMark, 1)
+                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode())
                 .eq(RoadInformation::getCode,entity.getCode()));
         if(CollectionUtil.isNotEmpty(roadInformationList)){
             for (RoadInformation roadInformation : roadInformationList) {
         Map<String, Object> map = new HashMap<>();
         map.put("tenantId", tenantId);
         map.put("roadIdList", roadIdList);
-        map.put("mark",1);
+        map.put("mark",MarkEnum.VALID.getCode());
         roadInformationList = roadInformationMapper.getListByMap(map);
         return roadInformationList;
     }
     private List<RoadInformation> getAllRoadInformationList(String tenantId) {
         List<RoadInformation> roadInformationList = roadInformationMapper.selectList(new LambdaQueryWrapper<RoadInformation>()
                 .eq(RoadInformation::getTenantId, tenantId)
-                .eq(RoadInformation::getMark, 1));
+                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode()));
         if (CollectionUtil.isEmpty(roadInformationList)) {
             return null;
         }
      */
     private void RoadRelation(RoadInformation roadInformation) {
         List<Section> sectionList = sectionMapper.selectList(new LambdaQueryWrapper<Section>()
-                .eq(Section::getMark, 1)
+                .eq(Section::getMark, MarkEnum.VALID.getCode())
                 .eq(Section::getTenantId, CurrentUserUtil.getTenantId())
                 .eq(Section::getRoadId, roadInformation.getId()));
         if (StringUtils.isNotEmpty(sectionList)) {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/road/query/QueryRoadListByDeptIdService.java

 import com.tuoheng.admin.entity.Dept;
 import com.tuoheng.admin.entity.RoadDept;
 import com.tuoheng.admin.entity.RoadInformation;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.road.QueryRoadListByDeptIdCodeEnum;
 import com.tuoheng.admin.mapper.DeptMapper;
 import com.tuoheng.admin.mapper.RoadDeptMapper;
         Dept dept = deptMapper.selectOne(new LambdaQueryWrapper<Dept>()
                 .eq(Dept::getTenantId, tenantId)
                 .eq(Dept::getId, id)
-                .eq(Dept::getMark, 1));
+                .eq(Dept::getMark, MarkEnum.VALID.getCode()));
         if (null == dept) {
             return JsonResult.error(QueryRoadListByDeptIdCodeEnum.DEPT_IS_NOT_EXIST.getCode(), QueryRoadListByDeptIdCodeEnum.DEPT_IS_NOT_EXIST.getMsg());
         }
     private List<RoadInformation> getAllRoadInformationList(String tenantId) {
         List<RoadInformation> roadList = roadInformationMapper.selectList(new LambdaQueryWrapper<RoadInformation>()
                 .eq(RoadInformation::getTenantId, tenantId)
-                .eq(RoadInformation::getMark, 1));
+                .eq(RoadInformation::getMark, MarkEnum.VALID.getCode()));
         if (CollectionUtil.isEmpty(roadList)) {
             return null;
         }
         Map<String, Object> map = new HashMap<>();
         map.put("tenantId", tenantId);
         map.put("roadIdList", roadIdList);
-        map.put("mark",1);
+        map.put("mark",MarkEnum.VALID.getCode());
         List<RoadInformation> roadInformationList = roadInformationMapper.getListByMap(map);
         return roadInformationList;
     }

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/service/role/RoleServiceImpl.java

 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.tuoheng.admin.dto.*;
 import com.tuoheng.admin.entity.*;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.enums.code.role.RoleDeleteEnum;
 import com.tuoheng.admin.mapper.*;
 import com.tuoheng.admin.query.RoleClientQuery;
         if (!StringUtils.isEmpty(roleQuery.getRoleName())) {
             queryWrapper.like("role_name", roleQuery.getRoleName());
         }
-        queryWrapper.eq("mark", 1);
+        queryWrapper.eq("mark", MarkEnum.VALID.getCode());
         //queryWrapper.orderByAsc("sort");
         queryWrapper.orderByAsc("create_time");
         queryWrapper.ne("id", "1");
                     .ne(Role::getId, entity.getId())
                     .eq(Role::getTenantId, CurrentUserUtil.getTenantId())
                     .eq(Role::getCode, entity.getCode())
-                    .eq(Role::getMark, 1));
+                    .eq(Role::getMark, MarkEnum.VALID.getCode()));
             //当前用户
             entity.setUpdateUser(CurrentUserUtil.getUserId());
             entity.setUpdateTime(DateUtils.now());
             Integer count = roleMapper.selectCount(new LambdaQueryWrapper<Role>()
                     .eq(Role::getTenantId, CurrentUserUtil.getTenantId())
                     .eq(Role::getCode, entity.getCode())
-                    .eq(Role::getMark, 1));
+                    .eq(Role::getMark, MarkEnum.VALID.getCode()));
             if (count > 0) {
                 return JsonResult.error("系统中已存在相同的角色编码");
             }
         //根据roleId查询是否关联的有用户
         for (Integer roleId : roleIds) {
             List<User> userList = userMapper.selectList(Wrappers.<User>lambdaQuery()
-                    .eq(User::getMark, 1).eq(User::getRoleId, roleId));
+                    .eq(User::getMark, MarkEnum.VALID.getCode()).eq(User::getRoleId, roleId));
             if(userList.size()>0 && StringUtils.isNotEmpty(userList)){
                 return JsonResult.error("该角色已经绑定用户,不能删除");
             }
             Role role = roleMapper.selectById(roleId);
-            role.setMark(0);
+            role.setMark(MarkEnum.NOTVALID.getCode());
             int result = roleMapper.updateById(role);
             if(result<=0){
                 return JsonResult.error();
         queryWrapper.ne("code", "001");
 //        queryWrapper.eq("tenant_id", CurrentUserUtil.getTenantId());
         queryWrapper.eq("status", 1);
-        queryWrapper.eq("mark", 1);
+        queryWrapper.eq("mark", MarkEnum.VALID.getCode());
         queryWrapper.orderByAsc("create_time");
         List<Role> rolesLists = roleMapper.selectList(queryWrapper);
 
         RoleMenuPermissionDto dto = new RoleMenuPermissionDto();
         Integer roleId = query.getRoleId();
         List<Menu> menuList = menuMapper.selectList(Wrappers.<Menu>lambdaQuery()
-                .eq(Menu::getMark, 1)
+                .eq(Menu::getMark, MarkEnum.VALID.getCode())
                 .eq(Menu::getStatus, 1)
                 .eq(StringUtils.isNotEmpty(query.getClientId()), Menu::getClientId, query.getClientId())
                 .orderByAsc(Menu::getSort));
         dto.setOpMenusList(collect);
         //根基小程序或者pc标识
         List<OpPermissions> permissions = opPermissionsMapper.selectList(Wrappers.<OpPermissions>lambdaQuery()
-                .eq(OpPermissions::getMark, 1)
+                .eq(OpPermissions::getMark, MarkEnum.VALID.getCode())
                 .eq(StringUtils.isNotEmpty(query.getClientId()), OpPermissions::getClientId, query.getClientId()));
         if(!permissions.isEmpty()){
             //获取角色菜单列表
         for (Integer id : ids) {
             //批量初始化租户对应角色配置
             List<Role> roles = roleMapper.selectList(Wrappers.<Role>lambdaQuery()
-                    .eq(Role::getMark, 1).eq(Role::getStatus, 1)
+                    .eq(Role::getMark, MarkEnum.VALID.getCode()).eq(Role::getStatus, 1)
                     .eq(Role::getTenantId, 1)
                     .ne(Role::getCode, "super"));
             for (Role role : roles) {

tuoheng-service/tuoheng-admin/src/main/java/com/tuoheng/admin/task/AirportTask.java

 import com.tuoheng.admin.entity.Inspection;
 import com.tuoheng.admin.enums.InspectionStatusEnum;
 import com.tuoheng.admin.enums.InspectionTypeEnum;
-import com.tuoheng.admin.enums.MarkTypeEnum;
+import com.tuoheng.admin.enums.MarkEnum;
 import com.tuoheng.admin.mapper.InspectionMapper;
 import com.tuoheng.admin.service.third.airport.AirportService;
 import com.tuoheng.common.core.utils.StringUtils;
 
         log.info("执行定时执行飞行任务：" + LocalDateTime.now());
         List<Inspection> inspectionList = inspectionMapper.selectList(new LambdaQueryWrapper<Inspection>()
-                .eq(Inspection::getMark, MarkTypeEnum.VALID.getCode())
+                .eq(Inspection::getMark, MarkEnum.VALID.getCode())
                 .between(Inspection::getInspectionTime, startTime, endTime)
                 //查询巡检方式为机场的任务
                 .eq(Inspection::getInspectionType, InspectionTypeEnum.AIRPORT.getCode())

tuoheng-service/tuoheng-miniprogram/src/main/java/com/tuoheng/miniprogram/enums/MarkEnum.java

+package com.tuoheng.miniprogram.enums;
+
+import lombok.Getter;
+
+/**
+ * 逻辑删除标记类型
+ * @author chenyukun
+ */
+public enum MarkEnum {
+    VALID(1,"有效"),
+
+    NOTVALID(0,"失效");
+
+    MarkEnum(int code, String description){
+        this.code = code;
+        this.description = description;
+    }
+
+    @Getter
+    private int code;
+
+    @Getter
+    private String description;
+}

tuoheng-service/tuoheng-miniprogram/src/main/java/com/tuoheng/miniprogram/service/impl/InspectionFileHandleServiceImpl.java

 import com.tuoheng.miniprogram.entity.*;
 import com.tuoheng.miniprogram.entity.dto.UploadResultDto;
 import com.tuoheng.miniprogram.enums.InspectionFileHandleEnum;
+import com.tuoheng.miniprogram.enums.MarkEnum;
 import com.tuoheng.miniprogram.enums.ServiceExceptionEnum;
 import com.tuoheng.miniprogram.service.IInspectionFileHandleService;
 import com.tuoheng.miniprogram.utils.CurrentUserUtil;
             return JsonResult.error(InspectionFileHandleEnum.USER_NAME_IS_NULL.getCode(),InspectionFileHandleEnum.USER_NAME_IS_NULL.getMsg());
         }
         User user = userMapper.selectOne(Wrappers.<User>lambdaQuery()
-                .eq(User::getMark, 1)
+                .eq(User::getMark, MarkEnum.VALID.getCode())
                 .eq(User::getUsername, username));
         if(ObjectUtil.isNull(user)){
             return JsonResult.error(InspectionFileHandleEnum.USER_IS_NOT_EXIST.getCode(),InspectionFileHandleEnum.USER_IS_NOT_EXIST.getMsg());