Merge branch 'device-microservice'

# Conflicts:
#	src/main/java/com/ycwl/basic/integration/scenic/service/ScenicConfigIntegrationService.java
#	src/main/java/com/ycwl/basic/integration/scenic/service/ScenicIntegrationService.java

src/main/java/com/ycwl/basic/controller/mobile/AppClaimController.java

@@ -11,7 +11,7 @@ import com.ycwl.basic.pricing.service.ICouponService;
 import com.ycwl.basic.pricing.service.VoucherPrintService;
 import com.ycwl.basic.repository.FaceRepository;
 import com.ycwl.basic.repository.ScenicRepository;
-import com.ycwl.basic.util.ScenicConfigManager;
+import com.ycwl.basic.integration.common.manager.ScenicConfigManager;
 import com.ycwl.basic.utils.ApiResponse;
 import lombok.AllArgsConstructor;
 import org.springframework.web.bind.annotation.PostMapping;

src/main/java/com/ycwl/basic/controller/pc/DeviceController.java

@@ -1,79 +0,0 @@
-package com.ycwl.basic.controller.pc;
-
-import com.github.pagehelper.PageInfo;
-import com.ycwl.basic.model.pc.device.entity.DeviceConfigEntity;
-import com.ycwl.basic.model.pc.device.req.DeviceAddOrUpdateReq;
-import com.ycwl.basic.model.pc.device.req.DeviceBatchSortRequest;
-import com.ycwl.basic.model.pc.device.req.DeviceReqQuery;
-import com.ycwl.basic.model.pc.device.req.DeviceSortRequest;
-import com.ycwl.basic.model.pc.device.resp.DeviceRespVO;
-import com.ycwl.basic.model.pc.template.req.TemplateSortRequest;
-import com.ycwl.basic.service.pc.DeviceService;
-import com.ycwl.basic.utils.ApiResponse;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-
-/**
- * @Author：longbinbin
- * @Date：2024/12/2 16:13
- */
-@RestController
-@RequestMapping("/api/device/v1")
-// 设备管理
-public class DeviceController {
-    @Autowired
-    private DeviceService deviceService;
-
-    // 设备分页查询
-    @PostMapping("/page")
-    public ApiResponse<PageInfo<DeviceRespVO>> pageQuery(@RequestBody DeviceReqQuery deviceReqQuery) {
-        return deviceService.pageQuery(deviceReqQuery);
-    }
-    // 设备列表查询
-    @PostMapping("/list")
-    public ApiResponse list(@RequestBody DeviceReqQuery deviceReqQuery) {
-        return deviceService.list(deviceReqQuery);
-    }
-    // 设备详情查询
-    @GetMapping("/getDetails/{id}")
-    public ApiResponse<DeviceRespVO> getDetails(@PathVariable("id") Long id) {
-        return deviceService.getById(id);
-    }
-    // 新增或修改设备
-    @PostMapping("/addOrUpdate")
-    public ApiResponse addOrUpdate(@RequestBody DeviceAddOrUpdateReq deviceReqQuery) {
-        return deviceService.addOrUpdate(deviceReqQuery);
-    }
-    // 删除设备
-    @DeleteMapping("/delete/{id}")
-    public ApiResponse delete(@PathVariable("id") Long id) {
-        return deviceService.deleteById(id);
-    }
-    // 修改设备状态
-    @PutMapping("/updateStatus/{id}")
-    public ApiResponse updateStatus(@PathVariable("id") Long id) {
-        return deviceService.updateStatus(id);
-    }
-
-    // 排序设备
-    @PostMapping("/sort")
-    public ApiResponse<Boolean> sortDevice(@RequestBody DeviceSortRequest request) {
-        return deviceService.sortDevice(request.getDeviceId(), request.getAfterDeviceId());
-    }
-
-    @PostMapping("/scenic/{scenicId}/sortBatch")
-    public ApiResponse<Boolean> sortDeviceBatch(@PathVariable("scenicId") Long scenicId, @RequestBody DeviceBatchSortRequest request) {
-        return deviceService.batchSort(scenicId, request);
-    }
-
-    @GetMapping("/config/{id}")
-    public ApiResponse<DeviceConfigEntity> getConfig(@PathVariable("id") Long id) {
-        return ApiResponse.success(deviceService.getConfig(id));
-    }
-
-    @PostMapping("/saveConfig/{configId}")
-    public ApiResponse saveConfig(@PathVariable("configId") Long configId, @RequestBody DeviceConfigEntity deviceConfigEntity) {
-        deviceService.saveConfig(configId, deviceConfigEntity);
-        return ApiResponse.success(null);
-    }
-}

