szz
/
ShiShiYiBan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

!1243 feat(iot): 添加 OTA 固件管理功能 

Merge pull request !1243 from 陈玄礼/feature/iot-ota-shelly
This commit is contained in:
芋道源码 2025-02-22 10:36:03 +00:00 committed by Gitee
parent f76843573e 54381e29a7
commit ebfe35c787
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
35 changed files with 2128 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
yudao-module-iot/yudao-module-iot-api/src/main/java/cn/iocoder/yudao/module/iot/enums/ErrorCodeConstants.java
View File

@ -51,5 +51,17 @@ public interface ErrorCodeConstants {
// ========== 插件实例 1-050-007-000 ==========
// ========== 固件相关 1-050-008-000 ==========
ErrorCode OTA_FIRMWARE_NOT_EXISTS = new ErrorCode(1_050_008_000, "固件信息不存在");
ErrorCode OTA_FIRMWARE_PRODUCT_VERSION_DUPLICATE = new ErrorCode(1_050_008_001, "产品版本号重复");
ErrorCode OTA_UPGRADE_TASK_NOT_EXISTS = new ErrorCode(1_050_008_002, "升级任务不存在");
ErrorCode OTA_UPGRADE_TASK_NAME_DUPLICATE = new ErrorCode(1_050_008_003, "升级任务名称重复");
ErrorCode OTA_UPGRADE_TASK_PARAMS_INVALID = new ErrorCode(1_050_008_004, "升级任务参数无效");
ErrorCode OTA_UPGRADE_TASK_CANNOT_CANCEL = new ErrorCode(1_050_008_005, "升级任务不能取消");
ErrorCode OTA_UPGRADE_RECORD_NOT_EXISTS = new ErrorCode(1_050_008_006, "升级记录不存在");
ErrorCode OTA_UPGRADE_RECORD_DUPLICATE = new ErrorCode(1_050_008_007, "升级记录重复");
ErrorCode OTA_UPGRADE_RECORD_CANNOT_RETRY = new ErrorCode(1_050_008_008, "升级记录不能重试");
}

62
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/IotOtaFirmwareController.java Normal file
View File

