qdintc/fishery-back
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat:功能优化，设备报警信息、微信缓存用户，操作记录信息，代码提交。

Browse Source
This commit is contained in:
tianyongbao
2025-10-24 20:44:36 +08:00
parent d135c85ec0
commit a9187da813
35 changed files with 2391 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
intc-admin/Dockerfile
View File

@@ -5,11 +5,11 @@ FROM bellsoft/liberica-openjdk-rocky:17.0.16-cds
LABEL maintainer="Lion Li"
RUN mkdir -p /ruoyi/server/logs \
/ruoyi/server/temp \
/ruoyi/skywalking/agent
RUN mkdir -p /intc/server/logs \
/intc/server/temp \
/intc/skywalking/agent
WORKDIR /ruoyi/server
WORKDIR /intc/server
ENV SERVER_PORT=8080 SNAIL_PORT=28080 LANG=C.UTF-8 LC_ALL=C.UTF-8 JAVA_OPTS=""
@@ -17,7 +17,7 @@ EXPOSE ${SERVER_PORT}
# 暴露 snail job 客户端端口 用于定时任务调度中心通信
EXPOSE ${SNAIL_PORT}
ADD ./target/ruoyi-admin.jar ./app.jar
ADD ./target/intc-admin.jar ./app.jar
SHELL ["/bin/bash", "-c"]

2
intc-admin/src/main/java/com/intc/IntcUltraApplication.java
View File

@@ -17,7 +17,7 @@ public class IntcUltraApplication {
SpringApplication application = new SpringApplication(IntcUltraApplication.class);
application.setApplicationStartup(new BufferingApplicationStartup(2048));
application.run(args);
System.out.println("(♥◠‿◠)ﾉﾞ Intc-Vue-Plus启动成功 ლ(´ڡ`ლ)ﾞ");
System.out.println("(♥◠‿◠)ﾉﾞ Intc-Vue-Ultra启动成功 ლ(´ڡ`ლ)ﾞ");
}
}

104
intc-modules/intc-fishery/src/main/java/com/intc/fishery/controller/DeviceWarnCombineController.java Normal file
View File

@@ -0,0 +1,104 @@
package com.intc.fishery.controller;
import java.util.List;
import com.intc.common.excel.utils.ExcelUtil;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.intc.common.idempotent.annotation.RepeatSubmit;
import com.intc.common.log.annotation.Log;
import com.intc.common.web.core.BaseController;
import com.intc.common.mybatis.core.page.PageQuery;
import com.intc.common.core.domain.R;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.common.log.enums.BusinessType;
import com.intc.fishery.domain.vo.DeviceWarnCombineVo;
import com.intc.fishery.domain.bo.DeviceWarnCombineBo;
import com.intc.fishery.service.IDeviceWarnCombineService;
import com.intc.common.mybatis.core.page.TableDataInfo;
/**
* 设备告警信息
*
* @author intc
* @date 2025-10-23
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/fishery/deviceWarnCombine")
public class DeviceWarnCombineController extends BaseController {
private final IDeviceWarnCombineService deviceWarnCombineService;
/**
* 查询设备告警信息列表
*/
@SaCheckPermission("fishery:deviceWarnCombine:list")
@GetMapping("/list")
public TableDataInfo<DeviceWarnCombineVo> list(DeviceWarnCombineBo bo, PageQuery pageQuery) {
return deviceWarnCombineService.queryPageList(bo, pageQuery);
}
/**
* 导出设备告警信息列表
*/
@SaCheckPermission("fishery:deviceWarnCombine:export")
@Log(title = "设备告警信息", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DeviceWarnCombineBo bo, HttpServletResponse response) {
List<DeviceWarnCombineVo> list = deviceWarnCombineService.queryList(bo);
ExcelUtil.exportExcel(list, "设备告警信息", DeviceWarnCombineVo.class, response);
}
/**
* 获取设备告警信息详细信息
*
* @param id 主键
*/
@SaCheckPermission("fishery:deviceWarnCombine:query")
@GetMapping("/{id}")
public R<DeviceWarnCombineVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(deviceWarnCombineService.queryById(id));
}
/**
* 新增设备告警信息
*/
@SaCheckPermission("fishery:deviceWarnCombine:add")
@Log(title = "设备告警信息", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DeviceWarnCombineBo bo) {
return toAjax(deviceWarnCombineService.insertByBo(bo));
}
/**
* 修改设备告警信息
*/
@SaCheckPermission("fishery:deviceWarnCombine:edit")
@Log(title = "设备告警信息", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DeviceWarnCombineBo bo) {
return toAjax(deviceWarnCombineService.updateByBo(bo));
}
/**
* 删除设备告警信息
*
* @param ids 主键串
*/
@SaCheckPermission("fishery:deviceWarnCombine:remove")
@Log(title = "设备告警信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(deviceWarnCombineService.deleteWithValidByIds(List.of(ids), true));
}
}

106
intc-modules/intc-fishery/src/main/java/com/intc/fishery/controller/DeviceWarnOneController.java Normal file
View File

@@ -0,0 +1,106 @@
package com.intc.fishery.controller;
import java.util.List;
import com.intc.common.excel.utils.ExcelUtil;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.intc.common.idempotent.annotation.RepeatSubmit;
import com.intc.common.log.annotation.Log;
import com.intc.common.web.core.BaseController;
import com.intc.common.mybatis.core.page.PageQuery;
import com.intc.common.core.domain.R;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.common.log.enums.BusinessType;
import com.intc.fishery.domain.vo.DeviceWarnOneVo;
import com.intc.fishery.domain.bo.DeviceWarnOneBo;
import com.intc.fishery.domain.bo.DeviceWarnOneBatchUpdateBo;
import com.intc.fishery.service.IDeviceWarnOneService;
import com.intc.common.mybatis.core.page.TableDataInfo;
/**
* 设备报警明细
*
* @author intc
* @date 2025-10-23
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/fishery/deviceWarnOne")
public class DeviceWarnOneController extends BaseController {
private final IDeviceWarnOneService deviceWarnOneService;
/**
* 查询设备报警明细列表
*/
@SaCheckPermission("fishery:deviceWarnOne:list")
@GetMapping("/list")
public TableDataInfo<DeviceWarnOneVo> list(DeviceWarnOneBo bo, PageQuery pageQuery) {
return deviceWarnOneService.queryPageList(bo, pageQuery);
}
/**
* 导出设备报警明细列表
*/
@SaCheckPermission("fishery:deviceWarnOne:export")
@Log(title = "设备报警明细", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(DeviceWarnOneBo bo, HttpServletResponse response) {
List<DeviceWarnOneVo> list = deviceWarnOneService.queryList(bo);
ExcelUtil.exportExcel(list, "设备报警明细", DeviceWarnOneVo.class, response);
}
/**
* 获取设备报警明细详细信息
*
* @param id 主键
*/
@SaCheckPermission("fishery:deviceWarnOne:query")
@GetMapping("/{id}")
public R<DeviceWarnOneVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(deviceWarnOneService.queryById(id));
}
/**
* 新增设备报警明细
*/
@SaCheckPermission("fishery:deviceWarnOne:add")
@Log(title = "设备报警明细", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody DeviceWarnOneBo bo) {
return toAjax(deviceWarnOneService.insertByBo(bo));
}
/**
* 修改设备报警明细
*/
@SaCheckPermission("fishery:deviceWarnOne:edit")
@Log(title = "设备报警明细", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody DeviceWarnOneBo bo) {
return toAjax(deviceWarnOneService.updateByBo(bo));
}
/**
* 删除设备报警明细
*
* @param ids 主键串
*/
@SaCheckPermission("fishery:deviceWarnOne:remove")
@Log(title = "设备报警明细", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(deviceWarnOneService.deleteWithValidByIds(List.of(ids), true));
}
}