src/main/java/com/ycwl/basic/controller/pc/DeviceV2Controller.java

@@ -0,0 +1,487 @@
+package com.ycwl.basic.controller.pc;
+
+import com.ycwl.basic.integration.device.dto.config.*;
+import com.ycwl.basic.integration.device.dto.device.*;
+import com.ycwl.basic.integration.device.service.DeviceConfigIntegrationService;
+import com.ycwl.basic.integration.device.service.DeviceIntegrationService;
+import com.ycwl.basic.utils.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 设备管理 V2 版本控制器 - 基于 zt-device 集成服务
+ * 
+ * @author Claude Code
+ * @date 2025-09-01
+ */
+@Slf4j
+@RestController
+@RequestMapping("/api/device/v2")
+@RequiredArgsConstructor
+public class DeviceV2Controller {
+
+    private final DeviceIntegrationService deviceIntegrationService;
+    private final DeviceConfigIntegrationService deviceConfigIntegrationService;
+
+    // ========== 设备基础 CRUD 操作 ==========
+
+    /**
+     * 设备V2核心信息分页列表
+     */
+    @GetMapping("/")
+    public ApiResponse<DeviceV2ListResponse> listDevices(@RequestParam(defaultValue = "1") Integer page,
+                                                        @RequestParam(defaultValue = "10") Integer pageSize,
+                                                        @RequestParam(required = false) String name,
+                                                        @RequestParam(required = false) String no,
+                                                        @RequestParam(required = false) String type,
+                                                        @RequestParam(required = false) Integer isActive,
+                                                        @RequestParam(required = false) Long scenicId) {
+        log.info("分页查询设备核心信息列表, page: {}, pageSize: {}, name: {}, no: {}, type: {}, isActive: {}, scenicId: {}", 
+                page, pageSize, name, no, type, isActive, scenicId);
+        
+        // 参数验证：限制pageSize最大值为100
+        if (pageSize > 100) {
+            pageSize = 100;
+        }
+        
+        try {
+            DeviceV2ListResponse response = deviceIntegrationService.listDevices(page, pageSize, name, no, type, isActive, scenicId);
+            return ApiResponse.success(response);
+        } catch (Exception e) {
+            log.error("分页查询设备核心信息列表失败", e);
+            return ApiResponse.fail("分页查询设备列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 设备V2带配置信息分页列表
+     */
+    @GetMapping("/with-config")
+    public ApiResponse<DeviceV2WithConfigListResponse> listDevicesWithConfig(@RequestParam(defaultValue = "1") Integer page,
+                                                                           @RequestParam(defaultValue = "10") Integer pageSize,
+                                                                           @RequestParam(required = false) String name,
+                                                                           @RequestParam(required = false) String no,
+                                                                           @RequestParam(required = false) String type,
+                                                                           @RequestParam(required = false) Integer isActive,
+                                                                           @RequestParam(required = false) Long scenicId) {
+        log.info("分页查询设备带配置信息列表, page: {}, pageSize: {}, name: {}, no: {}, type: {}, isActive: {}, scenicId: {}", 
+                page, pageSize, name, no, type, isActive, scenicId);
+        
+        // 参数验证：限制pageSize最大值为100
+        if (pageSize > 100) {
+            pageSize = 100;
+        }
+        
+        try {
+            DeviceV2WithConfigListResponse response = deviceIntegrationService.listDevicesWithConfig(page, pageSize, name, no, type, isActive, scenicId);
+            return ApiResponse.success(response);
+        } catch (Exception e) {
+            log.error("分页查询设备带配置信息列表失败", e);
+            return ApiResponse.fail("分页查询设备带配置信息列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据ID获取设备信息
+     */
+    @GetMapping("/{id}")
+    public ApiResponse<DeviceV2DTO> getDevice(@PathVariable Long id) {
+        log.info("获取设备信息, id: {}", id);
+        try {
+            DeviceV2DTO device = deviceIntegrationService.getDevice(id);
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("获取设备信息失败, id: {}", id, e);
+            return ApiResponse.fail("获取设备信息失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据ID获取设备带配置信息
+     */
+    @GetMapping("/{id}/with-config")
+    public ApiResponse<DeviceV2WithConfigDTO> getDeviceWithConfig(@PathVariable Long id) {
+        log.info("获取设备配置信息, id: {}", id);
+        try {
+            DeviceV2WithConfigDTO device = deviceIntegrationService.getDeviceWithConfig(id);
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("获取设备配置信息失败, id: {}", id, e);
+            return ApiResponse.fail("获取设备配置信息失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据设备编号获取设备信息
+     */
+    @GetMapping("/no/{no}")
+    public ApiResponse<DeviceV2DTO> getDeviceByNo(@PathVariable String no) {
+        log.info("根据设备编号获取设备信息, no: {}", no);
+        try {
+            DeviceV2DTO device = deviceIntegrationService.getDeviceByNo(no);
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("根据设备编号获取设备信息失败, no: {}", no, e);
+            return ApiResponse.fail("根据设备编号获取设备信息失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据设备编号获取设备带配置信息
+     */
+    @GetMapping("/no/{no}/with-config")
+    public ApiResponse<DeviceV2WithConfigDTO> getDeviceWithConfigByNo(@PathVariable String no) {
+        log.info("根据设备编号获取设备配置信息, no: {}", no);
+        try {
+            DeviceV2WithConfigDTO device = deviceIntegrationService.getDeviceWithConfigByNo(no);
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("根据设备编号获取设备配置信息失败, no: {}", no, e);
+            return ApiResponse.fail("根据设备编号获取设备配置信息失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 创建设备
+     */
+    @PostMapping("/")
+    public ApiResponse<DeviceV2DTO> createDevice(@Valid @RequestBody CreateDeviceRequest request) {
+        log.info("创建设备, name: {}, no: {}, type: {}, sort: {}", 
+                request.getName(), request.getNo(), request.getType(), request.getSort());
+        try {
+            DeviceV2DTO device = deviceIntegrationService.createDevice(request);
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("创建设备失败", e);
+            return ApiResponse.fail("创建设备失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 创建IPC摄像头设备（快捷方法）
+     */
+    @PostMapping("/ipc")
+    public ApiResponse<DeviceV2DTO> createIpcDevice(@RequestBody Map<String, Object> request) {
+        String name = (String) request.get("name");
+        String deviceNo = (String) request.get("no");
+        Long scenicId = Long.valueOf(request.get("scenicId").toString());
+        Integer sort = request.get("sort") != null ? Integer.valueOf(request.get("sort").toString()) : null;
+        
+        log.info("创建IPC摄像头设备, name: {}, no: {}, scenicId: {}, sort: {}", name, deviceNo, scenicId, sort);
+        try {
+            DeviceV2DTO device;
+            if (sort != null) {
+                device = deviceIntegrationService.createIpcDeviceWithSort(name, deviceNo, scenicId, sort);
+            } else {
+                device = deviceIntegrationService.createIpcDevice(name, deviceNo, scenicId);
+            }
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("创建IPC摄像头设备失败", e);
+            return ApiResponse.fail("创建IPC摄像头设备失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 创建自定义设备（快捷方法）
+     */
+    @PostMapping("/custom")
+    public ApiResponse<DeviceV2DTO> createCustomDevice(@RequestBody Map<String, Object> request) {
+        String name = (String) request.get("name");
+        String deviceNo = (String) request.get("no");
+        Long scenicId = Long.valueOf(request.get("scenicId").toString());
+        Integer sort = request.get("sort") != null ? Integer.valueOf(request.get("sort").toString()) : null;
+        
+        log.info("创建自定义设备, name: {}, no: {}, scenicId: {}, sort: {}", name, deviceNo, scenicId, sort);
+        try {
+            DeviceV2DTO device;
+            if (sort != null) {
+                device = deviceIntegrationService.createCustomDeviceWithSort(name, deviceNo, scenicId, sort);
+            } else {
+                device = deviceIntegrationService.createCustomDevice(name, deviceNo, scenicId);
+            }
+            return ApiResponse.success(device);
+        } catch (Exception e) {
+            log.error("创建自定义设备失败", e);
+            return ApiResponse.fail("创建自定义设备失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 更新设备信息
+     */
+    @PutMapping("/{id}")
+    public ApiResponse<String> updateDevice(@PathVariable Long id, @Valid @RequestBody UpdateDeviceRequest request) {
+        log.info("更新设备信息, id: {}", id);
+        try {
+            deviceIntegrationService.updateDevice(id, request);
+            return ApiResponse.success("设备信息更新成功");
+        } catch (Exception e) {
+            log.error("更新设备信息失败, id: {}", id, e);
+            return ApiResponse.fail("更新设备信息失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 更新设备排序
+     */
+    @PutMapping("/{id}/sort")
+    public ApiResponse<String> updateDeviceSort(@PathVariable Long id, @RequestBody Map<String, Integer> request) {
+        Integer sort = request.get("sort");
+        log.info("更新设备排序, id: {}, sort: {}", id, sort);
+        try {
+            deviceIntegrationService.updateDeviceSort(id, sort);
+            return ApiResponse.success("设备排序更新成功");
+        } catch (Exception e) {
+            log.error("更新设备排序失败, id: {}, sort: {}", id, sort, e);
+            return ApiResponse.fail("更新设备排序失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 启用设备
+     */
+    @PutMapping("/{id}/enable")
+    public ApiResponse<String> enableDevice(@PathVariable Long id) {
+        log.info("启用设备, id: {}", id);
+        try {
+            deviceIntegrationService.enableDevice(id);
+            return ApiResponse.success("设备启用成功");
+        } catch (Exception e) {
+            log.error("启用设备失败, id: {}", id, e);
+            return ApiResponse.fail("启用设备失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 禁用设备
+     */
+    @PutMapping("/{id}/disable")
+    public ApiResponse<String> disableDevice(@PathVariable Long id) {
+        log.info("禁用设备, id: {}", id);
+        try {
+            deviceIntegrationService.disableDevice(id);
+            return ApiResponse.success("设备禁用成功");
+        } catch (Exception e) {
+            log.error("禁用设备失败, id: {}", id, e);
+            return ApiResponse.fail("禁用设备失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 删除设备
+     */
+    @DeleteMapping("/{id}")
+    public ApiResponse<String> deleteDevice(@PathVariable Long id) {
+        log.info("删除设备, id: {}", id);
+        try {
+            deviceIntegrationService.deleteDevice(id);
+            return ApiResponse.success("设备删除成功");
+        } catch (Exception e) {
+            log.error("删除设备失败, id: {}", id, e);
+            return ApiResponse.fail("删除设备失败: " + e.getMessage());
+        }
+    }
+
+    // ========== 设备配置管理操作 ==========
+
+    /**
+     * 获取设备配置列表
+     */
+    @GetMapping("/{id}/config")
+    public ApiResponse<List<DeviceConfigV2DTO>> getDeviceConfigs(@PathVariable Long id) {
+        log.info("获取设备配置列表, deviceId: {}", id);
+        try {
+            List<DeviceConfigV2DTO> configs = deviceConfigIntegrationService.getDeviceConfigs(id);
+            return ApiResponse.success(configs);
+        } catch (Exception e) {
+            log.error("获取设备配置列表失败, deviceId: {}", id, e);
+            return ApiResponse.fail("获取设备配置列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 获取设备扁平化配置
+     */
+    @GetMapping("/{id}/flat-config")
+    public ApiResponse<Map<String, Object>> getDeviceFlatConfig(@PathVariable Long id) {
+        log.info("获取设备扁平化配置, deviceId: {}", id);
+        try {
+            Map<String, Object> config = deviceConfigIntegrationService.getDeviceFlatConfig(id);
+            return ApiResponse.success(config);
+        } catch (Exception e) {
+            log.error("获取设备扁平化配置失败, deviceId: {}", id, e);
+            return ApiResponse.fail("获取设备扁平化配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据配置键获取配置
+     */
+    @GetMapping("/{id}/config/{configKey}")
+    public ApiResponse<DeviceConfigV2DTO> getDeviceConfigByKey(@PathVariable Long id, 
+                                                              @PathVariable String configKey) {
+        log.info("根据键获取设备配置, deviceId: {}, configKey: {}", id, configKey);
+        try {
+            DeviceConfigV2DTO config = deviceConfigIntegrationService.getDeviceConfigByKey(id, configKey);
+            return ApiResponse.success(config);
+        } catch (Exception e) {
+            log.error("根据键获取设备配置失败, deviceId: {}, configKey: {}", id, configKey, e);
+            return ApiResponse.fail("根据键获取设备配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据设备编号获取配置列表
+     */
+    @GetMapping("/no/{no}/config")
+    public ApiResponse<List<DeviceConfigV2DTO>> getDeviceConfigsByNo(@PathVariable String no) {
+        log.info("根据设备编号获取配置列表, deviceNo: {}", no);
+        try {
+            List<DeviceConfigV2DTO> configs = deviceConfigIntegrationService.getDeviceConfigsByNo(no);
+            return ApiResponse.success(configs);
+        } catch (Exception e) {
+            log.error("根据设备编号获取配置列表失败, deviceNo: {}", no, e);
+            return ApiResponse.fail("根据设备编号获取配置列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 根据设备编号获取扁平化配置
+     */
+    @GetMapping("/no/{no}/flat-config")
+    public ApiResponse<Map<String, Object>> getDeviceFlatConfigByNo(@PathVariable String no) {
+        log.info("根据设备编号获取扁平化配置, deviceNo: {}", no);
+        try {
+            Map<String, Object> config = deviceConfigIntegrationService.getDeviceFlatConfigByNo(no);
+            return ApiResponse.success(config);
+        } catch (Exception e) {
+            log.error("根据设备编号获取扁平化配置失败, deviceNo: {}", no, e);
+            return ApiResponse.fail("根据设备编号获取扁平化配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 创建设备配置
+     */
+    @PostMapping("/{id}/config")
+    public ApiResponse<DeviceConfigV2DTO> createDeviceConfig(@PathVariable Long id, 
+                                                           @Valid @RequestBody CreateDeviceConfigRequest request) {
+        log.info("创建设备配置, deviceId: {}, configKey: {}", id, request.getConfigKey());
+        try {
+            DeviceConfigV2DTO config = deviceConfigIntegrationService.createDeviceConfig(id, request);
+            return ApiResponse.success(config);
+        } catch (Exception e) {
+            log.error("创建设备配置失败, deviceId: {}, configKey: {}", id, request.getConfigKey(), e);
+            return ApiResponse.fail("创建设备配置失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 批量创建/更新设备配置
+     */
+    @PostMapping("/{id}/config/batch")
+    public ApiResponse<BatchUpdateResponse> batchUpdateDeviceConfig(@PathVariable Long id, 
+                                                                   @Valid @RequestBody BatchDeviceConfigRequest request) {
+        log.info("批量更新设备配置, deviceId: {}, configs count: {}", id, request.getConfigs().size());
+        try {
+            BatchUpdateResponse result = deviceConfigIntegrationService.batchUpdateDeviceConfig(id, request);
+            return ApiResponse.success(result);
+        } catch (Exception e) {
+            log.error("批量更新设备配置失败, deviceId: {}", id, e);
+            return ApiResponse.fail("批量更新设备配置失败: " + e.getMessage());
+        }
+    }
+
+
+    /**
+     * 更新设备配置
+     */
+    @PutMapping("/{id}/config/{configId}")
+    public ApiResponse<String> updateDeviceConfig(@PathVariable Long id, @PathVariable Long configId,
+                                                 @Valid @RequestBody UpdateDeviceConfigRequest request) {
+        log.info("更新设备配置, deviceId: {}, configId: {}", id, configId);
+        try {
+            deviceConfigIntegrationService.updateDeviceConfig(id, configId, request);
+            return ApiResponse.success("设备配置更新成功");
+        } catch (Exception e) {
+            log.error("更新设备配置失败, deviceId: {}, configId: {}", id, configId, e);
+            return ApiResponse.fail("更新设备配置失败: " + e.getMessage());
+        }
+    }
+
+
+    /**
+     * 删除设备配置
+     */
+    @DeleteMapping("/{id}/config/{configId}")
+    public ApiResponse<String> deleteDeviceConfig(@PathVariable Long id, @PathVariable Long configId) {
+        log.info("删除设备配置, deviceId: {}, configId: {}", id, configId);
+        try {
+            deviceConfigIntegrationService.deleteDeviceConfig(id, configId);
+            return ApiResponse.success("设备配置删除成功");
+        } catch (Exception e) {
+            log.error("删除设备配置失败, deviceId: {}, configId: {}", id, configId, e);
+            return ApiResponse.fail("删除设备配置失败: " + e.getMessage());
+        }
+    }
+
+    // ========== 景区设备管理操作 ==========
+
+    /**
+     * 获取景区IPC设备列表
+     */
+    @GetMapping("/scenic/{scenicId}/ipc")
+    public ApiResponse<DeviceV2ListResponse> getScenicIpcDevices(@PathVariable Long scenicId,
+                                                               @RequestParam(defaultValue = "1") Integer page,
+                                                               @RequestParam(defaultValue = "10") Integer pageSize) {
+        log.info("获取景区IPC设备列表, scenicId: {}, page: {}, pageSize: {}", scenicId, page, pageSize);
+        try {
+            DeviceV2ListResponse response = deviceIntegrationService.getScenicIpcDevices(scenicId, page, pageSize);
+            return ApiResponse.success(response);
+        } catch (Exception e) {
+            log.error("获取景区IPC设备列表失败, scenicId: {}", scenicId, e);
+            return ApiResponse.fail("获取景区IPC设备列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 获取景区激活设备列表
+     */
+    @GetMapping("/scenic/{scenicId}/active")
+    public ApiResponse<DeviceV2ListResponse> getScenicActiveDevices(@PathVariable Long scenicId,
+                                                                  @RequestParam(defaultValue = "1") Integer page,
+                                                                  @RequestParam(defaultValue = "10") Integer pageSize) {
+        log.info("获取景区激活设备列表, scenicId: {}, page: {}, pageSize: {}", scenicId, page, pageSize);
+        try {
+            DeviceV2ListResponse response = deviceIntegrationService.getScenicActiveDevices(scenicId, page, pageSize);
+            return ApiResponse.success(response);
+        } catch (Exception e) {
+            log.error("获取景区激活设备列表失败, scenicId: {}", scenicId, e);
+            return ApiResponse.fail("获取景区激活设备列表失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 获取景区所有设备列表
+     */
+    @GetMapping("/scenic/{scenicId}/all")
+    public ApiResponse<DeviceV2ListResponse> getScenicAllDevices(@PathVariable Long scenicId,
+                                                               @RequestParam(defaultValue = "1") Integer page,
+                                                               @RequestParam(defaultValue = "10") Integer pageSize) {
+        log.info("获取景区所有设备列表, scenicId: {}, page: {}, pageSize: {}", scenicId, page, pageSize);
+        try {
+            DeviceV2ListResponse response = deviceIntegrationService.listDevices(page, pageSize, null, null, null, null, scenicId);
+            return ApiResponse.success(response);
+        } catch (Exception e) {
+            log.error("获取景区所有设备列表失败, scenicId: {}", scenicId, e);
+            return ApiResponse.fail("获取景区所有设备列表失败: " + e.getMessage());
+        }
+    }
+}

src/main/java/com/ycwl/basic/controller/viid/ViidController.java

@@ -4,12 +4,16 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.thread.ThreadFactoryBuilder;
 import cn.hutool.core.util.ObjectUtil;
+import com.ycwl.basic.integration.common.manager.DeviceConfigManager;
 import com.ycwl.basic.utils.JacksonUtil;
 import com.ycwl.basic.annotation.IgnoreLogReq;
 import com.ycwl.basic.annotation.IgnoreToken;
 import com.ycwl.basic.facebody.adapter.IFaceBodyAdapter;
 import com.ycwl.basic.facebody.entity.AddFaceResp;
-import com.ycwl.basic.mapper.DeviceMapper;
+import com.ycwl.basic.integration.device.service.DeviceIntegrationService;
+import com.ycwl.basic.integration.device.dto.device.CreateDeviceRequest;
+import com.ycwl.basic.integration.device.dto.device.UpdateDeviceRequest;
+import com.ycwl.basic.integration.device.dto.device.DeviceV2DTO;
 import com.ycwl.basic.mapper.FaceSampleMapper;
 import com.ycwl.basic.mapper.SourceMapper;
 import com.ycwl.basic.model.pc.device.entity.DeviceConfigEntity;
@@ -33,7 +37,6 @@ import com.ycwl.basic.model.viid.req.UnRegisterReq;
 import com.ycwl.basic.model.viid.resp.SystemTimeResp;
 import com.ycwl.basic.model.viid.resp.VIIDBaseResp;
 import com.ycwl.basic.repository.DeviceRepository;
-import com.ycwl.basic.repository.ScenicRepository;
 import com.ycwl.basic.service.pc.ScenicService;
 import com.ycwl.basic.service.task.TaskFaceService;
 import com.ycwl.basic.storage.StorageFactory;
@@ -80,15 +83,13 @@ import static com.ycwl.basic.constant.StorageConstant.VIID_FACE;
 @Slf4j
 public class ViidController {
     @Autowired
-    private DeviceMapper deviceMapper;
+    private DeviceIntegrationService deviceIntegrationService;
     private static final String serverId = "00000000000000000001";
     @Autowired
     private SourceMapper sourceMapper;
     @Autowired
     private DeviceRepository deviceRepository;
     @Autowired
-    private ScenicRepository scenicRepository;
-    @Autowired
     private TaskFaceService taskFaceService;
     private final Map<Long, ThreadPoolExecutor> executors = new ConcurrentHashMap<>();
     @Autowired
@@ -129,12 +130,21 @@ public class ViidController {
         }
         device.setKeepaliveAt(new Date());
         device.setIpAddr(IpUtils.getIpAddr(request));
-        if (device.getId() != null) {
-            deviceMapper.updateEntity(device);
-        } else {
-            device.setId(SnowFlakeUtil.getLongId());
-            deviceMapper.addEntity(device);
-            deviceRepository.clearDeviceCache(deviceId);
+        if (device.getId() == null) {
+            // 通过zt-device服务创建新设备
+            CreateDeviceRequest createRequest = new CreateDeviceRequest();
+            createRequest.setName(device.getName());
+            createRequest.setNo(device.getNo());
+            createRequest.setType("IPC"); // 默认类型为IPC
+            createRequest.setIsActive(0);
+            createRequest.setScenicId(0L);
+            createRequest.setSort(0);
+            try {
+                DeviceV2DTO createdDevice = deviceIntegrationService.createDevice(createRequest);
+                device.setId(createdDevice.getId());
+            } catch (Exception e) {
+                log.warn("创建设备失败，设备编号: {}, 错误: {}", deviceId, e.getMessage());
+            }
         }
         return new VIIDBaseResp(
                 new ResponseStatusObject(serverId, "/VIID/System/Register", "0", "注册成功", sdfTime.format(new Date()))
@@ -166,9 +176,20 @@ public class ViidController {
             device.setOnline(1);
             device.setKeepaliveAt(new Date());
             device.setIpAddr(IpUtils.getIpAddr(request));
-            device.setId(SnowFlakeUtil.getLongId());
-            deviceMapper.addEntity(device);
-            deviceRepository.clearDeviceCache(deviceId);
+            // 通过zt-device服务创建新设备
+            CreateDeviceRequest createRequest = new CreateDeviceRequest();
+            createRequest.setName(device.getName());
+            createRequest.setNo(device.getNo());
+            createRequest.setType("IPC"); // 默认类型为IPC
+            createRequest.setIsActive(0);
+            createRequest.setScenicId(0L);
+            createRequest.setSort(0);
+            try {
+                DeviceV2DTO createdDevice = deviceIntegrationService.createDevice(createRequest);
+                device.setId(createdDevice.getId());
+            } catch (Exception e) {
+                log.warn("创建设备失败，设备编号: {}, 错误: {}", deviceId, e.getMessage());
+            }
         } else {
             deviceRepository.updateOnlineStatus(device.getId(), IpUtils.getIpAddr(request), 1, new Date());
         }
@@ -245,17 +266,15 @@ public class ViidController {
             if (device == null) {
                 continue;
             }
-            DeviceConfigEntity deviceConfig = deviceRepository.getDeviceConfig(device.getId());
+            DeviceConfigManager deviceConfig = deviceRepository.getDeviceConfigManager(device.getId());
+            DeviceConfigEntity deviceConfigEntity = deviceRepository.getDeviceConfig(device.getId());
             if (deviceConfig == null) {
                 log.warn("设备配置不存在：" + deviceID);
                 return new VIIDBaseResp(
                         new ResponseStatusObject(faceId, "/VIID/Faces", "0", "OK", sdfTime.format(new Date()))
                 );
             }
-            int viidMode = 0;
-            if (deviceConfig.getViidType() != null) {
-                viidMode = deviceConfig.getViidType();
-            }
+            Integer viidMode = deviceConfig.getInteger("viid_mode", 0);
             Date shotTime = null;
             if (StringUtils.isNotBlank(face.getShotTime())) {
                 try {
@@ -333,7 +352,7 @@ public class ViidController {
                                             faceSampleMapper.updateScore(faceSample.getId(), addFaceResp.getScore());
                                         }
                                     }
-                                    if (Integer.valueOf(1).equals(deviceConfig.getEnablePreBook())) {
+                                    if (Integer.valueOf(1).equals(deviceConfig.getInteger("enable_pre_book"))) {
                                         DynamicTaskGenerator.addTask(faceSample.getId());
                                     }
                                 });
@@ -352,7 +371,7 @@ public class ViidController {
                                 MultipartFile _file = ImageUtils.base64ToMultipartFile(_subImage.getData());
                                 ThreadPoolExecutor executor = getExecutor(scenicId);
                                 executor.execute(() -> {
-                                    List<DeviceCropConfig> cropConfigs = deviceConfig._getCropConfig();
+                                    List<DeviceCropConfig> cropConfigs = deviceConfigEntity._getCropConfig();
                                     for (DeviceCropConfig cropConfig : cropConfigs) {
                                         source.setId(SnowFlakeUtil.getLongId());
                                         String filename = StorageUtil.joinPath(PHOTO_PATH, UUID.randomUUID() + "." + ext);
@@ -425,7 +444,7 @@ public class ViidController {
                                             faceSampleMapper.updateScore(faceSample.getId(), addFaceResp.getScore());
                                         }
                                     }
-                                    if (Integer.valueOf(1).equals(deviceConfig.getEnablePreBook())) {
+                                    if (Integer.valueOf(1).equals(deviceConfig.getInteger("enable_pre_book"))) {
                                         DynamicTaskGenerator.addTask(faceSample.getId());
                                     }
                                 });

src/main/java/com/ycwl/basic/controller/wvp/WvpController.java

@@ -6,7 +6,6 @@ import com.ycwl.basic.constant.StorageConstant;
 import com.ycwl.basic.device.entity.common.FileObject;
 import com.ycwl.basic.device.operator.WvpPassiveStorageOperator;
 import com.ycwl.basic.model.wvp.WvpSyncReqVo;
-import com.ycwl.basic.service.pc.DeviceService;
 import com.ycwl.basic.service.pc.ScenicService;
 import com.ycwl.basic.storage.adapters.IStorageAdapter;
 import com.ycwl.basic.storage.enums.StorageAcl;
@@ -30,15 +29,12 @@ import java.util.List;
 @RequestMapping("/wvp/v1/")
 public class WvpController {
 
-    @Autowired
-    private DeviceService deviceService;
     @Autowired
     private ScenicService scenicService;
 
     @IgnoreLogReq
     @PostMapping("/scenic/{scenicId}/sync")
     public ApiResponse<List<WvpPassiveStorageOperator.Task>> sync(@PathVariable("scenicId") Long scenicId, @RequestBody WvpSyncReqVo reqVo) {
-        deviceService.updateDevices(scenicId, reqVo);
         return ApiResponse.success(WvpPassiveStorageOperator.getTaskListByScenicId(scenicId));
     }