@ -0,0 +1,62 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwarePageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareRespVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareCreateReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareUpdateReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.service.ota.IotOtaFirmwareService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@Validated
@RestController
@Tag(name = "管理后台 - IoT OTA固件")
@RequestMapping("/iot/ota-firmware")
public class IotOtaFirmwareController {
@Resource
private IotOtaFirmwareService otaFirmwareService;
@PostMapping("/create")
@Operation(summary = "创建OTA固件")
@PreAuthorize("@ss.hasPermission('iot:ota-firmware:create')")
public CommonResult<Long> createOtaFirmware(@Valid @RequestBody IotOtaFirmwareCreateReqVO createReqVO) {
return success(otaFirmwareService.createOtaFirmware(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新OTA固件")
@PreAuthorize("@ss.hasPermission('iot:ota-firmware:update')")
public CommonResult<Boolean> updateOtaFirmware(@Valid @RequestBody IotOtaFirmwareUpdateReqVO updateReqVO) {
otaFirmwareService.updateOtaFirmware(updateReqVO);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得OTA固件")
@PreAuthorize("@ss.hasPermission('iot:ota-firmware:query')")
public CommonResult<IotOtaFirmwareRespVO> getOtaFirmware(@RequestParam("id") Long id) {
IotOtaFirmwareDO otaFirmware = otaFirmwareService.getOtaFirmware(id);
return success(BeanUtils.toBean(otaFirmware, IotOtaFirmwareRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得OTA固件分页")
@PreAuthorize("@ss.hasPermission('iot:ota-firmware:query')")
public CommonResult<PageResult<IotOtaFirmwareRespVO>> getOtaFirmwarePage(@Valid IotOtaFirmwarePageReqVO pageReqVO) {
PageResult<IotOtaFirmwareDO> pageResult = otaFirmwareService.getOtaFirmwarePage(pageReqVO);
return success(BeanUtils.toBean(pageResult, IotOtaFirmwareRespVO.class));
}
}

76
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/IotOtaUpgradeRecordController.java Normal file
View File

@ -0,0 +1,76 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record.IotOtaUpgradeRecordPageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record.IotOtaUpgradeRecordRespVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeRecordDO;
import cn.iocoder.yudao.module.iot.service.ota.IotOtaUpgradeRecordService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@Validated
@RestController
@Tag(name = "管理后台 - OTA升级记录")
@RequestMapping("/iot/ota-upgrade-record")
public class IotOtaUpgradeRecordController {
@Resource
private IotOtaUpgradeRecordService upgradeRecordService;
@GetMapping("/get-count")
@Operation(summary = "获得升级记录 分页 tab count")
@PreAuthorize("@ss.hasPermission('iot:ota-upgrade-record:query')")
public CommonResult<Map<Integer, Long>> getOtaUpgradeRecordCount(
@Valid IotOtaUpgradeRecordPageReqVO pageReqVO) {
return success(upgradeRecordService.getOtaUpgradeRecordCount(pageReqVO));
}
@GetMapping("/get-statistics")
@Operation(summary = "固件升级设备统计")
@PreAuthorize("@ss.hasPermission('iot:ota-upgrade-record:query')")
@Parameter(name = "firmwareId", description = "固件编号", required = true, example = "1024")
public CommonResult<Map<Integer, Long>> getOtaUpgradeRecordStatistics(
@RequestParam(value = "firmwareId") Long firmwareId) {
return success(upgradeRecordService.getOtaUpgradeRecordStatistics(firmwareId));
}
@GetMapping("/page")
@Operation(summary = "获得升级记录分页")
@PreAuthorize("@ss.hasPermission('iot:ota-upgrade-record:query')")
public CommonResult<PageResult<IotOtaUpgradeRecordRespVO>> getUpgradeRecordPage(
@Valid IotOtaUpgradeRecordPageReqVO pageReqVO) {
PageResult<IotOtaUpgradeRecordDO> pageResult = upgradeRecordService.getUpgradeRecordPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, IotOtaUpgradeRecordRespVO.class));
}
@GetMapping("/get")
@Operation(summary = "获得升级记录")
@PreAuthorize("@ss.hasPermission('iot:ota-upgrade-record:query')")
@Parameter(name = "id", description = "升级记录编号", required = true, example = "1024")
public CommonResult<IotOtaUpgradeRecordRespVO> getUpgradeRecord(@RequestParam("id") Long id) {
IotOtaUpgradeRecordDO upgradeRecord = upgradeRecordService.getUpgradeRecord(id);
return success(BeanUtils.toBean(upgradeRecord, IotOtaUpgradeRecordRespVO.class));
}
@PostMapping("/retry")
@Operation(summary = "重试升级记录")
@PreAuthorize("@ss.hasPermission('iot:ota-upgrade-record:retry')")
@Parameter(name = "id", description = "升级记录编号", required = true, example = "1024")
public CommonResult<Boolean> retryUpgradeRecord(@RequestParam("id") Long id) {
upgradeRecordService.retryUpgradeRecord(id);
return success(true);
}
}

64
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/IotOtaUpgradeTaskController.java Normal file
View File

@ -0,0 +1,64 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskPageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskRespVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskSaveReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import cn.iocoder.yudao.module.iot.service.ota.IotOtaUpgradeTaskService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@Validated
@RestController
@Tag(name = "管理后台 - OTA升级任务")
@RequestMapping("/iot/ota-upgrade-task")
public class IotOtaUpgradeTaskController {
@Resource
private IotOtaUpgradeTaskService upgradeTaskService;
@PostMapping("/create")
@Operation(summary = "创建升级任务")
@PreAuthorize(value = "@ss.hasPermission('iot:ota-upgrade-task:create')")
public CommonResult<Long> createUpgradeTask(@Valid @RequestBody IotOtaUpgradeTaskSaveReqVO createReqVO) {
return success(upgradeTaskService.createUpgradeTask(createReqVO));
}
@PostMapping("/cancel")
@Operation(summary = "取消升级任务")
@Parameter(name = "id", description = "升级任务编号", required = true)
@PreAuthorize(value = "@ss.hasPermission('iot:ota-upgrade-task:cancel')")
public CommonResult<Boolean> cancelUpgradeTask(@RequestParam("id") Long id) {
upgradeTaskService.cancelUpgradeTask(id);
return success(true);
}
@GetMapping("/page")
@Operation(summary = "获得升级任务分页")
@PreAuthorize(value = "@ss.hasPermission('iot:ota-upgrade-task:query')")
public CommonResult<PageResult<IotOtaUpgradeTaskRespVO>> getUpgradeTaskPage(@Valid @RequestBody IotOtaUpgradeTaskPageReqVO pageReqVO) {
PageResult<IotOtaUpgradeTaskDO> pageResult = upgradeTaskService.getUpgradeTaskPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, IotOtaUpgradeTaskRespVO.class));
}
@GetMapping("/get")
@Operation(summary = "获得升级任务")
@Parameter(name = "id", description = "升级任务编号", required = true, example = "1024")
@PreAuthorize(value = "@ss.hasPermission('iot:ota-upgrade-task:query')")
public CommonResult<IotOtaUpgradeTaskRespVO> getUpgradeTask(@RequestParam("id") Long id) {
IotOtaUpgradeTaskDO upgradeTask = upgradeTaskService.getUpgradeTask(id);
return success(BeanUtils.toBean(upgradeTask, IotOtaUpgradeTaskRespVO.class));
}
}

26
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/firmware/IotOtaFirmwareCommonReqVO.java Normal file
View File

@ -0,0 +1,26 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA固件信息 Request VO")
public class IotOtaFirmwareCommonReqVO {
/**
* 固件名称
*/
@NotEmpty(message = "固件名称不能为空")
@Schema(description = "固件名称", requiredMode = REQUIRED, example = "智能开关固件")
private String name;
/**
* 固件描述
*/
@Schema(description = "固件描述", example = "某品牌型号固件，测试用")
private String description;
}

73
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/firmware/IotOtaFirmwareCreateReqVO.java Normal file
View File

@ -0,0 +1,73 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA固件创建 Request VO")
public class IotOtaFirmwareCreateReqVO extends IotOtaFirmwareCommonReqVO {
/**
* 版本号
*/
@NotEmpty(message = "版本号不能为空")
@Schema(description = "版本号", requiredMode = REQUIRED, example = "1.0.0")
private String version;
/**
* 产品编号
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO#getId()}
*/
@NotNull(message = "产品编号不能为空")
@Schema(description = "产品编号", requiredMode = REQUIRED, example = "1024")
private String productId;
/**
* 产品标识
* <p>
* 冗余 {@link cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO#getProductKey()}
*/
@NotEmpty(message = "产品标识不能为空")
@Schema(description = "产品标识", requiredMode = REQUIRED, example = "yudao")
private String productKey;
/**
* 签名方式
* <p>
* 例如说：MD5、SHA256
*/
@Schema(description = "签名方式", example = "MD5")
private String signMethod;
/**
* 固件文件签名
*/
@Schema(description = "固件文件签名", example = "d41d8cd98f00b204e9800998ecf8427e")
private String fileSign;
/**
* 固件文件大小
*/
@NotNull(message = "固件文件大小不能为空")
@Schema(description = "固件文件大小（单位：byte）", example = "1024")
private Long fileSize;
/**
* 固件文件 URL
*/
@NotEmpty(message = "固件文件 URL 不能为空")
@Schema(description = "固件文件 URL", requiredMode = REQUIRED, example = "https://www.iocoder.cn/yudao-firmware.zip")
private String fileUrl;
/**
* 自定义信息，建议使用 JSON 格式
*/
@Schema(description = "自定义信息，建议使用 JSON 格式", example = "{\"key1\":\"value1\",\"key2\":\"value2\"}")
private String information;
}

23
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/firmware/IotOtaFirmwarePageReqVO.java Normal file
View File

@ -0,0 +1,23 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
@Data
@Schema(description = "管理后台 - OTA固件分页 Request VO")
public class IotOtaFirmwarePageReqVO extends PageParam {
/**
* 固件名称
*/
@Schema(description = "固件名称", example = "智能开关固件")
private String name;
/**
* 产品标识
*/
@Schema(description = "产品标识", example = "1024")
private String productId;
}

85
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/firmware/IotOtaFirmwareRespVO.java Normal file
View File

@ -0,0 +1,85 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware;
import cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO;
import com.fhs.core.trans.anno.Trans;
import com.fhs.core.trans.constant.TransType;
import com.fhs.core.trans.vo.VO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA固件 Response VO")
public class IotOtaFirmwareRespVO implements VO {
/**
* 固件编号
*/
@Schema(description = "固件编号", requiredMode = REQUIRED, example = "1024")
private Long id;
/**
* 固件名称
*/
@Schema(description = "固件名称", requiredMode = REQUIRED, example = "OTA固件")
private String name;
/**
* 固件描述
*/
@Schema(description = "固件描述")
private String description;
/**
* 版本号
*/
@Schema(description = "版本号", requiredMode = REQUIRED, example = "1.0.0")
private String version;
/**
* 产品编号
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO#getId()}
*/
@Schema(description = "产品编号", requiredMode = REQUIRED, example = "1024")
@Trans(type = TransType.SIMPLE, target = IotProductDO.class, fields = {"name"}, refs = {"productName"})
private String productId;
/**
* 产品标识
* <p>
* 冗余 {@link cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO#getProductKey()}
*/
@Schema(description = "产品标识", requiredMode = REQUIRED, example = "iot-product-key")
private String productKey;
/**
* 产品名称
*/
@Schema(description = "产品名称", requiredMode = REQUIRED, example = "OTA产品")
private String productName;
/**
* 签名方式
* <p>
* 例如说：MD5、SHA256
*/
@Schema(description = "签名方式", example = "MD5")
private String signMethod;
/**
* 固件文件签名
*/
@Schema(description = "固件文件签名", example = "1024")
private String fileSign;
/**
* 固件文件大小
*/
@Schema(description = "固件文件大小", requiredMode = REQUIRED, example = "1024")
private Long fileSize;
/**
* 固件文件 URL
*/
@Schema(description = "固件文件 URL", requiredMode = REQUIRED, example = "https://www.iocoder.cn")
private String fileUrl;
/**
* 自定义信息，建议使用 JSON 格式
*/
@Schema(description = "自定义信息，建议使用 JSON 格式")
private String information;
}

20
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/firmware/IotOtaFirmwareUpdateReqVO.java Normal file
View File

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA固件更新 Request VO")
public class IotOtaFirmwareUpdateReqVO extends IotOtaFirmwareCommonReqVO {
/**
* 固件编号
*/
@NotNull(message = "固件编号不能为空")
@Schema(description = "固件编号", requiredMode = REQUIRED, example = "1024")
private Long id;
}

56
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/upgrade/record/IotOtaUpgradeRecordPageReqVO.java Normal file
View File

@ -0,0 +1,56 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA升级记录分页 Request VO")
public class IotOtaUpgradeRecordPageReqVO extends PageParam {
/**
* 待处理状态
*/
public static final Integer PENDING = 0;
/**
* 已推送状态
*/
public static final Integer PUSHED = 10;
/**
* 正在升级状态
*/
public static final Integer UPGRADING = 20;
/**
* 升级成功状态
*/
public static final Integer SUCCESS = 30;
/**
* 升级失败状态
*/
public static final Integer FAILURE = 40;
/**
* 升级已取消状态
*/
public static final Integer CANCELED = 50;
/**
* 升级任务编号字段。
* <p>
* 该字段用于标识升级任务的唯一编号，不能为空。
*/
@NotNull(message = "升级任务编号不能为空")
@Schema(description = "升级任务编号", requiredMode = REQUIRED, example = "1024")
private Long taskId;
/**
* 设备标识字段。
* <p>
* 该字段用于标识设备的名称，通常用于区分不同的设备。
*/
@Schema(description = "设备标识", requiredMode = REQUIRED, example = "摄像头A1-1")
private String deviceName;
}

109
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/upgrade/record/IotOtaUpgradeRecordRespVO.java Normal file
View File

@ -0,0 +1,109 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import com.fhs.core.trans.anno.Trans;
import com.fhs.core.trans.constant.TransType;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA升级记录 Response VO")
public class IotOtaUpgradeRecordRespVO {
/**
* 升级记录编号
*/
@Schema(description = "升级记录编号", requiredMode = REQUIRED, example = "1024")
private Long id;
/**
* 固件编号
* <p>
* 关联 {@link IotOtaFirmwareDO#getId()}
*/
@Schema(description = "固件编号", requiredMode = REQUIRED, example = "1024")
@Trans(type = TransType.SIMPLE, target = IotOtaFirmwareDO.class, fields = {"version"}, refs = {"firmwareVersion"})
private Long firmwareId;
/**
* 固件版本
*/
@Schema(description = "固件版本", requiredMode = REQUIRED, example = "v1.0.0")
private String firmwareVersion;
/**
* 任务编号
* <p>
* 关联 {@link IotOtaUpgradeTaskDO#getId()}
*/
@Schema(description = "任务编号", requiredMode = REQUIRED, example = "1024")
private Long taskId;
/**
* 产品标识
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO#getId()}
*/
@Schema(description = "产品标识", requiredMode = REQUIRED, example = "iot")
private String productKey;
/**
* 设备名称
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO#getId()}
*/
@Schema(description = "设备名称", requiredMode = REQUIRED, example = "iot")
private String deviceName;
/**
* 设备编号
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO#getId()}
*/
@Schema(description = "设备编号", requiredMode = REQUIRED, example = "1024")
private String deviceId;
/**
* 来源的固件编号
* <p>
* 关联 {@link IotDeviceDO#getFirmwareId()}
*/
@Schema(description = "来源的固件编号", requiredMode = REQUIRED, example = "1024")
@Trans(type = TransType.SIMPLE, target = IotOtaFirmwareDO.class, fields = {"version"}, refs = {"fromFirmwareVersion"})
private Long fromFirmwareId;
/**
* 来源的固件版本
*/
@Schema(description = "来源的固件版本", requiredMode = REQUIRED, example = "v1.0.0")
private String fromFirmwareVersion;
/**
* 升级状态
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum}
*/
@Schema(description = "升级状态", requiredMode = REQUIRED, allowableValues = {"0", "10", "20", "30", "40", "50"})
private Integer status;
/**
* 升级进度，百分比
*/
@Schema(description = "升级进度，百分比", requiredMode = REQUIRED, example = "10")
private Integer progress;
/**
* 升级进度描述
* <p>
* 注意，只记录设备最后一次的升级进度描述
* 如果想看历史记录，可以查看 {@link cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceLogDO} 设备日志
*/
@Schema(description = "升级进度描述", requiredMode = REQUIRED, example = "10")
private String description;
/**
* 升级开始时间
*/
@Schema(description = "升级开始时间", requiredMode = REQUIRED, example = "2022-07-08 07:30:00")
private LocalDateTime startTime;
/**
* 升级结束时间
*/
@Schema(description = "升级结束时间", requiredMode = REQUIRED, example = "2022-07-08 07:30:00")
private LocalDateTime endTime;
}

27
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/upgrade/task/IotOtaUpgradeTaskPageReqVO.java Normal file
View File

@ -0,0 +1,27 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA升级任务分页 Request VO")
public class IotOtaUpgradeTaskPageReqVO extends PageParam {
/**
* 任务名称字段，用于描述任务的名称
*/
@Schema(description = "任务名称", example = "升级任务")
private String name;
/**
* 固件编号字段，用于唯一标识固件，不能为空
*/
@NotNull(message = "固件编号不能为空")
@Schema(description = "固件编号", requiredMode = REQUIRED, example = "1024")
private Long firmwareId;
}

84
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/upgrade/task/IotOtaUpgradeTaskRespVO.java Normal file
View File

@ -0,0 +1,84 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import com.fhs.core.trans.vo.VO;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA升级任务 Response VO")
public class IotOtaUpgradeTaskRespVO implements VO {
/**
* 任务编号
*/
@Schema(description = "任务编号", requiredMode = REQUIRED, example = "1024")
private Long id;
/**
* 任务名称
*/
@Schema(description = "任务名称", requiredMode = REQUIRED, example = "升级任务")
private String name;
/**
* 任务描述
*/
@Schema(description = "任务描述", example = "升级任务")
private String description;
/**
* 固件编号
* <p>
* 关联 {@link IotOtaFirmwareDO#getId()}
*/
@Schema(description = "固件编号", requiredMode = REQUIRED, example = "1024")
private Long firmwareId;
/**
* 任务状态
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskStatusEnum}
*/
@Schema(description = "任务状态", requiredMode = REQUIRED, allowableValues = {"10", "20", "21", "30"})
private Integer status;
/**
* 任务状态名称
*/
@Schema(description = "任务状态名称", requiredMode = REQUIRED, example = "进行中")
private String statusName;
/**
* 升级范围
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskScopeEnum}
*/
@Schema(description = "升级范围", requiredMode = REQUIRED, allowableValues = {"1", "2"})
private Integer scope;
/**
* 设备数量
*/
@Schema(description = "设备数量", requiredMode = REQUIRED, example = "1024")
private Long deviceCount;
/**
* 选中的设备编号数组
* <p>
* 关联 {@link IotDeviceDO#getId()}
*/
@Schema(description = "选中的设备编号数组", example = "1024")
private List<Long> deviceIds;
/**
* 选中的设备名字数组
* <p>
* 关联 {@link IotDeviceDO#getDeviceName()}
*/
@Schema(description = "选中的设备名字数组", example = "1024")
private List<String> deviceNames;
/**
* 创建时间
*/
@Schema(description = "创建时间", requiredMode = REQUIRED, example = "2022-07-08 07:30:00")
private LocalDateTime createTime;
}

68
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/controller/admin/ota/vo/upgrade/task/IotOtaUpgradeTaskSaveReqVO.java Normal file
View File

@ -0,0 +1,68 @@
package cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task;
import cn.iocoder.yudao.framework.common.validation.InEnum;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskScopeEnum;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.util.List;
import static io.swagger.v3.oas.annotations.media.Schema.RequiredMode.REQUIRED;
@Data
@Schema(description = "管理后台 - OTA升级任务创建/修改 Request VO")
public class IotOtaUpgradeTaskSaveReqVO {
/**
* 任务名称
*/
@NotEmpty(message = "任务名称不能为空")
@Schema(description = "任务名称", requiredMode = REQUIRED, example = "升级任务")
private String name;
/**
* 任务描述
*/
@Schema(description = "任务描述", example = "升级任务")
private String description;
/**
* 固件编号
* <p>
* 关联 {@link IotOtaFirmwareDO#getId()}
*/
@NotNull(message = "固件编号不能为空")
@Schema(description = "固件编号", requiredMode = REQUIRED, example = "1024")
private Long firmwareId;
/**
* 升级范围
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskScopeEnum}
*/
@NotNull(message = "升级范围不能为空")
@InEnum(value = IotOtaUpgradeTaskScopeEnum.class)
@Schema(description = "升级范围", requiredMode = REQUIRED, example = "1")
private Integer scope;
/**
* 选中的设备编号数组
* <p>
* 关联 {@link IotDeviceDO#getId()}
*/
@Schema(description = "选中的设备编号数组", requiredMode = REQUIRED, example = "[1,2,3,4]")
private List<Long> deviceIds;
/**
* 选中的设备名字数组
* <p>
* 关联 {@link IotDeviceDO#getDeviceName()}
*/
@Schema(description = "选中的设备名字数组", requiredMode = REQUIRED, example = "[设备1,设备2,设备3,设备4]")
private List<String> deviceNames;
}

34
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/convert/ota/IotOtaUpgradeRecordConvert.java Normal file
View File

@ -0,0 +1,34 @@
package cn.iocoder.yudao.module.iot.convert.ota;
import cn.hutool.core.convert.Convert;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum;
import cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record.IotOtaUpgradeRecordCreateReqBO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public interface IotOtaUpgradeRecordConvert {
IotOtaUpgradeRecordConvert INSTANCE = Mappers.getMapper(IotOtaUpgradeRecordConvert.class);
default List<IotOtaUpgradeRecordCreateReqBO> convertBOList(IotOtaUpgradeTaskDO upgradeTask, IotOtaFirmwareDO firmware, List<IotDeviceDO> deviceList) {
return deviceList.stream().map(device -> {
IotOtaUpgradeRecordCreateReqBO createReqBO = new IotOtaUpgradeRecordCreateReqBO();
createReqBO.setFirmwareId(firmware.getId());
createReqBO.setTaskId(upgradeTask.getId());
createReqBO.setProductKey(device.getProductKey());
createReqBO.setDeviceName(device.getDeviceName());
createReqBO.setDeviceId(Convert.toStr(device.getId()));
createReqBO.setFromFirmwareId(Convert.toLong(device.getFirmwareId()));
createReqBO.setStatus(IotOtaUpgradeRecordStatusEnum.PENDING.getStatus());
createReqBO.setProgress(0);
return createReqBO;
}).toList();
}
}

21
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/dataobject/ota/IotOtaUpgradeTaskDO.java
View File

@ -41,30 +41,41 @@ public class IotOtaUpgradeTaskDO extends BaseDO {
/**
* 固件编号
*
* <p>
* 关联 {@link IotOtaFirmwareDO#getId()}
*/
private Long firmwareId;
/**
* 任务状态
*
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskStatusEnum}
*/
private Integer status;
/**
* 升级范围
*
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskScopeEnum}
*/
private Integer scope;
/**
* 设备数量
*/
private Long deviceCount;
/**
* 选中的设备编号数组
* <p>
* 关联 {@link IotDeviceDO#getId()}
*/
@TableField(typeHandler = JacksonTypeHandler.class)
private List<Long> deviceIds;
/**
* 选中的设备名字数组
*
* <p>
* 关联 {@link IotDeviceDO#getDeviceName()}
*/
@TableField(typeHandler = JacksonTypeHandler.class)
private List<String> deviceNames;
}
}

4
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/mysql/device/IotDeviceMapper.java
View File

@ -60,6 +60,10 @@ public interface IotDeviceMapper extends BaseMapperX<IotDeviceDO> {
return selectList(IotDeviceDO::getState, state);
}
default List<IotDeviceDO> selectListByProductId(Long productId) {
return selectList(IotDeviceDO::getProductId, productId);
}
default Long selectCountByGroupId(Long groupId) {
return selectCount(new LambdaQueryWrapperX<IotDeviceDO>()
.apply("FIND_IN_SET(" + groupId + ",group_ids) > 0")

46
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/mysql/ota/IotOtaFirmwareMapper.java Normal file
View File

@ -0,0 +1,46 @@
package cn.iocoder.yudao.module.iot.dal.mysql.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwarePageReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* IotOtaFirmwareMapper 接口用于操作 IotOtaFirmwareDO 实体类对应的数据库表。
* 该接口继承自 BaseMapperX，提供了基本的 CRUD 操作，并扩展了特定查询方法。
*/
@Mapper
public interface IotOtaFirmwareMapper extends BaseMapperX<IotOtaFirmwareDO> {
/**
* 根据产品ID和固件版本号查询固件信息列表。
*
* @param productId 产品ID，用于筛选固件信息。
* @param version 固件版本号，用于筛选固件信息。
* @return 返回符合条件的固件信息列表。
*/
default List<IotOtaFirmwareDO> selectByProductIdAndVersion(String productId, String version) {
return selectList(new LambdaQueryWrapperX<IotOtaFirmwareDO>()
.eq(IotOtaFirmwareDO::getProductId, productId)
.eq(IotOtaFirmwareDO::getVersion, version));
}
/**
* 分页查询固件信息，支持根据名称和产品ID进行筛选，并按创建时间降序排列。
*
* @param pageReqVO 分页查询请求对象，包含分页参数和筛选条件。
* @return 返回分页查询结果，包含符合条件的固件信息列表。
*/
default PageResult<IotOtaFirmwareDO> selectPage(IotOtaFirmwarePageReqVO pageReqVO) {
return selectPage(pageReqVO,
new LambdaQueryWrapperX<IotOtaFirmwareDO>()
.likeIfPresent(IotOtaFirmwareDO::getName, pageReqVO.getName())
.eqIfPresent(IotOtaFirmwareDO::getProductId, pageReqVO.getProductId())
.orderByDesc(IotOtaFirmwareDO::getCreateTime));
}
}

133
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/mysql/ota/IotOtaUpgradeRecordMapper.java Normal file
View File

@ -0,0 +1,133 @@
package cn.iocoder.yudao.module.iot.dal.mysql.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record.IotOtaUpgradeRecordPageReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeRecordDO;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* OTA升级记录 Mapper 接口
*/
@Mapper
public interface IotOtaUpgradeRecordMapper extends BaseMapperX<IotOtaUpgradeRecordDO> {
/**
* 根据条件查询单个OTA升级记录
*
* @param firmwareId 固件ID，可选参数，用于筛选固件ID匹配的记录
* @param taskId 任务ID，可选参数，用于筛选任务ID匹配的记录
* @param deviceId 设备ID，可选参数，用于筛选设备ID匹配的记录
* @return 返回符合条件的单个OTA升级记录，如果不存在则返回null
*/
default IotOtaUpgradeRecordDO selectByConditions(Long firmwareId, Long taskId, String deviceId) {
// 使用LambdaQueryWrapperX构建查询条件，根据传入的参数动态添加查询条件
return selectOne(new LambdaQueryWrapperX<IotOtaUpgradeRecordDO>()
.eqIfPresent(IotOtaUpgradeRecordDO::getFirmwareId, firmwareId)
.eqIfPresent(IotOtaUpgradeRecordDO::getTaskId, taskId)
.eqIfPresent(IotOtaUpgradeRecordDO::getDeviceId, deviceId));
}
/**
* 获取OTA升级记录的数量
*
* @param taskId 任务ID，用于筛选特定任务的升级记录
* @param deviceName 设备名称，用于筛选特定设备的升级记录
* @param status 状态，用于筛选特定状态的升级记录
* @return 返回符合条件的OTA升级记录的数量
*/
Long getOtaUpgradeRecordCount(@Param("taskId") Long taskId,
@Param("deviceName") String deviceName,
@Param("status") Integer status);
/**
* 获取OTA升级记录的统计信息
*
* @param firmwareId 固件ID，用于筛选特定固件的升级记录
* @param status 状态，用于筛选特定状态的升级记录
* @return 返回符合条件的OTA升级记录的统计信息
*/
Long getOtaUpgradeRecordStatistics(@Param("firmwareId") Long firmwareId,
@Param("status") Integer status);
/**
* 根据分页查询条件获取IOT OTA升级记录的分页结果
*
* @param pageReqVO 分页查询请求参数，包含设备名称、任务ID等查询条件
* @return 返回分页查询结果，包含符合条件的IOT OTA升级记录列表
*/
default PageResult<IotOtaUpgradeRecordDO> selectUpgradeRecordPage(IotOtaUpgradeRecordPageReqVO pageReqVO) {
// 使用LambdaQueryWrapperX构建查询条件，并根据请求参数动态添加查询条件
return selectPage(pageReqVO, new LambdaQueryWrapperX<IotOtaUpgradeRecordDO>()
.likeIfPresent(IotOtaUpgradeRecordDO::getDeviceName, pageReqVO.getDeviceName()) // 如果设备名称存在，则添加模糊查询条件
.eqIfPresent(IotOtaUpgradeRecordDO::getTaskId, pageReqVO.getTaskId())); // 如果任务ID存在，则添加等值查询条件
}
/**
* 根据任务ID取消升级记录。
* 该方法通过任务ID查找状态为“待处理”的升级记录，并将其状态更新为“已取消”。
*
* @param taskId 任务ID，用于查找对应的升级记录。
*/
default void cancelUpgradeRecordByTaskId(Long taskId) {
// 使用LambdaUpdateWrapper构建更新条件，将状态为“待处理”的记录更新为“已取消”
update(new LambdaUpdateWrapper<IotOtaUpgradeRecordDO>()
.set(IotOtaUpgradeRecordDO::getStatus, IotOtaUpgradeRecordStatusEnum.CANCELED.getStatus())
.eq(IotOtaUpgradeRecordDO::getTaskId, taskId)
.eq(IotOtaUpgradeRecordDO::getStatus, IotOtaUpgradeRecordStatusEnum.PENDING.getStatus())
);
}
/**
* 根据状态查询符合条件的升级记录列表
* <p>
* 该函数使用LambdaQueryWrapperX构建查询条件，查询指定状态的升级记录。
*
* @param state 升级记录的状态，用于筛选符合条件的记录
* @return 返回符合指定状态的升级记录列表，类型为List<IotOtaUpgradeRecordDO>
*/
default List<IotOtaUpgradeRecordDO> selectUpgradeRecordListByState(Integer state) {
// 使用LambdaQueryWrapperX构建查询条件，根据状态查询符合条件的升级记录
return selectList(new LambdaQueryWrapperX<IotOtaUpgradeRecordDO>()
.eq(IotOtaUpgradeRecordDO::getStatus, state));
}
/**
* 更新升级记录状态
* <p>
* 该函数用于批量更新指定ID列表中的升级记录状态。通过传入的ID列表和状态值，使用LambdaUpdateWrapper构建更新条件，
* 并执行更新操作。
*
* @param ids 需要更新的升级记录ID列表，类型为List<Long>。传入的ID列表中的记录将被更新。
* @param status 要更新的状态值，类型为Integer。该值将被设置到符合条件的升级记录中。
*/
default void updateUpgradeRecordStatus(List<Long> ids, Integer status) {
// 使用LambdaUpdateWrapper构建更新条件，设置状态字段，并根据ID列表进行筛选
update(new LambdaUpdateWrapper<IotOtaUpgradeRecordDO>()
.set(IotOtaUpgradeRecordDO::getStatus, status)
.in(IotOtaUpgradeRecordDO::getId, ids)
);
}
/**
* 根据任务ID查询升级记录列表
* <p>
* 该函数通过任务ID查询符合条件的升级记录，并返回查询结果列表。
*
* @param taskId 任务ID，用于筛选升级记录
* @return 返回符合条件的升级记录列表，若未找到则返回空列表
*/
default List<IotOtaUpgradeRecordDO> selectUpgradeRecordListByTaskId(Long taskId) {
// 使用LambdaQueryWrapperX构建查询条件，根据任务ID查询符合条件的升级记录
return selectList(new LambdaQueryWrapperX<IotOtaUpgradeRecordDO>()
.eq(IotOtaUpgradeRecordDO::getTaskId, taskId));
}
}

59
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/dal/mysql/ota/IotOtaUpgradeTaskMapper.java Normal file
View File

@ -0,0 +1,59 @@
package cn.iocoder.yudao.module.iot.dal.mysql.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskPageReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* IotOtaUpgradeTaskMapper 接口用于操作 IotOtaUpgradeTaskDO 数据库表。
* 该接口继承自 BaseMapperX，提供了基本的数据库操作方法。
*/
@Mapper
public interface IotOtaUpgradeTaskMapper extends BaseMapperX<IotOtaUpgradeTaskDO> {
/**
* 根据固件ID和任务名称查询升级任务列表。
*
* @param firmwareId 固件ID，用于筛选升级任务
* @param name 任务名称，用于筛选升级任务
* @return 符合条件的升级任务列表
*/
default List<IotOtaUpgradeTaskDO> selectByFirmwareIdAndName(Long firmwareId, String name) {
return selectList(new LambdaQueryWrapperX<IotOtaUpgradeTaskDO>()
.eqIfPresent(IotOtaUpgradeTaskDO::getFirmwareId, firmwareId)
.eqIfPresent(IotOtaUpgradeTaskDO::getName, name));
}
/**
* 分页查询升级任务列表，支持根据固件ID和任务名称进行筛选。
*
* @param pageReqVO 分页查询请求对象，包含分页参数和筛选条件
* @return 分页结果，包含符合条件的升级任务列表
*/
default PageResult<IotOtaUpgradeTaskDO> selectUpgradeTaskPage(IotOtaUpgradeTaskPageReqVO pageReqVO) {
return selectPage(pageReqVO, new LambdaQueryWrapperX<IotOtaUpgradeTaskDO>()
.eqIfPresent(IotOtaUpgradeTaskDO::getFirmwareId, pageReqVO.getFirmwareId())
.likeIfPresent(IotOtaUpgradeTaskDO::getName, pageReqVO.getName()));
}
/**
* 根据任务状态查询升级任务列表
* <p>
* 该函数通过传入的任务状态，查询数据库中符合条件的升级任务列表。
*
* @param state 任务状态，用于筛选升级任务的状态值
* @return 返回符合条件的升级任务列表，列表中的每个元素为 IotOtaUpgradeTaskDO 对象
*/
default List<IotOtaUpgradeTaskDO> selectUpgradeTaskByState(Integer state) {
// 使用 LambdaQueryWrapperX 构建查询条件，筛选出状态等于指定值的升级任务
return selectList(new LambdaQueryWrapperX<IotOtaUpgradeTaskDO>()
.eq(IotOtaUpgradeTaskDO::getStatus, state));
}
}

34
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/job/ota/IotOtaUpgradeRecordJob.java Normal file
View File

@ -0,0 +1,34 @@
package cn.iocoder.yudao.module.iot.job.ota;
import cn.iocoder.yudao.framework.quartz.core.handler.JobHandler;
import cn.iocoder.yudao.framework.tenant.core.job.TenantJob;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeRecordDO;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum;
import cn.iocoder.yudao.module.iot.service.ota.IotOtaUpgradeRecordService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class IotOtaUpgradeRecordJob implements JobHandler {
@Resource
private IotOtaUpgradeRecordService upgradeRecordService;
@Override
@TenantJob
public String execute(String param) throws Exception {
// 1.查询待处理的升级记录
List<IotOtaUpgradeRecordDO> upgradeRecords = upgradeRecordService
.getUpgradeRecordListByState(IotOtaUpgradeRecordStatusEnum.PENDING.getStatus());
// TODO @芋艿 2.执行升级动作
// 3.最终，更新升级记录状态
List<Long> ids = upgradeRecords.stream().map(IotOtaUpgradeRecordDO::getId).toList();
upgradeRecordService.updateUpgradeRecordStatus(ids, IotOtaUpgradeRecordStatusEnum.PUSHED.getStatus());
return "";
}
}

71
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/job/ota/IotOtaUpgradeTaskJob.java Normal file
View File

@ -0,0 +1,71 @@
package cn.iocoder.yudao.module.iot.job.ota;
import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
import cn.iocoder.yudao.framework.quartz.core.handler.JobHandler;
import cn.iocoder.yudao.framework.tenant.core.job.TenantJob;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeRecordDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskStatusEnum;
import cn.iocoder.yudao.module.iot.service.ota.IotOtaUpgradeRecordService;
import cn.iocoder.yudao.module.iot.service.ota.IotOtaUpgradeTaskService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;
@Slf4j
@Component
public class IotOtaUpgradeTaskJob implements JobHandler {
@Resource
private IotOtaUpgradeTaskService upgradeTaskService;
@Resource
private IotOtaUpgradeRecordService upgradeRecordService;
@Override
@TenantJob
public String execute(String param) throws Exception {
// 1.这个任务主要是为了检查并更新升级任务的状态
List<IotOtaUpgradeTaskDO> upgradeTasks = upgradeTaskService
.getUpgradeTaskByState(IotOtaUpgradeTaskStatusEnum.IN_PROGRESS.getStatus());
// 2.遍历并且确定升级任务的状态
upgradeTasks.forEach(this::checkUpgradeTaskState);
// TODO @芋艿: 其他的一些业务逻辑
return "";
}
private void checkUpgradeTaskState(IotOtaUpgradeTaskDO upgradeTask) {
// 1.查询任务所有的升级记录
List<IotOtaUpgradeRecordDO> upgradeRecords =
upgradeRecordService.getUpgradeRecordListByTaskId(upgradeTask.getId());
if (upgradeRecords.stream().anyMatch(upgradeRecord ->
ObjectUtils.equalsAny(upgradeRecord.getStatus(),
IotOtaUpgradeRecordStatusEnum.PENDING.getStatus(),
IotOtaUpgradeRecordStatusEnum.PUSHED.getStatus(),
IotOtaUpgradeRecordStatusEnum.UPGRADING.getStatus()))) {
// 如果存在正在升级的升级记录，则升级任务的状态为进行中
log.debug("升级任务 {} 状态为进行中", upgradeTask.getId());
} else if (upgradeRecords.stream().allMatch(upgradeRecord ->
ObjectUtils.equalsAny(upgradeRecord.getStatus(),
IotOtaUpgradeRecordStatusEnum.SUCCESS.getStatus()))) {
// 如果全部升级成功，则升级任务的状态为已完成
upgradeTaskService.updateUpgradeTaskStatus(upgradeTask.getId(),
IotOtaUpgradeTaskStatusEnum.COMPLETED.getStatus());
} else if (upgradeRecords.stream().noneMatch(upgradeRecord ->
ObjectUtils.equalsAny(upgradeRecord.getStatus(),
IotOtaUpgradeRecordStatusEnum.PENDING.getStatus(),
IotOtaUpgradeRecordStatusEnum.PUSHED.getStatus(),
IotOtaUpgradeRecordStatusEnum.UPGRADING.getStatus())) &&
upgradeRecords.stream().anyMatch(upgradeRecord ->
ObjectUtils.equalsAny(upgradeRecord.getStatus(),
IotOtaUpgradeRecordStatusEnum.FAILURE.getStatus(),
IotOtaUpgradeRecordStatusEnum.CANCELED.getStatus()))) {
// 如果全部升级完毕，但是存在升级失败或者取消的升级记录，则升级任务的状态为失败
upgradeTaskService.updateUpgradeTaskStatus(upgradeTask.getId(),
IotOtaUpgradeTaskStatusEnum.INCOMPLETE.getStatus());
}
}
}

23
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceService.java
View File

@ -34,8 +34,8 @@ public interface IotDeviceService {
* @return 设备
*/
IotDeviceDO createDevice(@NotEmpty(message = "产品标识不能为空") String productKey,
@NotEmpty(message = "设备名称不能为空") String deviceName,
Long gatewayId);
@NotEmpty(message = "设备名称不能为空") String deviceName,
Long gatewayId);
/**
* 更新设备
@ -45,6 +45,7 @@ public interface IotDeviceService {
void updateDevice(@Valid IotDeviceSaveReqVO updateReqVO);
// TODO @芋艿：先这么实现。未来看情况，要不要自己实现
/**
* 更新设备的所属网关
*
@ -132,6 +133,22 @@ public interface IotDeviceService {
*/
List<IotDeviceDO> getDeviceListByState(Integer state);
/**
* 根据产品ID获取设备列表
*
* @param productId 产品ID，用于查询特定产品的设备列表
* @return 返回与指定产品ID关联的设备列表，列表中的每个元素为IotDeviceDO对象
*/
List<IotDeviceDO> getDeviceListByProductId(Long productId);
/**
* 根据设备ID列表获取设备信息列表
*
* @param deviceIdList 设备ID列表，包含需要查询的设备ID
* @return 返回与设备ID列表对应的设备信息列表，列表中的每个元素为IotDeviceDO对象
*/
List<IotDeviceDO> getDeviceListByIdList(List<Long> deviceIdList);
/**
* 基于产品编号，获得设备数量
*
@ -150,7 +167,7 @@ public interface IotDeviceService {
/**
* 【缓存】根据产品 key 和设备名称，获得设备信息
*
* <p>
* 注意：该方法会忽略租户信息，所以调用时，需要确认会不会有跨租户访问的风险！！！
*
* @param productKey 产品 key

12
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/device/IotDeviceServiceImpl.java
View File

@ -101,7 +101,7 @@ public class IotDeviceServiceImpl implements IotDeviceService {
}
private void validateCreateDeviceParam(String productKey, String deviceName, String deviceKey,
Long gatewayId, IotProductDO product) {
Long gatewayId, IotProductDO product) {
TenantUtils.executeIgnore(() -> {
// 校验设备名称在同一产品下是否唯一
if (deviceMapper.selectByProductKeyAndDeviceName(productKey, deviceName) != null) {
@ -259,6 +259,16 @@ public class IotDeviceServiceImpl implements IotDeviceService {
return deviceMapper.selectListByState(state);
}
@Override
public List<IotDeviceDO> getDeviceListByProductId(Long productId) {
return deviceMapper.selectListByProductId(productId);
}
@Override
public List<IotDeviceDO> getDeviceListByIdList(List<Long> deviceIdList) {
return deviceMapper.selectByIds(deviceIdList);
}
@Override
public void updateDeviceState(Long id, Integer state) {
// 1. 校验存在

57
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/IotOtaFirmwareService.java Normal file
View File

@ -0,0 +1,57 @@
package cn.iocoder.yudao.module.iot.service.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareCreateReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwarePageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareUpdateReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import jakarta.validation.Valid;
/**
* OTA固件管理服务接口
* 提供OTA固件的创建、更新和查询等功能
*/
public interface IotOtaFirmwareService {
/**
* 创建OTA固件
*
* @param saveReqVO OTA固件保存请求对象，包含固件的相关信息
* @return 返回新创建的固件的ID
*/
Long createOtaFirmware(@Valid IotOtaFirmwareCreateReqVO saveReqVO);
/**
* 更新OTA固件信息
*
* @param updateReqVO OTA固件保存请求对象，包含需要更新的固件信息
*/
void updateOtaFirmware(@Valid IotOtaFirmwareUpdateReqVO updateReqVO);
/**
* 根据ID获取OTA固件信息
*
* @param id OTA固件的唯一标识符
* @return 返回OTA固件的详细信息对象
*/
IotOtaFirmwareDO getOtaFirmware(Long id);
/**
* 分页查询OTA固件信息
*
* @param pageReqVO 包含分页查询条件的请求对象
* @return 返回分页查询结果，包含固件信息列表和分页信息
*/
PageResult<IotOtaFirmwareDO> getOtaFirmwarePage(@Valid IotOtaFirmwarePageReqVO pageReqVO);
/**
* 验证物联网OTA固件是否存在
*
* @param id 固件的唯一标识符
* 该方法用于检查系统中是否存在与给定ID关联的物联网OTA固件信息
* 主要目的是在进行固件更新操作前，确保目标固件已经存在并可以被访问
* 如果固件不存在，该方法可能抛出异常或返回错误信息，具体行为未定义
*/
IotOtaFirmwareDO validateFirmwareExists(Long id);
}

88
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/IotOtaFirmwareServiceImpl.java Normal file
View File

@ -0,0 +1,88 @@
package cn.iocoder.yudao.module.iot.service.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareCreateReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwarePageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.firmware.IotOtaFirmwareUpdateReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.dal.mysql.ota.IotOtaFirmwareMapper;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.List;
import java.util.Objects;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.OTA_FIRMWARE_NOT_EXISTS;
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.OTA_FIRMWARE_PRODUCT_VERSION_DUPLICATE;
@Slf4j
@Service
@Validated
public class IotOtaFirmwareServiceImpl implements IotOtaFirmwareService {
@Resource
private IotOtaFirmwareMapper otaFirmwareMapper;
@Override
public Long createOtaFirmware(IotOtaFirmwareCreateReqVO saveReqVO) {
// 1.校验固件产品id+版本号不能重复
validateProductAndVersionDuplicate(saveReqVO.getProductId(), saveReqVO.getVersion());
// 2.转化数据格式，准备存储到数据库中
IotOtaFirmwareDO otaFirmware = BeanUtils.toBean(saveReqVO, IotOtaFirmwareDO.class);
otaFirmwareMapper.insert(otaFirmware);
return otaFirmware.getId();
}
@Override
public void updateOtaFirmware(IotOtaFirmwareUpdateReqVO updateReqVO) {
// 1.1. 校验存在
validateFirmwareExists(updateReqVO.getId());
// 2. 更新数据
IotOtaFirmwareDO updateObj = BeanUtils.toBean(updateReqVO, IotOtaFirmwareDO.class);
otaFirmwareMapper.updateById(updateObj);
}
@Override
public IotOtaFirmwareDO getOtaFirmware(Long id) {
return otaFirmwareMapper.selectById(id);
}
@Override
public PageResult<IotOtaFirmwareDO> getOtaFirmwarePage(IotOtaFirmwarePageReqVO pageReqVO) {
return otaFirmwareMapper.selectPage(pageReqVO);
}
@Override
public IotOtaFirmwareDO validateFirmwareExists(Long id) {
IotOtaFirmwareDO otaFirmware = otaFirmwareMapper.selectById(id);
if (otaFirmware == null) {
throw exception(OTA_FIRMWARE_NOT_EXISTS);
}
return otaFirmware;
}
/**
* 验证产品和版本号是否重复
* <p>
* 该方法用于确保在系统中不存在具有相同产品ID和版本号的固件条目
* 它通过调用otaFirmwareMapper的selectByProductIdAndVersion方法来查询数据库中是否存在匹配的产品ID和版本号的固件信息
* 如果查询结果非空且不为null，则抛出异常，提示固件信息已存在，从而避免数据重复
*
* @param productId 产品ID，用于数据库查询
* @param version 版本号，用于数据库查询
* @throws cn.iocoder.yudao.framework.common.exception.ServiceException，则抛出异常，提示固件信息已存在
*/
private void validateProductAndVersionDuplicate(String productId, String version) {
// 查询数据库中是否存在具有相同产品ID和版本号的固件信息
List<IotOtaFirmwareDO> list = otaFirmwareMapper.selectByProductIdAndVersion(productId, version);
// 如果查询结果非空且不为null，则抛出异常，提示固件信息已存在
if (Objects.nonNull(list) && !list.isEmpty()) {
throw exception(OTA_FIRMWARE_PRODUCT_VERSION_DUPLICATE);
}
}
}

112
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/IotOtaUpgradeRecordService.java Normal file
View File

@ -0,0 +1,112 @@
package cn.iocoder.yudao.module.iot.service.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record.IotOtaUpgradeRecordPageReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeRecordDO;
import cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record.IotOtaUpgradeRecordCreateReqBO;
import cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record.IotOtaUpgradeRecordUpdateReqBO;
import jakarta.validation.Valid;
import java.util.List;
import java.util.Map;
/**
* IotOtaUpgradeRecordService 接口定义了与物联网设备OTA升级记录相关的操作。
* 该接口提供了创建、更新、查询、统计和重试升级记录的功能。
*/
public interface IotOtaUpgradeRecordService {
/**
* 批量创建物联网OTA升级记录
* <p>
* 该函数用于处理一组物联网OTA升级记录的创建请求，并将这些记录批量保存到系统中。
*
* @param saveList 包含多个物联网OTA升级记录创建请求的列表，每个请求对象都经过校验（@Valid注解确保）
* 列表中的每个元素都是IotOtaUpgradeRecordCreateReqBO类型的对象，表示一个独立的升级记录创建请求。
*/
void createUpgradeRecordBatch(@Valid List<IotOtaUpgradeRecordCreateReqBO> saveList);
/**
* 更新现有的OTA升级记录。
*
* @param updateReqBO 包含更新升级记录所需信息的请求对象，必须经过验证。
*/
void updateUpgradeRecord(@Valid IotOtaUpgradeRecordUpdateReqBO updateReqBO);
/**
* 获取OTA升级记录的数量统计。
*
* @return 返回一个Map，其中键为状态码，值为对应状态的升级记录数量。
*/
Map<Integer, Long> getOtaUpgradeRecordCount(@Valid IotOtaUpgradeRecordPageReqVO pageReqVO);
/**
* 获取OTA升级记录的统计信息。
*
* @return 返回一个Map，其中键为状态码，值为对应状态的升级记录统计信息。
*/
Map<Integer, Long> getOtaUpgradeRecordStatistics(Long firmwareId);
/**
* 重试指定的OTA升级记录。
*
* @param id 需要重试的升级记录的ID。
*/
void retryUpgradeRecord(Long id);
/**
* 获取指定ID的OTA升级记录的详细信息。
*
* @param id 需要查询的升级记录的ID。
* @return 返回包含升级记录详细信息的响应对象。
*/
IotOtaUpgradeRecordDO getUpgradeRecord(Long id);
/**
* 分页查询OTA升级记录。
*
* @param pageReqVO 包含分页查询条件的请求对象，必须经过验证。
* @return 返回包含分页查询结果的响应对象。
*/
PageResult<IotOtaUpgradeRecordDO> getUpgradeRecordPage(
@Valid IotOtaUpgradeRecordPageReqVO pageReqVO);
/**
* 根据任务ID取消升级记录。
* <p>
* 该函数用于根据给定的任务ID，取消与该任务相关的升级记录。通常用于在任务执行失败或用户手动取消时，
* 清理或标记相关的升级记录为取消状态。
*
* @param taskId 要取消升级记录的任务ID。该ID唯一标识一个任务，通常由任务管理系统生成。
*/
void cancelUpgradeRecordByTaskId(Long taskId);
/**
* 根据升级状态获取升级记录列表
*
* @param state 升级状态，用于筛选符合条件的升级记录
* @return 返回符合指定状态的升级记录列表，列表中的元素为 {@link IotOtaUpgradeRecordDO} 对象
*/
List<IotOtaUpgradeRecordDO> getUpgradeRecordListByState(Integer state);
/**
* 更新升级记录的状态。
* <p>
* 该函数用于批量更新指定升级记录的状态。通过传入的ID列表和状态值，将对应的升级记录的状态更新为指定的值。
*
* @param ids 需要更新状态的升级记录的ID列表。列表中的每个元素代表一个升级记录的ID。
* @param status 要更新的状态值。该值应为有效的状态标识符，通常为整数类型。
*/
void updateUpgradeRecordStatus(List<Long> ids, Integer status);
/**
* 根据任务ID获取升级记录列表
* <p>
* 该函数通过给定的任务ID，查询并返回与该任务相关的所有升级记录。
*
* @param taskId 任务ID，用于指定需要查询的任务
* @return 返回一个包含升级记录的列表，列表中的每个元素为IotOtaUpgradeRecordDO对象
*/
List<IotOtaUpgradeRecordDO> getUpgradeRecordListByTaskId(Long taskId);
}

207
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/IotOtaUpgradeRecordServiceImpl.java Normal file
View File

@ -0,0 +1,207 @@
package cn.iocoder.yudao.module.iot.service.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.framework.common.util.object.ObjectUtils;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.record.IotOtaUpgradeRecordPageReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeRecordDO;
import cn.iocoder.yudao.module.iot.dal.mysql.ota.IotOtaUpgradeRecordMapper;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum;
import cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record.IotOtaUpgradeRecordCreateReqBO;
import cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record.IotOtaUpgradeRecordUpdateReqBO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import java.util.List;
import java.util.Map;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.*;
@Slf4j
@Service
@Validated
public class IotOtaUpgradeRecordServiceImpl implements IotOtaUpgradeRecordService {
@Resource
private IotOtaUpgradeRecordMapper upgradeRecordMapper;
@Override
public void createUpgradeRecordBatch(List<IotOtaUpgradeRecordCreateReqBO> saveList) {
// 1. 批量校验参数信息
saveList.forEach(saveBO -> validateUpgradeRecordDuplicate(saveBO.getFirmwareId(), saveBO.getTaskId(), saveBO.getDeviceId()));
// 2.将数据转化成数据库存储的格式
List<IotOtaUpgradeRecordDO> upgradeRecords = BeanUtils.toBean(saveList, IotOtaUpgradeRecordDO.class);
// 3.将数据批量存储到数据库里
upgradeRecordMapper.insertBatch(upgradeRecords);
}
@Override
@Transactional
public void updateUpgradeRecord(IotOtaUpgradeRecordUpdateReqBO updateReqBO) {
// 1.校验升级记录信息是否存在
validateUpgradeRecordExists(updateReqBO.getId());
// 2.将数据转化成数据库存储的格式
IotOtaUpgradeRecordDO updateRecord = BeanUtils.toBean(updateReqBO, IotOtaUpgradeRecordDO.class);
upgradeRecordMapper.updateById(updateRecord);
// TODO @芋艿: 更新升级记录触发的其他Action
}
/**
* 获取OTA升级记录的数量统计。
* 该方法根据传入的查询条件，统计不同状态的OTA升级记录数量，并返回一个包含各状态数量的映射。
*
* @param pageReqVO 包含查询条件的请求对象，主要包括任务ID和设备名称等信息。
* @return 返回一个Map，其中键为状态常量，值为对应状态的记录数量。
*/
@Override
@Transactional
public Map<Integer, Long> getOtaUpgradeRecordCount(IotOtaUpgradeRecordPageReqVO pageReqVO) {
// 分别查询不同状态的OTA升级记录数量
Long pending = upgradeRecordMapper.getOtaUpgradeRecordCount(pageReqVO.getTaskId(), pageReqVO.getDeviceName(), IotOtaUpgradeRecordStatusEnum.PENDING.getStatus());
Long pushed = upgradeRecordMapper.getOtaUpgradeRecordCount(pageReqVO.getTaskId(), pageReqVO.getDeviceName(), IotOtaUpgradeRecordStatusEnum.PUSHED.getStatus());
Long upgrading = upgradeRecordMapper.getOtaUpgradeRecordCount(pageReqVO.getTaskId(), pageReqVO.getDeviceName(), IotOtaUpgradeRecordStatusEnum.UPGRADING.getStatus());
Long success = upgradeRecordMapper.getOtaUpgradeRecordCount(pageReqVO.getTaskId(), pageReqVO.getDeviceName(), IotOtaUpgradeRecordStatusEnum.SUCCESS.getStatus());
Long failure = upgradeRecordMapper.getOtaUpgradeRecordCount(pageReqVO.getTaskId(), pageReqVO.getDeviceName(), IotOtaUpgradeRecordStatusEnum.FAILURE.getStatus());
Long canceled = upgradeRecordMapper.getOtaUpgradeRecordCount(pageReqVO.getTaskId(), pageReqVO.getDeviceName(), IotOtaUpgradeRecordStatusEnum.CANCELED.getStatus());
// 将各状态的数量封装到Map中返回
return Map.of(IotOtaUpgradeRecordPageReqVO.PENDING, pending,
IotOtaUpgradeRecordPageReqVO.PUSHED, pushed,
IotOtaUpgradeRecordPageReqVO.UPGRADING, upgrading,
IotOtaUpgradeRecordPageReqVO.SUCCESS, success,
IotOtaUpgradeRecordPageReqVO.FAILURE, failure,
IotOtaUpgradeRecordPageReqVO.CANCELED, canceled);
}
/**
* 获取指定固件ID的OTA升级记录统计信息。
* 该方法通过查询数据库，统计不同状态的OTA升级记录数量，并返回一个包含各状态数量的映射。
*
* @param firmwareId 固件ID，用于指定需要统计的固件升级记录。
* @return 返回一个Map，其中键为升级记录状态（如PENDING、PUSHED等），值为对应状态的记录数量。
*/
@Override
@Transactional
public Map<Integer, Long> getOtaUpgradeRecordStatistics(Long firmwareId) {
// 查询并统计不同状态的OTA升级记录数量
Long pending = upgradeRecordMapper.getOtaUpgradeRecordStatistics(firmwareId, IotOtaUpgradeRecordStatusEnum.PENDING.getStatus());
Long pushed = upgradeRecordMapper.getOtaUpgradeRecordStatistics(firmwareId, IotOtaUpgradeRecordStatusEnum.PUSHED.getStatus());
Long upgrading = upgradeRecordMapper.getOtaUpgradeRecordStatistics(firmwareId, IotOtaUpgradeRecordStatusEnum.UPGRADING.getStatus());
Long success = upgradeRecordMapper.getOtaUpgradeRecordStatistics(firmwareId, IotOtaUpgradeRecordStatusEnum.SUCCESS.getStatus());
Long failure = upgradeRecordMapper.getOtaUpgradeRecordStatistics(firmwareId, IotOtaUpgradeRecordStatusEnum.FAILURE.getStatus());
Long canceled = upgradeRecordMapper.getOtaUpgradeRecordStatistics(firmwareId, IotOtaUpgradeRecordStatusEnum.CANCELED.getStatus());
// 将统计结果封装为Map并返回
return Map.of(IotOtaUpgradeRecordPageReqVO.PENDING, pending,
IotOtaUpgradeRecordPageReqVO.PUSHED, pushed,
IotOtaUpgradeRecordPageReqVO.UPGRADING, upgrading,
IotOtaUpgradeRecordPageReqVO.SUCCESS, success,
IotOtaUpgradeRecordPageReqVO.FAILURE, failure,
IotOtaUpgradeRecordPageReqVO.CANCELED, canceled);
}
@Override
public void retryUpgradeRecord(Long id) {
// 1.1.校验升级记录信息是否存在
IotOtaUpgradeRecordDO upgradeRecord = validateUpgradeRecordExists(id);
// 1.2.校验升级记录是否可以重新升级
validateUpgradeRecordCanRetry(upgradeRecord);
// 2.将一些数据重置，这样定时任务轮询就可以重启任务
upgradeRecordMapper.updateById(new IotOtaUpgradeRecordDO()
.setId(upgradeRecord.getId()).setProgress(0)
.setStatus(IotOtaUpgradeRecordStatusEnum.PENDING.getStatus()));
// TODO @芋艿: 重试升级记录触发的其他Action
// TODO 如果一个升级记录被取消或者已经执行失败，重试成功，是否会对升级任务的状态有影响？
}
@Override
public IotOtaUpgradeRecordDO getUpgradeRecord(Long id) {
return upgradeRecordMapper.selectById(id);
}
@Override
public PageResult<IotOtaUpgradeRecordDO> getUpgradeRecordPage(IotOtaUpgradeRecordPageReqVO pageReqVO) {
return upgradeRecordMapper.selectUpgradeRecordPage(pageReqVO);
}
@Override
public void cancelUpgradeRecordByTaskId(Long taskId) {
// 暂定只有待推送的升级记录可以取消
upgradeRecordMapper.cancelUpgradeRecordByTaskId(taskId);
}
@Override
public List<IotOtaUpgradeRecordDO> getUpgradeRecordListByState(Integer state) {
return upgradeRecordMapper.selectUpgradeRecordListByState(state);
}
@Override
public void updateUpgradeRecordStatus(List<Long> ids, Integer status) {
upgradeRecordMapper.updateUpgradeRecordStatus(ids, status);
}
@Override
public List<IotOtaUpgradeRecordDO> getUpgradeRecordListByTaskId(Long taskId) {
return upgradeRecordMapper.selectUpgradeRecordListByTaskId(taskId);
}
/**
* 验证指定的升级记录是否存在。
* <p>
* 该函数通过给定的ID查询升级记录，如果查询结果为空，则抛出异常，表示升级记录不存在。
*
* @param id 升级记录的唯一标识符，类型为Long。
* @throws cn.iocoder.yudao.framework.common.exception.ServiceException，则抛出异常，异常类型为OTA_UPGRADE_RECORD_NOT_EXISTS。
*/
private IotOtaUpgradeRecordDO validateUpgradeRecordExists(Long id) {
// 根据ID查询升级记录
IotOtaUpgradeRecordDO upgradeRecord = upgradeRecordMapper.selectById(id);
// 如果查询结果为空，抛出异常
if (upgradeRecord == null) {
throw exception(OTA_UPGRADE_RECORD_NOT_EXISTS);
}
return upgradeRecord;
}
/**
* 验证固件升级记录是否存在。
* <p>
* 该函数通过给定的固件ID、任务ID和设备ID查询升级记录，如果查询结果为空，则抛出异常。
*
* @param firmwareId 固件ID，用于标识特定的固件版本
* @param taskId 任务ID，用于标识特定的升级任务
* @param deviceId 设备ID，用于标识特定的设备
* @throws cn.iocoder.yudao.framework.common.exception.ServiceException，则抛出OTA_UPGRADE_RECORD_NOT_EXISTS异常
*/
private void validateUpgradeRecordDuplicate(Long firmwareId, Long taskId, String deviceId) {
// 根据条件查询升级记录
IotOtaUpgradeRecordDO upgradeRecord = upgradeRecordMapper.selectByConditions(firmwareId, taskId, deviceId);
// 如果查询结果为空，抛出异常
if (upgradeRecord != null) {
throw exception(OTA_UPGRADE_RECORD_DUPLICATE);
}
}
/**
* 验证升级记录是否可以重试。
* <p>
* 该方法用于检查给定的升级记录是否处于允许重试的状态。如果升级记录的状态为
* PENDING、PUSHED 或 UPGRADING，则抛出异常，表示不允许重试。
*
* @param upgradeRecord 需要验证的升级记录对象，类型为 IotOtaUpgradeRecordDO
* @throws cn.iocoder.yudao.framework.common.exception.ServiceException，则抛出 OTA_UPGRADE_RECORD_CANNOT_RETRY 异常
*/
private void validateUpgradeRecordCanRetry(IotOtaUpgradeRecordDO upgradeRecord) {
// 检查升级记录的状态是否为 PENDING、PUSHED 或 UPGRADING
if (ObjectUtils.equalsAny(upgradeRecord.getStatus(),
IotOtaUpgradeRecordStatusEnum.PENDING.getStatus(),
IotOtaUpgradeRecordStatusEnum.PUSHED.getStatus(),
IotOtaUpgradeRecordStatusEnum.UPGRADING.getStatus())) {
// 如果升级记录处于上述状态之一，则抛出异常，表示不允许重试
throw exception(OTA_UPGRADE_RECORD_CANNOT_RETRY);
}
}
}

67
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/IotOtaUpgradeTaskService.java Normal file
View File

@ -0,0 +1,67 @@
package cn.iocoder.yudao.module.iot.service.ota;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskPageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskSaveReqVO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import jakarta.validation.Valid;
import java.util.List;
/**
* IoT OTA升级任务服务接口
* 提供OTA升级任务的创建、取消和查询功能
*/
public interface IotOtaUpgradeTaskService {
/**
* 创建OTA升级任务
*
* @param createReqVO OTA升级任务的创建请求对象，包含创建任务所需的信息
* @return 创建成功的OTA升级任务的ID
*/
Long createUpgradeTask(@Valid IotOtaUpgradeTaskSaveReqVO createReqVO);
/**
* 取消OTA升级任务
*
* @param id 要取消的OTA升级任务的ID
*/
void cancelUpgradeTask(Long id);
/**
* 根据ID获取OTA升级任务的详细信息
*
* @param id OTA升级任务的ID
* @return OTA升级任务的详细信息对象
*/
IotOtaUpgradeTaskDO getUpgradeTask(Long id);
/**
* 分页查询OTA升级任务
*
* @param pageReqVO OTA升级任务的分页查询请求对象，包含查询条件和分页信息
* @return 分页查询结果，包含OTA升级任务列表和总记录数
*/
PageResult<IotOtaUpgradeTaskDO> getUpgradeTaskPage(@Valid IotOtaUpgradeTaskPageReqVO pageReqVO);
/**
* 根据任务状态获取升级任务列表
*
* @param state 任务状态，用于筛选符合条件的升级任务
* @return 返回符合指定状态的升级任务列表，列表中的元素为 IotOtaUpgradeTaskDO 对象
*/
List<IotOtaUpgradeTaskDO> getUpgradeTaskByState(Integer state);
/**
* 更新升级任务的状态。
* <p>
* 该函数用于根据任务ID更新指定升级任务的状态。通常用于在任务执行过程中
* 更新任务的状态，例如从“进行中”变为“已完成”或“失败”。
*
* @param id 升级任务的唯一标识符，类型为Long。不能为null。
* @param status 要更新的任务状态，类型为Integer。通常表示任务的状态码，如0表示未开始，1表示进行中，2表示已完成等。
*/
void updateUpgradeTaskStatus(Long id, Integer status);
}

236
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/IotOtaUpgradeTaskServiceImpl.java Normal file
View File

@ -0,0 +1,236 @@
package cn.iocoder.yudao.module.iot.service.ota;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskPageReqVO;
import cn.iocoder.yudao.module.iot.controller.admin.ota.vo.upgrade.task.IotOtaUpgradeTaskSaveReqVO;
import cn.iocoder.yudao.module.iot.convert.ota.IotOtaUpgradeRecordConvert;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import cn.iocoder.yudao.module.iot.dal.mysql.ota.IotOtaUpgradeTaskMapper;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskScopeEnum;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeTaskStatusEnum;
import cn.iocoder.yudao.module.iot.service.device.IotDeviceService;
import cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record.IotOtaUpgradeRecordCreateReqBO;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import java.util.List;
import java.util.Objects;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.*;
@Slf4j
@Service
@Validated
public class IotOtaUpgradeTaskServiceImpl implements IotOtaUpgradeTaskService {
@Resource
private IotOtaUpgradeTaskMapper upgradeTaskMapper;
@Lazy
@Resource
private IotDeviceService deviceService;
@Lazy
@Resource
private IotOtaFirmwareService firmwareService;
@Lazy
@Resource
private IotOtaUpgradeRecordService upgradeRecordService;
@Override
@Transactional(rollbackFor = Exception.class)
public Long createUpgradeTask(IotOtaUpgradeTaskSaveReqVO createReqVO) {
// 1.1.校验同一固件的升级任务名称不重复
validateFirmwareTaskDuplicate(createReqVO.getFirmwareId(), createReqVO.getName());
// 1.2.校验固件信息是否存在
IotOtaFirmwareDO firmware = firmwareService.validateFirmwareExists(createReqVO.getFirmwareId());
// 1.3.校验升级范围=2(指定设备时),deviceIds deviceNames不为空并且长度相等
validateScopeAndDevice(createReqVO.getScope(), createReqVO.getDeviceIds(), createReqVO.getDeviceNames());
// 2.初始化OTA升级任务信息
IotOtaUpgradeTaskDO upgradeTask = initUpgradeTask(createReqVO, firmware.getProductId());
// 3.保存OTA升级任务信息到数据库
upgradeTaskMapper.insert(upgradeTask);
// 4.生成设备升级记录信息并存储，等待定时任务轮询
List<IotOtaUpgradeRecordCreateReqBO> upgradeRecordList = initUpgradeRecordList(upgradeTask, firmware, createReqVO.getDeviceIds());
upgradeRecordService.createUpgradeRecordBatch(upgradeRecordList);
// TODO @芋艿: 创建任务触发的其他Action
return upgradeTask.getId();
}
@Override
@Transactional(rollbackFor = Exception.class)
public void cancelUpgradeTask(Long id) {
// 1.1.校验升级任务是否存在
IotOtaUpgradeTaskDO upgradeTask = validateUpgradeTaskExists(id);
// 1.2.校验升级任务是否可以取消
validateUpgradeTaskCanCancel(upgradeTask);
// 2.更新OTA升级任务状态为已取消
upgradeTaskMapper.updateById(IotOtaUpgradeTaskDO.builder()
.id(id).status(IotOtaUpgradeTaskStatusEnum.CANCELED.getStatus())
.build());
// 3.更新OTA升级记录状态为已取消
upgradeRecordService.cancelUpgradeRecordByTaskId(id);
// TODO @芋艿: 取消任务触发的其他Action
}
@Override
public IotOtaUpgradeTaskDO getUpgradeTask(Long id) {
return upgradeTaskMapper.selectById(id);
}
@Override
public PageResult<IotOtaUpgradeTaskDO> getUpgradeTaskPage(IotOtaUpgradeTaskPageReqVO pageReqVO) {
return upgradeTaskMapper.selectUpgradeTaskPage(pageReqVO);
}
@Override
public List<IotOtaUpgradeTaskDO> getUpgradeTaskByState(Integer state) {
return upgradeTaskMapper.selectUpgradeTaskByState(state);
}
@Override
public void updateUpgradeTaskStatus(Long id, Integer status) {
upgradeTaskMapper.updateById(IotOtaUpgradeTaskDO.builder()
.id(id).status(status)
.build());
}
/**
* 校验固件升级任务是否重复
* <p>
* 该方法用于检查给定固件ID和任务名称组合是否已存在于数据库中，如果存在则抛出异常，
* 表示任务名称对于该固件而言是重复的此检查确保用户不能创建具有相同名称的任务，
* 从而避免数据重复和混淆
*
* @param firmwareId 固件的唯一标识符，用于区分不同的固件
* @param taskName 升级任务的名称，用于与固件ID一起检查重复性
* @throws cn.iocoder.yudao.framework.common.exception.ServerException 则抛出预定义的异常
*/
private void validateFirmwareTaskDuplicate(Long firmwareId, String taskName) {
// 查询数据库中是否有相同固件ID和任务名称的升级任务存在
List<IotOtaUpgradeTaskDO> upgradeTaskList = upgradeTaskMapper.selectByFirmwareIdAndName(firmwareId, taskName);
// 如果查询结果不为空，说明存在重复的任务名称，抛出异常
if (CollUtil.isNotEmpty(upgradeTaskList)) {
throw exception(OTA_UPGRADE_TASK_NAME_DUPLICATE);
}
}
/**
* 验证升级任务的范围和设备参数是否有效
* 当选择特定设备进行升级时，确保提供的设备ID和设备名称列表有效且对应
*
* @param scope 升级任务的范围，表示是选择特定设备还是其他范围
* @param deviceIds 设备ID列表，用于标识参与升级的设备
* @param deviceNames 设备名称列表，与设备ID列表对应
*/
private void validateScopeAndDevice(Integer scope, List<Long> deviceIds, List<String> deviceNames) {
// 当升级任务范围为选择特定设备时
if (Objects.equals(scope, IotOtaUpgradeTaskScopeEnum.SELECT.getScope())) {
// 检查设备ID列表和设备名称列表是否为空或长度不一致，若不符合要求，则抛出异常
if (CollUtil.isEmpty(deviceIds) || CollUtil.isEmpty(deviceNames) || deviceIds.size() != deviceNames.size()) {
throw exception(OTA_UPGRADE_TASK_PARAMS_INVALID);
}
}
}
/**
* 验证升级任务是否存在
* <p>
* 通过查询数据库来验证给定ID的升级任务是否存在此方法主要用于确保后续操作所针对的升级任务是有效的
*
* @param id 升级任务的唯一标识符如果为null或数据库中不存在对应的记录，则认为任务不存在
* @throws cn.iocoder.yudao.framework.common.exception.ServiceException 如果升级任务不存在，则抛出异常提示任务不存在
*/
private IotOtaUpgradeTaskDO validateUpgradeTaskExists(Long id) {
// 查询数据库中是否有相同固件ID和任务名称的升级任务存在
IotOtaUpgradeTaskDO upgradeTask = upgradeTaskMapper.selectById(id);
// 如果查询结果不为空，说明存在重复的任务名称，抛出异常
if (Objects.isNull(upgradeTask)) {
throw exception(OTA_UPGRADE_TASK_NOT_EXISTS);
}
return upgradeTask;
}
/**
* 验证升级任务是否可以被取消
* <p>
* 此方法旨在确保只有当升级任务处于进行中状态时，才可以执行取消操作
* 它通过比较任务的当前状态与预定义的进行中状态来判断是否允许取消操作
* 如果任务状态不符合条件，则抛出异常，表明该任务无法取消
*
* @param upgradeTask 待验证的升级任务对象，包含任务的详细信息，如状态等
* @throws cn.iocoder.yudao.framework.common.exception.ServiceException 如果任务状态不是进行中，则抛出此异常，表明任务无法取消
*/
private void validateUpgradeTaskCanCancel(IotOtaUpgradeTaskDO upgradeTask) {
// 检查升级任务的状态是否为进行中，只有此状态下的任务才允许取消
if (!Objects.equals(upgradeTask.getStatus(), IotOtaUpgradeTaskStatusEnum.IN_PROGRESS.getStatus())) {
// 只有进行中的任务才可以取消
throw exception(OTA_UPGRADE_TASK_CANNOT_CANCEL);
}
}
/**
* 初始化升级任务
* <p>
* 根据请求参数创建升级任务对象，并根据选择的范围初始化设备数量
* 如果选择特定设备进行升级，则设备数量为所选设备的总数
* 如果选择全部设备进行升级，则设备数量为该固件对应产品下的所有设备总数
*
* @param createReqVO 升级任务保存请求对象，包含创建升级任务所需的信息
* @return 返回初始化后的升级任务对象
*/
private IotOtaUpgradeTaskDO initUpgradeTask(IotOtaUpgradeTaskSaveReqVO createReqVO, String productId) {
// 配置各项参数
IotOtaUpgradeTaskDO upgradeTask = IotOtaUpgradeTaskDO.builder()
.name(createReqVO.getName())
.description(createReqVO.getDescription())
.firmwareId(createReqVO.getFirmwareId())
.scope(createReqVO.getScope())
.deviceIds(createReqVO.getDeviceIds())
.deviceNames(createReqVO.getDeviceNames())
.deviceCount(Convert.toLong(CollUtil.size(createReqVO.getDeviceIds())))
.status(IotOtaUpgradeTaskStatusEnum.IN_PROGRESS.getStatus())
.build();
// 如果选择全选，则需要查询设备数量
if (Objects.equals(createReqVO.getScope(), IotOtaUpgradeTaskScopeEnum.ALL.getScope())) {
// 根据产品ID查询设备数量
Long deviceCount = deviceService.getDeviceCountByProductId(Convert.toLong(productId));
// 设置升级任务的设备数量
upgradeTask.setDeviceCount(deviceCount);
}
// 返回初始化后的升级任务对象
return upgradeTask;
}
/**
* 初始化升级记录列表
* <p>
* 根据升级任务的范围（选择设备或按产品ID）获取设备列表，并将其转换为升级记录请求对象列表。
*
* @param upgradeTask 升级任务对象，包含升级任务的相关信息
* @param firmware 固件对象，包含固件的相关信息
* @param deviceIds 设备ID列表，仅在升级任务范围为选择设备时使用
* @return 升级记录请求对象列表，包含每个设备的升级记录信息
*/
private List<IotOtaUpgradeRecordCreateReqBO> initUpgradeRecordList(IotOtaUpgradeTaskDO upgradeTask, IotOtaFirmwareDO firmware, List<Long> deviceIds) {
// 根据升级任务的范围确定设备列表
List<IotDeviceDO> deviceList;
if (Objects.equals(upgradeTask.getScope(), IotOtaUpgradeTaskScopeEnum.SELECT.getScope())) {
// 如果升级任务范围为选择设备，则根据设备ID列表获取设备信息
deviceList = deviceService.getDeviceListByIdList(deviceIds);
} else {
// 如果升级任务范围为按产品ID，则根据固件的产品ID获取设备信息
deviceList = deviceService.getDeviceListByProductId(Convert.toLong(firmware.getProductId()));
}
// 将升级任务、固件和设备列表转换为升级记录请求对象列表
return IotOtaUpgradeRecordConvert.INSTANCE.convertBOList(upgradeTask, firmware, deviceList);
}
}

1
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/bo/package-info.java Normal file
View File

@ -0,0 +1 @@
package cn.iocoder.yudao.module.iot.service.ota.bo;

1
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/bo/upgrade/package-info.java Normal file
View File

@ -0,0 +1 @@
package cn.iocoder.yudao.module.iot.service.ota.bo.upgrade;

79
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/bo/upgrade/record/IotOtaUpgradeRecordCreateReqBO.java Normal file
View File

@ -0,0 +1,79 @@
package cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaFirmwareDO;
import cn.iocoder.yudao.module.iot.dal.dataobject.ota.IotOtaUpgradeTaskDO;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class IotOtaUpgradeRecordCreateReqBO {
/**
* 固件编号
* <p>
* 关联 {@link IotOtaFirmwareDO#getId()}
*/
@NotNull(message = "固件编号不能为空")
private Long firmwareId;
/**
* 任务编号
* <p>
* 关联 {@link IotOtaUpgradeTaskDO#getId()}
*/
@NotNull(message = "任务编号不能为空")
private Long taskId;
/**
* 产品标识
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.product.IotProductDO#getId()}
*/
private String productKey;
/**
* 设备名称
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO#getId()}
*/
private String deviceName;
/**
* 设备编号
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceDO#getId()}
*/
@NotNull(message = "设备编号不能为空")
private String deviceId;
/**
* 来源的固件编号
* <p>
* 关联 {@link IotDeviceDO#getFirmwareId()}
*/
private Long fromFirmwareId;
/**
* 升级状态
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum}
*/
private Integer status;
/**
* 升级进度，百分比
*/
private Integer progress;
/**
* 升级进度描述
* <p>
* 注意，只记录设备最后一次的升级进度描述
* 如果想看历史记录，可以查看 {@link cn.iocoder.yudao.module.iot.dal.dataobject.device.IotDeviceLogDO} 设备日志
*/
private String description;
/**
* 升级开始时间
*/
private LocalDateTime startTime;
/**
* 升级结束时间
*/
private LocalDateTime endTime;
}

45
yudao-module-iot/yudao-module-iot-biz/src/main/java/cn/iocoder/yudao/module/iot/service/ota/bo/upgrade/record/IotOtaUpgradeRecordUpdateReqBO.java Normal file
View File

@ -0,0 +1,45 @@
package cn.iocoder.yudao.module.iot.service.ota.bo.upgrade.record;
import cn.iocoder.yudao.framework.common.validation.InEnum;
import cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import org.hibernate.validator.constraints.Range;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Data
public class IotOtaUpgradeRecordUpdateReqBO {
/**
* 升级记录编号
*/
@NotNull(message = "升级记录编号不能为空")
private Long id;
/**
* 升级状态
* <p>
* 关联 {@link cn.iocoder.yudao.module.iot.enums.ota.IotOtaUpgradeRecordStatusEnum}
*/
@InEnum(IotOtaUpgradeRecordStatusEnum.class)
private Integer status;
/**
* 升级进度，百分比
*/
@Range(min = 0, max = 100, message = "升级进度必须介于 0-100 之间")
private Integer progress;
/**
* 升级开始时间
*/
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime startTime;
/**
* 升级结束时间
*/
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime endTime;
}

22
yudao-module-iot/yudao-module-iot-biz/src/main/resources/mapper/ota/IotOtaUpgradeRecordMapper.xml Normal file
View File

@ -0,0 +1,22 @@
<?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="cn.iocoder.yudao.module.iot.dal.mysql.ota.IotOtaUpgradeRecordMapper">
<select id="getOtaUpgradeRecordCount" resultType="java.lang.Long">
select count(*)
from iot_ota_upgrade_record
where task_id = #{taskId}
and device_name like concat('%', #{deviceName}, '%')
and status = #{status}
</select>
<select id="getOtaUpgradeRecordStatistics" resultType="java.lang.Long">
select count(*)
from iot_ota_upgrade_record
where firmware_id = #{firmwareId}
and status = #{status}
</select>
</mapper>