104
intc-modules/intc-fishery/src/main/java/com/intc/fishery/controller/MessageOpRecordController.java Normal file
View File

@@ -0,0 +1,104 @@
package com.intc.fishery.controller;
import java.util.List;
import com.intc.common.excel.utils.ExcelUtil;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.intc.common.idempotent.annotation.RepeatSubmit;
import com.intc.common.log.annotation.Log;
import com.intc.common.web.core.BaseController;
import com.intc.common.mybatis.core.page.PageQuery;
import com.intc.common.core.domain.R;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.common.log.enums.BusinessType;
import com.intc.fishery.domain.vo.MessageOpRecordVo;
import com.intc.fishery.domain.bo.MessageOpRecordBo;
import com.intc.fishery.service.IMessageOpRecordService;
import com.intc.common.mybatis.core.page.TableDataInfo;
/**
* 用户操作记录
*
* @author intc
* @date 2025-10-23
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/fishery/messageOpRecord")
public class MessageOpRecordController extends BaseController {
private final IMessageOpRecordService messageOpRecordService;
/**
* 查询用户操作记录列表
*/
@SaCheckPermission("fishery:messageOpRecord:list")
@GetMapping("/list")
public TableDataInfo<MessageOpRecordVo> list(MessageOpRecordBo bo, PageQuery pageQuery) {
return messageOpRecordService.queryPageList(bo, pageQuery);
}
/**
* 导出用户操作记录列表
*/
@SaCheckPermission("fishery:messageOpRecord:export")
@Log(title = "用户操作记录", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(MessageOpRecordBo bo, HttpServletResponse response) {
List<MessageOpRecordVo> list = messageOpRecordService.queryList(bo);
ExcelUtil.exportExcel(list, "用户操作记录", MessageOpRecordVo.class, response);
}
/**
* 获取用户操作记录详细信息
*
* @param id 主键
*/
@SaCheckPermission("fishery:messageOpRecord:query")
@GetMapping("/{id}")
public R<MessageOpRecordVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(messageOpRecordService.queryById(id));
}
/**
* 新增用户操作记录
*/
@SaCheckPermission("fishery:messageOpRecord:add")
@Log(title = "用户操作记录", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody MessageOpRecordBo bo) {
return toAjax(messageOpRecordService.insertByBo(bo));
}
/**
* 修改用户操作记录
*/
@SaCheckPermission("fishery:messageOpRecord:edit")
@Log(title = "用户操作记录", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody MessageOpRecordBo bo) {
return toAjax(messageOpRecordService.updateByBo(bo));
}
/**
* 删除用户操作记录
*
* @param ids 主键串
*/
@SaCheckPermission("fishery:messageOpRecord:remove")
@Log(title = "用户操作记录", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(messageOpRecordService.deleteWithValidByIds(List.of(ids), true));
}
}

104
intc-modules/intc-fishery/src/main/java/com/intc/fishery/controller/TecentUserCacheController.java Normal file
View File

@@ -0,0 +1,104 @@
package com.intc.fishery.controller;
import java.util.List;
import com.intc.common.excel.utils.ExcelUtil;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import com.intc.common.idempotent.annotation.RepeatSubmit;
import com.intc.common.log.annotation.Log;
import com.intc.common.web.core.BaseController;
import com.intc.common.mybatis.core.page.PageQuery;
import com.intc.common.core.domain.R;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.common.log.enums.BusinessType;
import com.intc.fishery.domain.vo.TecentUserCacheVo;
import com.intc.fishery.domain.bo.TecentUserCacheBo;
import com.intc.fishery.service.ITecentUserCacheService;
import com.intc.common.mybatis.core.page.TableDataInfo;
/**
* 公众号用户缓存
*
* @author intc
* @date 2025-10-23
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/fishery/tecentUserCache")
public class TecentUserCacheController extends BaseController {
private final ITecentUserCacheService tecentUserCacheService;
/**
* 查询公众号用户缓存列表
*/
@SaCheckPermission("fishery:tecentUserCache:list")
@GetMapping("/list")
public TableDataInfo<TecentUserCacheVo> list(TecentUserCacheBo bo, PageQuery pageQuery) {
return tecentUserCacheService.queryPageList(bo, pageQuery);
}
/**
* 导出公众号用户缓存列表
*/
@SaCheckPermission("fishery:tecentUserCache:export")
@Log(title = "公众号用户缓存", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(TecentUserCacheBo bo, HttpServletResponse response) {
List<TecentUserCacheVo> list = tecentUserCacheService.queryList(bo);
ExcelUtil.exportExcel(list, "公众号用户缓存", TecentUserCacheVo.class, response);
}
/**
* 获取公众号用户缓存详细信息
*
* @param id 主键
*/
@SaCheckPermission("fishery:tecentUserCache:query")
@GetMapping("/{id}")
public R<TecentUserCacheVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(tecentUserCacheService.queryById(id));
}
/**
* 新增公众号用户缓存
*/
@SaCheckPermission("fishery:tecentUserCache:add")
@Log(title = "公众号用户缓存", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody TecentUserCacheBo bo) {
return toAjax(tecentUserCacheService.insertByBo(bo));
}
/**
* 修改公众号用户缓存
*/
@SaCheckPermission("fishery:tecentUserCache:edit")
@Log(title = "公众号用户缓存", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody TecentUserCacheBo bo) {
return toAjax(tecentUserCacheService.updateByBo(bo));
}
/**
* 删除公众号用户缓存
*
* @param ids 主键串
*/
@SaCheckPermission("fishery:tecentUserCache:remove")
@Log(title = "公众号用户缓存", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(tecentUserCacheService.deleteWithValidByIds(List.of(ids), true));
}
}

83
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/DeviceWarnCombine.java Normal file
View File

@@ -0,0 +1,83 @@
package com.intc.fishery.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.intc.common.tenant.core.TenantEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
/**
* 设备告警信息对象 mgr_device_warn_combine
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("mgr_device_warn_combine")
public class DeviceWarnCombine extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 设备编号
*/
private String deviceSerialNum;
/**
* 设备类型
*/
private Integer deviceType;
/**
* 参数类型
*/
private Integer thresholdType;
/**
* 进展状态
*/
private Integer processStatus;
/**
* 故障类型
*/
private Integer warnType;
/**
* 告警总数量
*/
private Integer totalCount;
/**
* 备注
*/
private String remarkContent;
/**
* 处理人
*/
private String handlerName;
/**
* 处理时间
*/
private Date processTime;
/**
* 备注
*/
private String remark;
}

83
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/DeviceWarnOne.java Normal file
View File

@@ -0,0 +1,83 @@
package com.intc.fishery.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.intc.common.tenant.core.TenantEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
/**
* 设备报警明细对象 mgr_device_warn_one
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("mgr_device_warn_one")
public class DeviceWarnOne extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 报警主表id
*/
private Long warnCombineId;
/**
* 用户id
*/
private Long userId;
/**
* 告警最大值
*/
private Double limitUpper;
/**
* 告警最小值
*/
private Double limitLower;
/**
* 告警当前值
*/
private Double curValue;
/**
* 进展状态
*/
private Integer processStatus;
/**
* 故障类型
*/
private Integer warnType;
/**
* 处理人
*/
private String handlerName;
/**
* 处理时间
*/
private Date processTime;
/**
* 备注
*/
private String remark;
}

61
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/MessageOpRecord.java Normal file
View File

@@ -0,0 +1,61 @@
package com.intc.fishery.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.intc.common.tenant.core.TenantEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
/**
* 用户操作记录对象 aqu_message_op_record
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("aqu_message_op_record")
public class MessageOpRecord extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* 用户id
*/
private Long userId;
/**
* 操作用户id
*/
private Long opUserId;
/**
* 操作标题
*/
private String title;
/**
* 操作内容
*/
private String message;
/**
* 操作方式
*/
private Integer opType;
/**
* 备注
*/
private String remark;
}

46
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/TecentUserCache.java Normal file
View File

@@ -0,0 +1,46 @@
package com.intc.fishery.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.intc.common.tenant.core.TenantEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
/**
* 公众号用户缓存对象 aqu_tecent_user_cache
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("aqu_tecent_user_cache")
public class TecentUserCache extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@TableId(value = "id")
private Long id;
/**
* openId
*/
private String openId;
/**
* unionId
*/
private String unionId;
/**
* 备注
*/
private String remark;
}

87
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/bo/DeviceWarnCombineBo.java Normal file
View File

@@ -0,0 +1,87 @@
package com.intc.fishery.domain.bo;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.fishery.domain.DeviceWarnCombine;
import com.intc.common.mybatis.core.domain.BaseEntity;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 设备告警信息业务对象 mgr_device_warn_combine
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = DeviceWarnCombine.class, reverseConvertGenerate = false)
public class DeviceWarnCombineBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = { EditGroup.class })
private Long id;
/**
* 设备编号
*/
@NotBlank(message = "设备编号不能为空", groups = { AddGroup.class, EditGroup.class })
private String deviceSerialNum;
/**
* 设备类型
*/
@NotNull(message = "设备类型不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer deviceType;
/**
* 参数类型
*/
@NotNull(message = "参数类型不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer thresholdType;
/**
* 进展状态
*/
@NotNull(message = "进展状态不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer processStatus;
/**
* 故障类型
*/
@NotNull(message = "故障类型不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer warnType;
/**
* 告警总数量
*/
@NotNull(message = "告警总数量不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer totalCount;
/**
* 备注
*/
private String remarkContent;
/**
* 处理人
*/
private String handlerName;
/**
* 处理时间
*/
private Date processTime;
/**
* 备注
*/
private String remark;
}

52
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/bo/DeviceWarnOneBatchUpdateBo.java Normal file
View File

@@ -0,0 +1,52 @@
package com.intc.fishery.domain.bo;
import java.util.Date;
import com.intc.common.mybatis.core.domain.BaseEntity;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 设备报警明细批量更新业务对象
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class DeviceWarnOneBatchUpdateBo extends BaseEntity {
/**
* 报警主表id(必填,用于批量更新条件)
*/
@NotNull(message = "报警主表id不能为空")
private Long warnCombineId;
/**
* 进展状态
*/
private Integer processStatus;
/**
* 故障类型
*/
private Integer warnType;
/**
* 处理人
*/
private String handlerName;
/**
* 处理时间
*/
private Date processTime;
/**
* 备注
*/
private String remark;
}

89
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/bo/DeviceWarnOneBo.java Normal file
View File

@@ -0,0 +1,89 @@
package com.intc.fishery.domain.bo;
import java.util.Date;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.common.mybatis.core.domain.BaseEntity;
import com.intc.fishery.domain.DeviceWarnOne;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 设备报警明细业务对象 mgr_device_warn_one
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = DeviceWarnOne.class, reverseConvertGenerate = false)
public class DeviceWarnOneBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = { EditGroup.class })
private Long id;
/**
* 报警主表id
*/
@NotNull(message = "报警主表id不能为空", groups = { AddGroup.class, EditGroup.class })
private Long warnCombineId;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = { AddGroup.class, EditGroup.class })
private Long userId;
/**
* 告警最大值
*/
@NotNull(message = "告警最大值不能为空", groups = { AddGroup.class, EditGroup.class })
private Double limitUpper;
/**
* 告警最小值
*/
@NotNull(message = "告警最小值不能为空", groups = { AddGroup.class, EditGroup.class })
private Double limitLower;
/**
* 告警当前值
*/
@NotNull(message = "告警当前值不能为空", groups = { AddGroup.class, EditGroup.class })
private Double curValue;
/**
* 进展状态
*/
@NotNull(message = "进展状态不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer processStatus;
/**
* 故障类型
*/
@NotNull(message = "故障类型不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer warnType;
/**
* 处理人
*/
private String handlerName;
/**
* 处理时间
*/
private Date processTime;
/**
* 备注
*/
private String remark;
}

63
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/bo/MessageOpRecordBo.java Normal file
View File

@@ -0,0 +1,63 @@
package com.intc.fishery.domain.bo;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.fishery.domain.MessageOpRecord;
import com.intc.common.mybatis.core.domain.BaseEntity;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
/**
* 用户操作记录业务对象 aqu_message_op_record
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = MessageOpRecord.class, reverseConvertGenerate = false)
public class MessageOpRecordBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = { EditGroup.class })
private Long id;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = { AddGroup.class, EditGroup.class })
private Long userId;
/**
* 操作用户id
*/
private Long opUserId;
/**
* 操作标题
*/
@NotBlank(message = "操作标题不能为空", groups = { AddGroup.class, EditGroup.class })
private String title;
/**
* 操作内容
*/
@NotBlank(message = "操作内容不能为空", groups = { AddGroup.class, EditGroup.class })
private String message;
/**
* 操作方式
*/
@NotNull(message = "操作方式不能为空", groups = { AddGroup.class, EditGroup.class })
private Integer opType;
/**
* 备注
*/
private String remark;
}

46
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/bo/TecentUserCacheBo.java Normal file
View File

@@ -0,0 +1,46 @@
package com.intc.fishery.domain.bo;
import com.intc.common.core.validate.AddGroup;
import com.intc.common.core.validate.EditGroup;
import com.intc.fishery.domain.TecentUserCache;
import com.intc.common.mybatis.core.domain.BaseEntity;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
/**
* 公众号用户缓存业务对象 aqu_tecent_user_cache
*
* @author intc
* @date 2025-10-23
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = TecentUserCache.class, reverseConvertGenerate = false)
public class TecentUserCacheBo extends BaseEntity {
/**
* 主键id
*/
@NotNull(message = "主键id不能为空", groups = { EditGroup.class })
private Long id;
/**
* openId
*/
@NotBlank(message = "openId不能为空", groups = { AddGroup.class, EditGroup.class })
private String openId;
/**
* unionId
*/
@NotBlank(message = "unionId不能为空", groups = { AddGroup.class, EditGroup.class })
private String unionId;
/**
* 备注
*/
private String remark;
}

99
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/vo/DeviceWarnCombineVo.java Normal file
View File

@@ -0,0 +1,99 @@
package com.intc.fishery.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.intc.fishery.domain.DeviceWarnCombine;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.intc.common.excel.annotation.ExcelDictFormat;
import com.intc.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 设备告警信息视图对象 mgr_device_warn_combine
*
* @author intc
* @date 2025-10-23
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = DeviceWarnCombine.class)
public class DeviceWarnCombineVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 设备编号
*/
@ExcelProperty(value = "设备编号")
private String deviceSerialNum;
/**
* 设备类型
*/
@ExcelProperty(value = "设备类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "aqu_device_type")
private Integer deviceType;
/**
* 参数类型
*/
@ExcelProperty(value = "参数类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "threshold_type")
private Integer thresholdType;
/**
* 进展状态
*/
@ExcelProperty(value = "进展状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "process_status")
private Integer processStatus;
/**
* 故障类型
*/
@ExcelProperty(value = "故障类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "risk_type")
private Integer warnType;
/**
* 告警总数量
*/
@ExcelProperty(value = "告警总数量")
private Integer totalCount;
/**
* 处理人
*/
@ExcelProperty(value = "处理人")
private String handlerName;
/**
* 处理时间
*/
@ExcelProperty(value = "处理时间")
private Date processTime;
/**
* 创建时间
*/
@ExcelProperty(value = "创建时间")
private Date createTime;
private Date updateTime;
}

120
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/vo/DeviceWarnOneVo.java Normal file
View File

@@ -0,0 +1,120 @@
package com.intc.fishery.domain.vo;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.intc.common.excel.annotation.ExcelDictFormat;
import com.intc.common.excel.convert.ExcelDictConvert;
import com.intc.common.json.handler.DoubleSerializer;
import com.intc.fishery.domain.DeviceWarnOne;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
/**
* 设备报警明细视图对象 mgr_device_warn_one
*
* @author intc
* @date 2025-10-23
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = DeviceWarnOne.class)
public class DeviceWarnOneVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 报警主表id
*/
@ExcelProperty(value = "报警主表id")
private Long warnCombineId;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 告警最大值
*/
@ExcelProperty(value = "告警最大值")
private Double limitUpper;
/**
* 告警最小值
*/
@ExcelProperty(value = "告警最小值")
private Double limitLower;
/**
* 告警当前值
*/
@ExcelProperty(value = "告警当前值")
@JsonSerialize(using = DoubleSerializer.class)
private Double curValue;
/**
* 进展状态
*/
@ExcelProperty(value = "进展状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "process_status")
private Integer processStatus;
/**
* 故障类型
*/
@ExcelProperty(value = "故障类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "risk_type")
private Integer warnType;
/**
* 处理人
*/
@ExcelProperty(value = "处理人")
private String handlerName;
/**
* 处理时间
*/
@ExcelProperty(value = "处理时间")
private Date processTime;
/**
* 设备编号
*/
@ExcelProperty(value = "设备编号")
private String deviceSerialNum;
/**
* 设备类型
*/
@ExcelProperty(value = "设备类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "aqu_device_type")
private Integer deviceType;
/**
* 参数类型
*/
@ExcelProperty(value = "参数类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "threshold_type")
private Integer thresholdType;
private Date createTime;
private Date updateTime;
}

101
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/vo/MessageOpRecordVo.java Normal file
View File

@@ -0,0 +1,101 @@
package com.intc.fishery.domain.vo;
import com.intc.fishery.domain.MessageOpRecord;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.intc.common.excel.annotation.ExcelDictFormat;
import com.intc.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 用户操作记录视图对象 aqu_message_op_record
*
* @author intc
* @date 2025-10-23
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = MessageOpRecord.class)
public class MessageOpRecordVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 操作用户id
*/
@ExcelProperty(value = "操作用户id")
private Long opUserId;
/**
* 操作标题
*/
@ExcelProperty(value = "操作标题")
private String title;
/**
* 操作内容
*/
@ExcelProperty(value = "操作内容")
private String message;
/**
* 操作方式
*/
@ExcelProperty(value = "操作方式", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "op_type")
private Integer opType;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 用户名(关联查询)
*/
@ExcelProperty(value = "用户名")
private String userName;
/**
* 用户手机号(关联查询)
*/
@ExcelProperty(value = "用户手机号")
private String userPhonenumber;
/**
* 操作用户名(关联查询)
*/
@ExcelProperty(value = "操作用户名")
private String opUserName;
/**
* 操作用户手机号(关联查询)
*/
@ExcelProperty(value = "操作用户手机号")
private String opUserPhonenumber;
private Date createTime;
private Date updateTime;
}

58
intc-modules/intc-fishery/src/main/java/com/intc/fishery/domain/vo/TecentUserCacheVo.java Normal file
View File

@@ -0,0 +1,58 @@
package com.intc.fishery.domain.vo;
import com.intc.fishery.domain.TecentUserCache;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import com.intc.common.excel.annotation.ExcelDictFormat;
import com.intc.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 公众号用户缓存视图对象 aqu_tecent_user_cache
*
* @author intc
* @date 2025-10-23
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = TecentUserCache.class)
public class TecentUserCacheVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
@ExcelProperty(value = "主键id")
private Long id;
/**
* openId
*/
@ExcelProperty(value = "openId")
private String openId;
/**
* unionId
*/
@ExcelProperty(value = "unionId")
private String unionId;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
private Date createTime;
private Date updateTime;
}

15
intc-modules/intc-fishery/src/main/java/com/intc/fishery/mapper/DeviceWarnCombineMapper.java Normal file
View File

@@ -0,0 +1,15 @@
package com.intc.fishery.mapper;
import com.intc.common.mybatis.core.mapper.BaseMapperPlusJoin;
import com.intc.fishery.domain.DeviceWarnCombine;
import com.intc.fishery.domain.vo.DeviceWarnCombineVo;
/**
* 设备告警信息Mapper接口
*
* @author intc
* @date 2025-10-23
*/
public interface DeviceWarnCombineMapper extends BaseMapperPlusJoin<DeviceWarnCombine, DeviceWarnCombineVo> {
}

15
intc-modules/intc-fishery/src/main/java/com/intc/fishery/mapper/DeviceWarnOneMapper.java Normal file
View File

@@ -0,0 +1,15 @@
package com.intc.fishery.mapper;
import com.intc.common.mybatis.core.mapper.BaseMapperPlusJoin;
import com.intc.fishery.domain.DeviceWarnOne;
import com.intc.fishery.domain.vo.DeviceWarnOneVo;
/**
* 设备报警明细Mapper接口
*
* @author intc
* @date 2025-10-23
*/
public interface DeviceWarnOneMapper extends BaseMapperPlusJoin<DeviceWarnOne, DeviceWarnOneVo> {
}

15
intc-modules/intc-fishery/src/main/java/com/intc/fishery/mapper/MessageOpRecordMapper.java Normal file
View File

@@ -0,0 +1,15 @@
package com.intc.fishery.mapper;
import com.intc.fishery.domain.MessageOpRecord;
import com.intc.fishery.domain.vo.MessageOpRecordVo;
import com.intc.common.mybatis.core.mapper.BaseMapperPlusJoin;
/**
* 用户操作记录Mapper接口
*
* @author intc
* @date 2025-10-23
*/
public interface MessageOpRecordMapper extends BaseMapperPlusJoin<MessageOpRecord, MessageOpRecordVo> {
}

15
intc-modules/intc-fishery/src/main/java/com/intc/fishery/mapper/TecentUserCacheMapper.java Normal file
View File

@@ -0,0 +1,15 @@
package com.intc.fishery.mapper;
import com.intc.fishery.domain.TecentUserCache;
import com.intc.fishery.domain.vo.TecentUserCacheVo;
import com.intc.common.mybatis.core.mapper.BaseMapperPlus;
/**
* 公众号用户缓存Mapper接口
*
* @author intc
* @date 2025-10-23
*/
public interface TecentUserCacheMapper extends BaseMapperPlus<TecentUserCache, TecentUserCacheVo> {
}

68
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/IDeviceWarnCombineService.java Normal file
View File

@@ -0,0 +1,68 @@
package com.intc.fishery.service;
import com.intc.fishery.domain.vo.DeviceWarnCombineVo;
import com.intc.fishery.domain.bo.DeviceWarnCombineBo;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 设备告警信息Service接口
*
* @author intc
* @date 2025-10-23
*/
public interface IDeviceWarnCombineService {
/**
* 查询设备告警信息
*
* @param id 主键
* @return 设备告警信息
*/
DeviceWarnCombineVo queryById(Long id);
/**
* 分页查询设备告警信息列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 设备告警信息分页列表
*/
TableDataInfo<DeviceWarnCombineVo> queryPageList(DeviceWarnCombineBo bo, PageQuery pageQuery);
/**
* 查询符合条件的设备告警信息列表
*
* @param bo 查询条件
* @return 设备告警信息列表
*/
List<DeviceWarnCombineVo> queryList(DeviceWarnCombineBo bo);
/**
* 新增设备告警信息
*
* @param bo 设备告警信息
* @return 是否新增成功
*/
Boolean insertByBo(DeviceWarnCombineBo bo);
/**
* 修改设备告警信息
*
* @param bo 设备告警信息
* @return 是否修改成功
*/
Boolean updateByBo(DeviceWarnCombineBo bo);
/**
* 校验并批量删除设备告警信息信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

70
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/IDeviceWarnOneService.java Normal file
View File

@@ -0,0 +1,70 @@
package com.intc.fishery.service;
import com.intc.fishery.domain.vo.DeviceWarnOneVo;
import com.intc.fishery.domain.bo.DeviceWarnOneBo;
import com.intc.fishery.domain.bo.DeviceWarnOneBatchUpdateBo;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 设备报警明细Service接口
*
* @author intc
* @date 2025-10-23
*/
public interface IDeviceWarnOneService {
/**
* 查询设备报警明细
*
* @param id 主键
* @return 设备报警明细
*/
DeviceWarnOneVo queryById(Long id);
/**
* 分页查询设备报警明细列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 设备报警明细分页列表
*/
TableDataInfo<DeviceWarnOneVo> queryPageList(DeviceWarnOneBo bo, PageQuery pageQuery);
/**
* 查询符合条件的设备报警明细列表
*
* @param bo 查询条件
* @return 设备报警明细列表
*/
List<DeviceWarnOneVo> queryList(DeviceWarnOneBo bo);
/**
* 新增设备报警明细
*
* @param bo 设备报警明细
* @return 是否新增成功
*/
Boolean insertByBo(DeviceWarnOneBo bo);
/**
* 修改设备报警明细
*
* @param bo 设备报警明细
* @return 是否修改成功
*/
Boolean updateByBo(DeviceWarnOneBo bo);
/**
* 校验并批量删除设备报警明细信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

68
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/IMessageOpRecordService.java Normal file
View File

@@ -0,0 +1,68 @@
package com.intc.fishery.service;
import com.intc.fishery.domain.vo.MessageOpRecordVo;
import com.intc.fishery.domain.bo.MessageOpRecordBo;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 用户操作记录Service接口
*
* @author intc
* @date 2025-10-23
*/
public interface IMessageOpRecordService {
/**
* 查询用户操作记录
*
* @param id 主键
* @return 用户操作记录
*/
MessageOpRecordVo queryById(Long id);
/**
* 分页查询用户操作记录列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 用户操作记录分页列表
*/
TableDataInfo<MessageOpRecordVo> queryPageList(MessageOpRecordBo bo, PageQuery pageQuery);
/**
* 查询符合条件的用户操作记录列表
*
* @param bo 查询条件
* @return 用户操作记录列表
*/
List<MessageOpRecordVo> queryList(MessageOpRecordBo bo);
/**
* 新增用户操作记录
*
* @param bo 用户操作记录
* @return 是否新增成功
*/
Boolean insertByBo(MessageOpRecordBo bo);
/**
* 修改用户操作记录
*
* @param bo 用户操作记录
* @return 是否修改成功
*/
Boolean updateByBo(MessageOpRecordBo bo);
/**
* 校验并批量删除用户操作记录信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

68
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/ITecentUserCacheService.java Normal file
View File

@@ -0,0 +1,68 @@
package com.intc.fishery.service;
import com.intc.fishery.domain.vo.TecentUserCacheVo;
import com.intc.fishery.domain.bo.TecentUserCacheBo;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 公众号用户缓存Service接口
*
* @author intc
* @date 2025-10-23
*/
public interface ITecentUserCacheService {
/**
* 查询公众号用户缓存
*
* @param id 主键
* @return 公众号用户缓存
*/
TecentUserCacheVo queryById(Long id);
/**
* 分页查询公众号用户缓存列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 公众号用户缓存分页列表
*/
TableDataInfo<TecentUserCacheVo> queryPageList(TecentUserCacheBo bo, PageQuery pageQuery);
/**
* 查询符合条件的公众号用户缓存列表
*
* @param bo 查询条件
* @return 公众号用户缓存列表
*/
List<TecentUserCacheVo> queryList(TecentUserCacheBo bo);
/**
* 新增公众号用户缓存
*
* @param bo 公众号用户缓存
* @return 是否新增成功
*/
Boolean insertByBo(TecentUserCacheBo bo);
/**
* 修改公众号用户缓存
*
* @param bo 公众号用户缓存
* @return 是否修改成功
*/
Boolean updateByBo(TecentUserCacheBo bo);
/**
* 校验并批量删除公众号用户缓存信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

177
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/impl/DeviceWarnCombineServiceImpl.java Normal file
View File

@@ -0,0 +1,177 @@
package com.intc.fishery.service.impl;
import com.intc.common.core.utils.MapstructUtils;
import com.intc.common.core.utils.StringUtils;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import com.intc.fishery.domain.bo.DeviceWarnCombineBo;
import com.intc.fishery.domain.vo.DeviceWarnCombineVo;
import com.intc.fishery.domain.DeviceWarnCombine;
import com.intc.fishery.domain.DeviceWarnOne;
import com.intc.fishery.mapper.DeviceWarnCombineMapper;
import com.intc.fishery.mapper.DeviceWarnOneMapper;
import com.intc.fishery.service.IDeviceWarnCombineService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 设备告警信息Service业务层处理
*
* @author intc
* @date 2025-10-23
*/
@Slf4j
@RequiredArgsConstructor
@Service
public class DeviceWarnCombineServiceImpl implements IDeviceWarnCombineService {
private final DeviceWarnCombineMapper baseMapper;
private final DeviceWarnOneMapper deviceWarnOneMapper;
/**
* 查询设备告警信息
*
* @param id 主键
* @return 设备告警信息
*/
@Override
public DeviceWarnCombineVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 分页查询设备告警信息列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 设备告警信息分页列表
*/
@Override
public TableDataInfo<DeviceWarnCombineVo> queryPageList(DeviceWarnCombineBo bo, PageQuery pageQuery) {
MPJLambdaWrapper<DeviceWarnCombine> wrapper = buildJoinQueryWrapper(bo);
Page<DeviceWarnCombineVo> result = baseMapper.selectJoinPage(pageQuery.build(), DeviceWarnCombineVo.class, wrapper);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的设备告警信息列表
*
* @param bo 查询条件
* @return 设备告警信息列表
*/
@Override
public List<DeviceWarnCombineVo> queryList(DeviceWarnCombineBo bo) {
MPJLambdaWrapper<DeviceWarnCombine> wrapper = buildJoinQueryWrapper(bo);
return baseMapper.selectJoinList(DeviceWarnCombineVo.class, wrapper);
}
private MPJLambdaWrapper<DeviceWarnCombine> buildJoinQueryWrapper(DeviceWarnCombineBo bo) {
Map<String, Object> params = bo.getParams();
MPJLambdaWrapper<DeviceWarnCombine> wrapper = new MPJLambdaWrapper<DeviceWarnCombine>()
.selectAll(DeviceWarnCombine.class)
.selectCount(DeviceWarnOne::getId, DeviceWarnCombineVo::getTotalCount)
.leftJoin(DeviceWarnOne.class, DeviceWarnOne::getWarnCombineId, DeviceWarnCombine::getId)
.eq(StringUtils.isNotBlank(bo.getDeviceSerialNum()), DeviceWarnCombine::getDeviceSerialNum, bo.getDeviceSerialNum())
.eq(bo.getDeviceType() != null, DeviceWarnCombine::getDeviceType, bo.getDeviceType())
.eq(bo.getThresholdType() != null, DeviceWarnCombine::getThresholdType, bo.getThresholdType())
.eq(bo.getProcessStatus() != null, DeviceWarnCombine::getProcessStatus, bo.getProcessStatus())
.eq(bo.getWarnType() != null, DeviceWarnCombine::getWarnType, bo.getWarnType())
.groupBy(DeviceWarnCombine::getId)
.orderByDesc(DeviceWarnCombine::getUpdateTime);
return wrapper;
}
/**
* 新增设备告警信息
*
* @param bo 设备告警信息
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(DeviceWarnCombineBo bo) {
DeviceWarnCombine add = MapstructUtils.convert(bo, DeviceWarnCombine.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改设备告警信息
*
* @param bo 设备告警信息
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(DeviceWarnCombineBo bo) {
DeviceWarnCombine update = MapstructUtils.convert(bo, DeviceWarnCombine.class);
validEntityBeforeSave(update);
boolean result = baseMapper.updateById(update) > 0;
// 如果更新成功,同时批量更新关联的DeviceWarnOne记录
if (result) {
LambdaUpdateWrapper<DeviceWarnOne> updateWrapper = Wrappers.lambdaUpdate();
updateWrapper.eq(DeviceWarnOne::getWarnCombineId, bo.getId());
// 只更新非空字段
updateWrapper.set(bo.getProcessStatus() != null, DeviceWarnOne::getProcessStatus, bo.getProcessStatus());
updateWrapper.set(bo.getWarnType() != null, DeviceWarnOne::getWarnType, bo.getWarnType());
updateWrapper.set(StringUtils.isNotBlank(bo.getHandlerName()), DeviceWarnOne::getHandlerName, bo.getHandlerName());
updateWrapper.set(bo.getProcessTime() != null, DeviceWarnOne::getProcessTime, bo.getProcessTime());
updateWrapper.set(StringUtils.isNotBlank(bo.getRemark()), DeviceWarnOne::getRemark, bo.getRemark());
int updatedCount = deviceWarnOneMapper.update(null, updateWrapper);
log.info("更新DeviceWarnCombine[id={}]成功,同时批量更新了{}条DeviceWarnOne记录", bo.getId(), updatedCount);
}
return result;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DeviceWarnCombine entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除设备告警信息信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
// 先删除关联的DeviceWarnOne记录
LambdaQueryWrapper<DeviceWarnOne> queryWrapper = Wrappers.lambdaQuery();
queryWrapper.in(DeviceWarnOne::getWarnCombineId, ids);
int deletedDetailCount = deviceWarnOneMapper.delete(queryWrapper);
log.info("删除DeviceWarnCombine记录前,先删除了{}条关联的DeviceWarnOne记录", deletedDetailCount);
// 再删除主表DeviceWarnCombine记录
boolean result = baseMapper.deleteByIds(ids) > 0;
if (result) {
log.info("成功删除{}条DeviceWarnCombine记录", ids.size());
}
return result;
}
}

154
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/impl/DeviceWarnOneServiceImpl.java Normal file
View File

@@ -0,0 +1,154 @@
package com.intc.fishery.service.impl;
import com.intc.common.core.utils.MapstructUtils;
import com.intc.common.core.utils.StringUtils;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import com.intc.fishery.domain.bo.DeviceWarnOneBo;
import com.intc.fishery.domain.bo.DeviceWarnOneBatchUpdateBo;
import com.intc.fishery.domain.vo.DeviceWarnOneVo;
import com.intc.fishery.domain.DeviceWarnOne;
import com.intc.fishery.domain.DeviceWarnCombine;
import com.intc.fishery.mapper.DeviceWarnOneMapper;
import com.intc.fishery.service.IDeviceWarnOneService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 设备报警明细Service业务层处理
*
* @author intc
* @date 2025-10-23
*/
@Slf4j
@RequiredArgsConstructor
@Service
public class DeviceWarnOneServiceImpl implements IDeviceWarnOneService {
private final DeviceWarnOneMapper baseMapper;
/**
* 查询设备报警明细
*
* @param id 主键
* @return 设备报警明细
*/
@Override
public DeviceWarnOneVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 分页查询设备报警明细列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 设备报警明细分页列表
*/
@Override
public TableDataInfo<DeviceWarnOneVo> queryPageList(DeviceWarnOneBo bo, PageQuery pageQuery) {
MPJLambdaWrapper<DeviceWarnOne> wrapper = buildJoinQueryWrapper(bo);
Page<DeviceWarnOneVo> result = baseMapper.selectJoinPage(pageQuery.build(), DeviceWarnOneVo.class, wrapper);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的设备报警明细列表
*
* @param bo 查询条件
* @return 设备报警明细列表
*/
@Override
public List<DeviceWarnOneVo> queryList(DeviceWarnOneBo bo) {
MPJLambdaWrapper<DeviceWarnOne> wrapper = buildJoinQueryWrapper(bo);
return baseMapper.selectJoinList(DeviceWarnOneVo.class, wrapper);
}
private MPJLambdaWrapper<DeviceWarnOne> buildJoinQueryWrapper(DeviceWarnOneBo bo) {
Map<String, Object> params = bo.getParams();
// 从params中获取关联表查询条件并转换类型
String deviceSerialNum = (String) params.get("deviceSerialNum");
Integer deviceType = params.get("deviceType") != null ? Integer.parseInt(params.get("deviceType").toString()) : null;
Integer thresholdType = params.get("thresholdType") != null ? Integer.parseInt(params.get("thresholdType").toString()) : null;
MPJLambdaWrapper<DeviceWarnOne> wrapper = new MPJLambdaWrapper<DeviceWarnOne>()
.selectAll(DeviceWarnOne.class)
.select(DeviceWarnCombine::getDeviceSerialNum)
.select(DeviceWarnCombine::getDeviceType)
.select(DeviceWarnCombine::getThresholdType)
.leftJoin(DeviceWarnCombine.class, DeviceWarnCombine::getId, DeviceWarnOne::getWarnCombineId)
.eq(bo.getWarnCombineId() != null, DeviceWarnOne::getWarnCombineId, bo.getWarnCombineId())
.eq(bo.getUserId() != null, DeviceWarnOne::getUserId, bo.getUserId())
.eq(bo.getProcessStatus() != null, DeviceWarnOne::getProcessStatus, bo.getProcessStatus())
.eq(bo.getWarnType() != null, DeviceWarnOne::getWarnType, bo.getWarnType())
.like(StringUtils.isNotBlank(bo.getHandlerName()), DeviceWarnOne::getHandlerName, bo.getHandlerName())
.like(StringUtils.isNotBlank(deviceSerialNum), DeviceWarnCombine::getDeviceSerialNum, deviceSerialNum)
.eq(deviceType != null, DeviceWarnCombine::getDeviceType, deviceType)
.eq(thresholdType != null, DeviceWarnCombine::getThresholdType, thresholdType)
.orderByDesc(DeviceWarnOne::getUpdateTime);
return wrapper;
}
/**
* 新增设备报警明细
*
* @param bo 设备报警明细
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(DeviceWarnOneBo bo) {
DeviceWarnOne add = MapstructUtils.convert(bo, DeviceWarnOne.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改设备报警明细
*
* @param bo 设备报警明细
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(DeviceWarnOneBo bo) {
DeviceWarnOne update = MapstructUtils.convert(bo, DeviceWarnOne.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(DeviceWarnOne entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除设备报警明细信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
}

159
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/impl/MessageOpRecordServiceImpl.java Normal file
View File

@@ -0,0 +1,159 @@
package com.intc.fishery.service.impl;
import com.intc.common.core.utils.MapstructUtils;
import com.intc.common.core.utils.StringUtils;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import com.intc.fishery.domain.bo.MessageOpRecordBo;
import com.intc.fishery.domain.vo.MessageOpRecordVo;
import com.intc.fishery.domain.MessageOpRecord;
import com.intc.fishery.domain.AquUser;
import com.intc.fishery.mapper.MessageOpRecordMapper;
import com.intc.fishery.service.IMessageOpRecordService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 用户操作记录Service业务层处理
*
* @author intc
* @date 2025-10-23
*/
@Slf4j
@RequiredArgsConstructor
@Service
public class MessageOpRecordServiceImpl implements IMessageOpRecordService {
private final MessageOpRecordMapper baseMapper;
/**
* 查询用户操作记录
*
* @param id 主键
* @return 用户操作记录
*/
@Override
public MessageOpRecordVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 分页查询用户操作记录列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 用户操作记录分页列表
*/
@Override
public TableDataInfo<MessageOpRecordVo> queryPageList(MessageOpRecordBo bo, PageQuery pageQuery) {
MPJLambdaWrapper<MessageOpRecord> wrapper = buildJoinQueryWrapper(bo);
Page<MessageOpRecordVo> result = baseMapper.selectJoinPage(pageQuery.build(), MessageOpRecordVo.class, wrapper);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的用户操作记录列表
*
* @param bo 查询条件
* @return 用户操作记录列表
*/
@Override
public List<MessageOpRecordVo> queryList(MessageOpRecordBo bo) {
MPJLambdaWrapper<MessageOpRecord> wrapper = buildJoinQueryWrapper(bo);
return baseMapper.selectJoinList(MessageOpRecordVo.class, wrapper);
}
private MPJLambdaWrapper<MessageOpRecord> buildJoinQueryWrapper(MessageOpRecordBo bo) {
Map<String, Object> params = bo.getParams();
// 获取用户关键字搜索参数
String userKeyword = params.get("userKeyword") != null ? params.get("userKeyword").toString() : null;
MPJLambdaWrapper<MessageOpRecord> wrapper = new MPJLambdaWrapper<MessageOpRecord>()
.selectAll(MessageOpRecord.class)
// 关联查询AquUser用户信息
.selectAs("u1.user_name", MessageOpRecordVo::getUserName)
.selectAs("u1.mobile_phone", MessageOpRecordVo::getUserPhonenumber)
// 关联查询操作用户信息
.selectAs("u2.user_name", MessageOpRecordVo::getOpUserName)
.selectAs("u2.mobile_phone", MessageOpRecordVo::getOpUserPhonenumber)
// 关联aqu_user表(用户)
.leftJoin("aqu_user u1 on u1.id = t.user_id")
// 关联aqu_user表(操作用户)
.leftJoin("aqu_user u2 on u2.id = t.op_user_id")
.eq(bo.getUserId() != null, MessageOpRecord::getUserId, bo.getUserId())
.eq(bo.getOpUserId() != null, MessageOpRecord::getOpUserId, bo.getOpUserId())
.like(StringUtils.isNotBlank(bo.getTitle()), MessageOpRecord::getTitle, bo.getTitle())
.like(StringUtils.isNotBlank(bo.getMessage()), MessageOpRecord::getMessage, bo.getMessage())
.eq(bo.getOpType() != null, MessageOpRecord::getOpType, bo.getOpType())
// 根据用户关键字模糊查询用户名或手机号
.and(StringUtils.isNotBlank(userKeyword), w -> w
.like("u1.user_name", userKeyword)
.or()
.like("u1.mobile_phone", userKeyword)
)
.orderByDesc(MessageOpRecord::getCreateTime);
return wrapper;
}
/**
* 新增用户操作记录
*
* @param bo 用户操作记录
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(MessageOpRecordBo bo) {
MessageOpRecord add = MapstructUtils.convert(bo, MessageOpRecord.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改用户操作记录
*
* @param bo 用户操作记录
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(MessageOpRecordBo bo) {
MessageOpRecord update = MapstructUtils.convert(bo, MessageOpRecord.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(MessageOpRecord entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除用户操作记录信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
}

131
intc-modules/intc-fishery/src/main/java/com/intc/fishery/service/impl/TecentUserCacheServiceImpl.java Normal file
View File

@@ -0,0 +1,131 @@
package com.intc.fishery.service.impl;
import com.intc.common.core.utils.MapstructUtils;
import com.intc.common.core.utils.StringUtils;
import com.intc.common.mybatis.core.page.TableDataInfo;
import com.intc.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import com.intc.fishery.domain.bo.TecentUserCacheBo;
import com.intc.fishery.domain.vo.TecentUserCacheVo;
import com.intc.fishery.domain.TecentUserCache;
import com.intc.fishery.mapper.TecentUserCacheMapper;
import com.intc.fishery.service.ITecentUserCacheService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 公众号用户缓存Service业务层处理
*
* @author intc
* @date 2025-10-23
*/
@Slf4j
@RequiredArgsConstructor
@Service
public class TecentUserCacheServiceImpl implements ITecentUserCacheService {
private final TecentUserCacheMapper baseMapper;
/**
* 查询公众号用户缓存
*
* @param id 主键
* @return 公众号用户缓存
*/
@Override
public TecentUserCacheVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 分页查询公众号用户缓存列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 公众号用户缓存分页列表
*/
@Override
public TableDataInfo<TecentUserCacheVo> queryPageList(TecentUserCacheBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<TecentUserCache> lqw = buildQueryWrapper(bo);
Page<TecentUserCacheVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的公众号用户缓存列表
*
* @param bo 查询条件
* @return 公众号用户缓存列表
*/
@Override
public List<TecentUserCacheVo> queryList(TecentUserCacheBo bo) {
LambdaQueryWrapper<TecentUserCache> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<TecentUserCache> buildQueryWrapper(TecentUserCacheBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<TecentUserCache> lqw = Wrappers.lambdaQuery();
lqw.orderByDesc(TecentUserCache::getCreateTime);
return lqw;
}
/**
* 新增公众号用户缓存
*
* @param bo 公众号用户缓存
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(TecentUserCacheBo bo) {
TecentUserCache add = MapstructUtils.convert(bo, TecentUserCache.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改公众号用户缓存
*
* @param bo 公众号用户缓存
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(TecentUserCacheBo bo) {
TecentUserCache update = MapstructUtils.convert(bo, TecentUserCache.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(TecentUserCache entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除公众号用户缓存信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
}

6
intc-modules/intc-fishery/src/main/resources/mapper/fishery/DeviceWarnCombineMapper.xml Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.intc.fishery.mapper.DeviceWarnCombineMapper">
</mapper>

6
intc-modules/intc-fishery/src/main/resources/mapper/fishery/DeviceWarnOneMapper.xml Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.intc.fishery.mapper.DeviceWarnOneMapper">
</mapper>

6
intc-modules/intc-fishery/src/main/resources/mapper/fishery/MessageOpRecordMapper.xml Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.intc.fishery.mapper.MessageOpRecordMapper">
</mapper>

6
intc-modules/intc-fishery/src/main/resources/mapper/fishery/TecentUserCacheMapper.xml Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.intc.fishery.mapper.TecentUserCacheMapper">
</mapper>