将 bnt.web.my 模块迁移到 content-service/disk 模块

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/controller/CamController.java

@@ -0,0 +1,134 @@
+package cn.reghao.tnb.content.app.disk.controller;
+
+import cn.reghao.jutil.jdk.result.Result;
+import cn.reghao.jutil.jdk.result.WebResult;
+import cn.reghao.tnb.content.app.disk.model.dto.CamRecordDto;
+import cn.reghao.tnb.content.app.disk.model.vo.CamRecordInfo;
+import cn.reghao.tnb.content.app.disk.model.vo.CamRecordVo;
+import cn.reghao.tnb.content.app.disk.model.vo.MarkDay;
+import cn.reghao.tnb.content.app.disk.service.CamRecordService;
+import cn.reghao.tnb.content.app.disk.service.CamService;
+import cn.reghao.tnb.content.app.geo.model.vo.SelectOption;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.time.LocalDate;
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2024-08-27 19:50:05
+ */
+@Tag(name = "摄像头接口")
+@RestController
+@RequestMapping("/api/disk/cam")
+public class CamController {
+    private final CamService camService;
+    private final CamRecordService camRecordService;
+
+    public CamController(CamService camService, CamRecordService camRecordService) {
+        this.camService = camService;
+        this.camRecordService = camRecordService;
+    }
+
+    @Operation(summary = "摄像头详情页面", description = "N")
+    @GetMapping("/detail")
+    public String camListPage1(@RequestParam(value = "camId", required = false) Long camId,
+                               @RequestParam(value = "yearMonthDay", required = false) String yearMonthDay) {
+        List<SelectOption> kvs = camService.getCamList();
+        if (kvs.isEmpty()) {
+            return WebResult.failWithMsg("no cam");
+        }
+
+        String currentDayStr = LocalDate.now().toString();
+        if (yearMonthDay != null) {
+            currentDayStr = yearMonthDay;
+        }
+
+        if (camId == null) {
+            SelectOption selectOption = kvs.get(0);
+            camId = Long.parseLong(selectOption.getLabel());
+        }
+
+        String currentMonthStr = currentDayStr.substring(0, currentDayStr.lastIndexOf("-"));
+        List<MarkDay> markDays = camRecordService.getDaysInMonth(camId, currentMonthStr);
+        List<CamRecordInfo> dayRecords = camRecordService.getCamRecords(camId, currentDayStr);
+        if (!dayRecords.isEmpty()) {
+            CamRecordInfo camRecordInfo = dayRecords.get(0);
+            long recordId = camRecordInfo.getRecordId();
+            CamRecordVo camRecordVo = camRecordService.getCamRecord(recordId);
+            if (camRecordVo != null) {
+                /*model.addAttribute("coverUrl", camRecordVo.getCoverUrl());
+                model.addAttribute("videoUrl", camRecordVo.getVideoUrl());*/
+            }
+        } else {
+            String videoUrl = "";
+            CamRecordVo camRecordVo = camRecordService.getLatestRecord(camId);
+            if (camRecordVo != null) {
+                //videoUrl = camRecordVo.getVideoUrl();
+                /*model.addAttribute("coverUrl", camRecordVo.getCoverUrl());
+                model.addAttribute("videoUrl", videoUrl);*/
+            } else {
+                /*model.addAttribute("coverUrl", "");
+                model.addAttribute("videoUrl", videoUrl);*/
+            }
+        }
+
+        /*model.addAttribute("camId", camId);
+        model.addAttribute("kvs", kvs);
+        model.addAttribute("markDays", markDays);
+        model.addAttribute("dayRecords", dayRecords);
+        model.addAttribute("viewDate", currentDayStr);*/
+        return WebResult.success();
+    }
+
+    @Operation(summary = "添加录像", description = "N")
+    @PostMapping(value = "/record", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String addCamRecord(@Validated @RequestBody CamRecordDto camRecordDto) {
+        Result result = camRecordService.add(camRecordDto);
+        return WebResult.result(result);
+    }
+
+    @Operation(summary = "某个月中哪些天有录像", description = "N")
+    @GetMapping(value = "/record/month", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String getCamRecordByMonth(Long camId, String yearMonth) {
+        List<MarkDay> list = camRecordService.getDaysInMonth(camId, yearMonth);
+        return WebResult.success(list);
+    }
+
+    @Operation(summary = "获取录像", description = "N")
+    @GetMapping(value = "/record/url/{recordId}", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String getCamRecord(@PathVariable("recordId") long recordId) {
+        CamRecordVo camRecord = camRecordService.getCamRecord(recordId);
+        if (camRecord != null) {
+            return WebResult.success(camRecord);
+        }
+
+        return WebResult.fail();
+    }
+
+    @Operation(summary = "开启/关闭摄像头", description = "N")
+    @PostMapping(value = "/data", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String submit(String deviceId, String content) throws IOException {
+        camService.setCamState(deviceId);
+        return WebResult.success();
+    }
+
+    @Operation(summary = "设置 cam 状态", description = "N")
+    @PostMapping(value = "/state", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String updateCamState(String deviceId, boolean onStream) throws IOException {
+        camService.updateCamState(deviceId, onStream);
+        return WebResult.success();
+    }
+
+    @Operation(summary = "添加活动接口", description = "N")
+    @PostMapping(value = "/activity", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String addActivity() {
+        camService.addActivity();
+        return WebResult.success();
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/controller/NetDiskController.java

@@ -0,0 +1,228 @@
+package cn.reghao.tnb.content.app.disk.controller;
+
+import cn.reghao.jutil.jdk.db.PageList;
+import cn.reghao.jutil.jdk.result.WebResult;
+import cn.reghao.oss.sdk.model.constant.ObjectType;
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.tnb.content.app.disk.model.dto.CreateDir;
+import cn.reghao.tnb.content.app.disk.model.dto.RenameFile;
+import cn.reghao.tnb.content.app.disk.model.dto.SearchForm;
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import cn.reghao.tnb.content.app.disk.model.vo.*;
+import cn.reghao.tnb.content.app.disk.service.NetDiskQuery;
+import cn.reghao.tnb.content.app.disk.service.NetDiskService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.MediaType;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2024-08-29 22:17:06
+ */
+@Tag(name = "网盘接口")
+@RestController
+@RequestMapping("/api/disk")
+public class NetDiskController {
+    private final NetDiskQuery netDiskQuery;
+    private final NetDiskService netDiskService;
+    private int pageSize = 10;
+
+    public NetDiskController(NetDiskQuery netDiskQuery, NetDiskService netDiskService) {
+        this.netDiskQuery = netDiskQuery;
+        this.netDiskService = netDiskService;
+    }
+
+    @Operation(summary = "网盘文件列表页面", description = "N")
+    @GetMapping("/file")
+    public String diskPage(SearchForm searchForm) {
+        Integer pageNumber = searchForm.getPageNo();
+        String filename = searchForm.getFilename();
+        String path = searchForm.getPath();
+        Integer fileType = searchForm.getFileType();
+
+        if (pageNumber == null) {
+            pageNumber = 1;
+        }
+
+        String queryParams = "";
+        if (path == null || path.isBlank()) {
+            path = "/";
+        }
+        queryParams += "?path=" + path;
+
+        String pid = "0";
+        if (!"/".equals(path)) {
+            NetDisk diskFile = netDiskQuery.findByPath(path);
+            if (diskFile == null) {
+                return WebResult.failWithMsg("not found diskFile");
+            }
+            pid = diskFile.getFileId();
+        }
+
+        PageList<FileInfo> page = netDiskQuery.findByPid(pageSize, pageNumber, pid);
+        List<NamePath> pathList = netDiskService.getPathList(path);
+
+        int showTitle = 3;
+        String uploadPage = String.format("/bg/file/upload?channelCode=%s", showTitle);
+
+        /*model.addAttribute("parentDirs", pathList);
+        model.addAttribute("page", page);
+        model.addAttribute("uploadPage", uploadPage);
+        model.addAttribute("showTitle", showTitle);
+        model.addAttribute("query", queryParams);*/
+        return WebResult.success();
+    }
+
+    @Operation(summary = "图片文件列表页面", description = "N")
+    @GetMapping("/image")
+    public String getPhotoPage(SearchForm searchForm) {
+        Integer pageNumber = searchForm.getPageNo();
+        if (pageNumber == null) {
+            pageNumber = 1;
+        }
+
+        PageList<DiskFileInfo> images = netDiskQuery.getImageFiles(ObjectType.Image, pageSize, pageNumber);
+        //model.addAttribute("page", images);
+        return WebResult.success();
+    }
+
+    @Operation(summary = "视频文件列表页面", description = "N")
+    @GetMapping("/video")
+    public String diskVideoPage(SearchForm searchForm) {
+        Integer pageNumber = searchForm.getPageNo();
+        if (pageNumber == null) {
+            pageNumber = 1;
+        }
+
+        PageList<DiskFileInfo> images = netDiskQuery.getImageFiles(ObjectType.Video, pageSize, pageNumber);
+        //model.addAttribute("page", images);
+        return WebResult.success();
+    }
+
+    @Operation(summary = "音频文件列表页面", description = "N")
+    @GetMapping("/audio")
+    public String diskAudioPage(SearchForm searchForm) {
+        Integer pageNumber = searchForm.getPageNo();
+        if (pageNumber == null) {
+            pageNumber = 1;
+        }
+
+        PageList<DiskFileInfo> images = netDiskQuery.getImageFiles(ObjectType.Audio, pageSize, pageNumber);
+        //model.addAttribute("page", images);
+        return WebResult.success();
+    }
+
+    @Operation(summary = "文档文件列表页面", description = "N")
+    @GetMapping("/doc")
+    public String diskDocPage(SearchForm searchForm) {
+        Integer pageNumber = searchForm.getPageNo();
+        if (pageNumber == null) {
+            pageNumber = 1;
+        }
+
+        PageList<DiskFileInfo> images = netDiskQuery.getImageFiles(ObjectType.Text, pageSize, pageNumber);
+        //model.addAttribute("page", images);
+        return WebResult.success();
+    }
+
+    @Operation(summary = "文件分享页面", description = "N")
+    @GetMapping("/share/{shareId}")
+    public String disSharePage(@PathVariable("shareId") String shareId) {
+        /*model.addAttribute("siteName", "disk");
+        model.addAttribute("page", Page.empty());
+        model.addAttribute("query", "fileType=1001");*/
+        return WebResult.success();
+    }
+
+    @Operation(summary = "检查文件是否存在", description = "N")
+    @PostMapping(value = "/file/check", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String createFolder(@Validated CreateDir createDir) {
+        long loginUser = UserContext.getUserId();
+        NetDisk netDisk = netDiskQuery.getNetDisk(loginUser, createDir.getPath());
+        Boolean exist = netDisk != null;
+        return WebResult.success(exist);
+    }
+
+    @Operation(summary = "文件预览", description = "N")
+    @GetMapping(value = "/preview", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String getPreviewFile(@RequestParam("fileId") String fileId) {
+        FileUrl fileUrl = netDiskQuery.getFileUrl(fileId);
+        return WebResult.success(fileUrl);
+    }
+
+    @Operation(summary = "重命名文件", description = "N")
+    @PostMapping(value = "/rename", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String rename(@Validated RenameFile renameFile) throws IOException {
+        /*long owner = UserContext.getUserId();
+        String fileId = renameFile.getFileId();
+        String newFilename = renameFile.getNewFilename();
+        Result result = netDiskService.rename(fileId, newFilename, owner);
+        return WebResult.result(result);*/
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "复制文件", description = "N")
+    @PostMapping(value = "/copy", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String copyFiles(@RequestParam("fileId") List<String> fileIds, String pid) throws IOException {
+        /*long owner = UserContext.getUserId();
+        netDiskService.move(pid, fileIds, true, owner);*/
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "移动文件", description = "N")
+    @PostMapping(value = "/move", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String moveFiles(@RequestParam("fileId") List<String> fileIds, String pid) throws IOException {
+        /*long owner = UserContext.getUserId();
+        netDiskService.move(pid, fileIds, false, owner);*/
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "删除文件", description = "N")
+    @PostMapping(value = "/delete", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String deleteFiles(@RequestParam("fileId") List<String> fileIds) throws IOException {
+        //netDiskService.delete(fileIds);
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "还原删除的文件", description = "N")
+    @PostMapping(value = "/restore", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String restoreFiles(@RequestParam("fileId") List<String> fileIds) throws IOException {
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "清空回收站", description = "N")
+    @PostMapping(value = "/erase", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String eraseFiles(@RequestParam("fileId") List<String> fileIds) throws IOException {
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "获取目录树", description = "N")
+    @GetMapping(value = "/disk/foldertree", produces = MediaType.APPLICATION_JSON_VALUE)
+    public String getFolderTree() {
+        List<FolderTree> list = netDiskQuery.getFolders();
+        return WebResult.success(list);
+    }
+
+    @Operation(summary = "访问分享的文件", description = "N")
+    @GetMapping("/s/{shareId}")
+    public String shareFile(@PathVariable("shareId") String shareId) {
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "获取分享的文件列表", description = "N")
+    @GetMapping("/share/list")
+    public String getShareList() {
+        return WebResult.successWithMsg("尚未实现");
+    }
+
+    @Operation(summary = "获取回收站中的文件列表", description = "N")
+    @GetMapping("/trash/list")
+    public String getTrashList() {
+        return WebResult.successWithMsg("尚未实现");
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/db/mapper/CamDeviceMapper.java

@@ -0,0 +1,21 @@
+package cn.reghao.tnb.content.app.disk.db.mapper;
+
+import cn.reghao.jutil.jdk.db.BaseMapper;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.tnb.content.app.disk.model.po.CamDevice;
+import cn.reghao.tnb.content.app.disk.model.query.CamDeviceQuery;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2025-08-28 22:47:06
+ */
+@Mapper
+public interface CamDeviceMapper extends BaseMapper<CamDevice> {
+    int countByCamDeviceQuery(CamDeviceQuery camDeviceQuery);
+    List<CamDevice> findCamDeviceQueryByPage(@Param("camDeviceQuery") CamDeviceQuery camDeviceQuery,
+                                             @Param("page") Page page);
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/db/mapper/CamRecordMapper.java

@@ -0,0 +1,23 @@
+package cn.reghao.tnb.content.app.disk.db.mapper;
+
+import cn.reghao.jutil.jdk.db.BaseMapper;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.tnb.content.app.disk.model.po.CamRecord;
+import cn.reghao.tnb.content.app.disk.model.vo.RecordInfo;
+import cn.reghao.tnb.content.app.disk.model.vo.ResultCount;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2025-08-28 22:47:18
+ */
+@Mapper
+public interface CamRecordMapper extends BaseMapper<CamRecord> {
+    List<CamRecord> findByCamId(@Param("camId") long camId, @Param("page") Page page);
+    List<RecordInfo> findByCamIdAndStartAt(@Param("camId") long camId, @Param("dayStr") String dayStr);
+    CamRecord findByRecordId(long recordId);
+    List<ResultCount> findGroupByYearMonth(@Param("camId") long camId, @Param("yearMonth") String yearMonth);
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/db/mapper/NetDiskMapper.java

@@ -0,0 +1,22 @@
+package cn.reghao.tnb.content.app.disk.db.mapper;
+
+import cn.reghao.jutil.jdk.db.BaseMapper;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import cn.reghao.tnb.content.app.disk.model.query.DiskQuery;
+import cn.reghao.tnb.content.app.disk.model.vo.NetDiskCount;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2025-08-28 22:47:28
+ */
+@Mapper
+public interface NetDiskMapper extends BaseMapper<NetDisk> {
+    List<NetDiskCount> findFileTypeCountByGroup(long owner);
+    int countByDiskQuery(DiskQuery diskQuery);
+    List<NetDisk> findDiskQueryByPage(@Param("diskQuery") DiskQuery diskQuery, @Param("page") Page page);
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/db/mapper/UserActivityMapper.java

@@ -0,0 +1,13 @@
+package cn.reghao.tnb.content.app.disk.db.mapper;
+
+import cn.reghao.jutil.jdk.db.BaseMapper;
+import cn.reghao.tnb.content.app.disk.model.po.UserActivity;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * @author reghao
+ * @date 2025-08-28 22:47:42
+ */
+@Mapper
+public interface UserActivityMapper extends BaseMapper<UserActivity> {
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/dto/CamRecordDto.java

@@ -0,0 +1,28 @@
+package cn.reghao.tnb.content.app.disk.model.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+/**
+ * @author reghao
+ * @date 2024-02-03 13:09:07
+ */
+@Setter
+@Getter
+public class CamRecordDto {
+    @NotBlank
+    private String camName;
+    @NotNull
+    private Long startAt;
+    @NotNull
+    private Integer duration;
+    //@NotBlank
+    private String videoFileId;
+
+    private Integer coverChannelCode;
+    private String coverFileId;
+    private Integer videoChannelCode;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/dto/CreateDir.java

@@ -0,0 +1,19 @@
+package cn.reghao.tnb.content.app.disk.model.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+/**
+ * @author reghao
+ * @date 2024-04-17 09:06:05
+ */
+@Setter
+@Getter
+public class CreateDir {
+    @NotBlank
+    private String path;
+    @NotBlank
+    private String sha256sum;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/dto/MoveFile.java

@@ -0,0 +1,16 @@
+package cn.reghao.tnb.content.app.disk.model.dto;
+
+import lombok.Getter;
+
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2023-12-24 00:39:18
+ */
+@Getter
+public class MoveFile {
+    private Integer type;
+    private String pid;
+    private List<String> fileIds;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/dto/RenameFile.java

@@ -0,0 +1,19 @@
+package cn.reghao.tnb.content.app.disk.model.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+/**
+ * @author reghao
+ * @date 2023-11-15 19:18:39
+ */
+@Setter
+@Getter
+public class RenameFile {
+    @NotBlank
+    private String fileId;
+    @NotBlank
+    private String newFilename;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/dto/SearchForm.java

@@ -0,0 +1,17 @@
+package cn.reghao.tnb.content.app.disk.model.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @author reghao
+ * @date 2023-12-22 20:41:02
+ */
+@Setter
+@Getter
+public class SearchForm {
+    private Integer pageNo;
+    private String path;
+    private Integer fileType;
+    private String filename;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/po/CamDevice.java

@@ -0,0 +1,37 @@
+package cn.reghao.tnb.content.app.disk.model.po;
+
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.jutil.jdk.db.BaseObject;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author reghao
+ * @date 2024-02-06 14:46:43
+ */
+@NoArgsConstructor
+@Setter
+@Getter
+public class CamDevice extends BaseObject<Integer> {
+    private String deviceId;
+    private Long camId;
+    private String camName;
+    private Boolean online;
+    private Boolean state;
+    private LocalDateTime addAt;
+    private Long owner;
+    private String pushUrl;
+    private String pullUrl;
+
+    public CamDevice(Long camId, String camName) {
+        this.camId = camId;
+        this.camName = camName;
+        this.online = true;
+        this.state = false;
+        this.addAt = LocalDateTime.now();
+        this.owner = UserContext.getUserId();
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/po/CamRecord.java

@@ -0,0 +1,33 @@
+package cn.reghao.tnb.content.app.disk.model.po;
+
+import cn.reghao.jutil.jdk.db.BaseObject;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author reghao
+ * @date 2023-12-08 16:03:05
+ */
+@NoArgsConstructor
+@Setter
+@Getter
+public class CamRecord extends BaseObject<Integer> {
+    private Long camId;
+    private Long recordId;
+    private String videoFileId;
+    private String coverUrl;
+    private LocalDateTime startAt;
+    private Integer duration;
+
+    public CamRecord(long camId, long recordId, String videoFileId, String coverUrl, int duration, LocalDateTime startAt) {
+        this.camId = camId;
+        this.recordId = recordId;
+        this.videoFileId = videoFileId;
+        this.coverUrl = coverUrl;
+        this.startAt = startAt;
+        this.duration = duration;
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/po/NetDisk.java

@@ -0,0 +1,58 @@
+package cn.reghao.tnb.content.app.disk.model.po;
+
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.jutil.jdk.db.BaseObject;
+import cn.reghao.oss.sdk.model.constant.ObjectType;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2023-11-11 00:06:21
+ */
+@NoArgsConstructor
+@AllArgsConstructor
+@Setter
+@Getter
+public class NetDisk extends BaseObject<Integer> {
+    private Integer channelCode;
+    private String fileId;
+    private String pid;
+    private String path;
+    private String filename;
+    private Integer fileType;
+    private String sha256sum;
+    private Long size;
+    private Long owner;
+    private transient List<NetDisk> children = new ArrayList<>();
+
+    public NetDisk(String fileId, String pid, String path, String filename) {
+        this.channelCode = 0;
+        this.fileId = fileId;
+        this.pid = pid;
+        this.path = path;
+        this.filename = filename;
+        this.fileType = ObjectType.Dir.getCode();
+        this.sha256sum = "0";
+        this.size = 0L;
+        this.owner = UserContext.getUserId();
+    }
+
+    public NetDisk(int channelCode, String fileId, String pid, String path, String filename,
+                   int fileType, String sha256sum, long size) {
+        this.channelCode = channelCode;
+        this.fileId = fileId;
+        this.pid = pid;
+        this.path = path;
+        this.filename = filename;
+        this.fileType = fileType;
+        this.sha256sum = sha256sum;
+        this.size = size;
+        this.owner = UserContext.getUserId();
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/po/UserActivity.java

@@ -0,0 +1,29 @@
+package cn.reghao.tnb.content.app.disk.model.po;
+
+import cn.reghao.jutil.jdk.db.BaseObject;
+import cn.reghao.tnb.common.auth.UserContext;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+/**
+ * @author reghao
+ * @date 2024-08-30 20:51:33
+ */
+public class UserActivity extends BaseObject<Integer> {
+    private String id;
+    private Integer activity;
+    private LocalDateTime createTime;
+    private Long createBy;
+
+    public UserActivity() {
+        this.id = UUID.randomUUID().toString().replace("-", "");
+        this.activity = 1;
+        this.createTime = LocalDateTime.now();
+        this.createBy = UserContext.getUserId();
+    }
+
+    public void setCreateBy(Long createBy) {
+        this.createBy = createBy;
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/query/CamDeviceQuery.java

@@ -0,0 +1,56 @@
+package cn.reghao.tnb.content.app.disk.model.query;
+
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2025-08-29 20:08:34
+ */
+@Getter
+public class CamDeviceQuery {
+    private Long camId;
+    private String camName;
+    private String deviceId;
+    private Long owner;
+
+    private CamDeviceQuery(Builder builder) {
+        this.camId = builder.camId;
+        this.camName = builder.camName;
+        this.deviceId = builder.deviceId;
+        this.owner = builder.owner;
+    }
+
+    public static final class Builder {
+        private Long camId;
+        private String camName;
+        private String deviceId;
+        private Long owner;
+
+        public Builder() {
+        }
+
+        public Builder camId(long camId) {
+            this.camId = camId;
+            return this;
+        }
+
+        public Builder camName(String camName) {
+            this.camName = camName;
+            return this;
+        }
+
+        public Builder deviceId(String deviceId) {
+            this.deviceId = deviceId;
+            return this;
+        }
+
+        public Builder owner(long owner) {
+            this.owner = owner;
+            return this;
+        }
+
+        public CamDeviceQuery build() {
+            return new CamDeviceQuery(this);
+        }
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/query/DiskQuery.java

@@ -0,0 +1,72 @@
+package cn.reghao.tnb.content.app.disk.model.query;
+
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2025-08-29 20:09:08
+ */
+@Getter
+public class DiskQuery {
+    private Integer fileType;
+    private Long owner;
+    private String pid;
+    private String fileId;
+    private String path;
+    private String sha256sum;
+
+    private DiskQuery(Builder builder) {
+        this.fileType = builder.fileType;
+        this.owner = builder.owner;
+        this.pid = builder.pid;
+        this.fileId = builder.fileId;
+        this.path = builder.path;
+        this.sha256sum = builder.sha256sum;
+    }
+
+    public static final class Builder {
+        private Integer fileType;
+        private Long owner;
+        private String pid;
+        private String fileId;
+        private String path;
+        private String sha256sum;
+
+        public Builder() {
+        }
+
+        public Builder fileType(int fileType) {
+            this.fileType = fileType;
+            return this;
+        }
+
+        public Builder owner(long owner) {
+            this.owner = owner;
+            return this;
+        }
+
+        public Builder pid(String pid) {
+            this.pid = pid;
+            return this;
+        }
+
+        public Builder fileId(String fileId) {
+            this.fileId = fileId;
+            return this;
+        }
+
+        public Builder path(String path) {
+            this.path = path;
+            return this;
+        }
+
+        public Builder sha256sum(String sha256sum) {
+            this.sha256sum = sha256sum;
+            return this;
+        }
+
+        public DiskQuery build() {
+            return new DiskQuery(this);
+        }
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/CamRecordInfo.java

@@ -0,0 +1,33 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import cn.reghao.jutil.jdk.converter.DateTimeConverter;
+import cn.reghao.tnb.content.app.disk.model.po.CamRecord;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2024-03-22 22:13:31
+ */
+@Getter
+@AllArgsConstructor
+public class CamRecordInfo {
+    private Long camId;
+    private Long recordId;
+    private String startAt;
+    private Integer duration;
+
+    public CamRecordInfo(CamRecord camRecord) {
+        this.camId = camRecord.getCamId();
+        this.recordId = camRecord.getRecordId();
+        this.startAt = DateTimeConverter.format(camRecord.getStartAt());
+        this.duration = camRecord.getDuration();
+    }
+
+    public CamRecordInfo(RecordInfo recordInfo) {
+        this.camId = recordInfo.getCamId();
+        this.recordId = recordInfo.getRecordId();
+        this.startAt = DateTimeConverter.format(recordInfo.getStartAt());
+        this.duration = recordInfo.getDuration();
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/CamRecordVo.java

@@ -0,0 +1,20 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author reghao
+ * @date 2024-02-03 18:10:01
+ */
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+public class CamRecordVo {
+    private Long camId;
+    private Long recordId;
+    private String recordTime;
+    private String coverUrl;
+    private String videoUrl;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/CamUrl.java

@@ -0,0 +1,26 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2025-03-06 20:27:53
+ */
+@Getter
+public class CamUrl {
+    private String urlType;
+    private String videoUrl;
+    private boolean liveUrl;
+
+    public CamUrl(String videoUrl) {
+        this.urlType = "mp4";
+        this.videoUrl = videoUrl;
+        this.liveUrl = false;
+    }
+
+    public CamUrl(String videoUrl, boolean liveUrl) {
+        this.urlType = "flv";
+        this.videoUrl = videoUrl;
+        this.liveUrl = liveUrl;
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/DiskFileInfo.java

@@ -0,0 +1,20 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2024-10-30 17:37:17
+ */
+@AllArgsConstructor
+@Getter
+public class DiskFileInfo {
+    private String fileId;
+    private String filename;
+    private String url;
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/FileInfo.java

@@ -0,0 +1,41 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import cn.reghao.jutil.jdk.converter.DateTimeConverter;
+import cn.reghao.oss.sdk.model.constant.ObjectType;
+import cn.reghao.oss.sdk.model.dto.ObjectInfo;
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2024-10-30 10:24:28
+ */
+@AllArgsConstructor
+@Getter
+public class FileInfo {
+    private String fileId;
+    private String filename;
+    private String updateTime;
+    private String size;
+    private int fileType;
+    private String fileTypeStr;
+
+    public FileInfo(ObjectInfo objectInfo, String size) {
+        this.fileId = objectInfo.getObjectId();
+        this.filename = objectInfo.getFilename();
+        this.updateTime = objectInfo.getUpdateTime();
+        this.size = size;
+        this.fileType = objectInfo.getFileType();
+        this.fileTypeStr = ObjectType.getDescByCode(objectInfo.getFileType());
+    }
+
+    public FileInfo(NetDisk netDisk, String size) {
+        this.fileId = netDisk.getFileId();
+        this.filename = netDisk.getFilename();
+        this.updateTime = DateTimeConverter.format(netDisk.getUpdateTime());
+        this.size = size;
+        this.fileType = netDisk.getFileType();
+        this.fileTypeStr = ObjectType.getDescByCode(netDisk.getFileType());
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/FileUrl.java

@@ -0,0 +1,34 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * @author reghao
+ * @date 2023-11-13 10:00:50
+ */
+@NoArgsConstructor
+@Setter
+@Getter
+@Deprecated
+public class FileUrl {
+    private String fileId;
+    private int fileType;
+    private String originalUrl;
+    private String url;
+    private String filename;
+    private String objectName;
+    private Integer channelCode;
+
+    public FileUrl(NetDisk netDisk) {
+        this.fileId = netDisk.getFileId();
+        this.fileType = netDisk.getFileType();
+        this.originalUrl = netDisk.getFileId();
+        this.url = netDisk.getFileId();
+        this.filename = netDisk.getFilename();
+        this.objectName = netDisk.getFilename();
+        this.channelCode = netDisk.getChannelCode();
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/FolderTree.java

@@ -0,0 +1,30 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author reghao
+ * @date 2023-11-14 10:55:43
+ */
+@Getter
+public class FolderTree {
+    private String pid;
+    private String fileId;
+    private String label;
+    private String value;
+    private String icon;
+    private List<FolderTree> children;
+
+    public FolderTree(NetDisk diskFile) {
+        this.pid = diskFile.getPid();
+        this.fileId = diskFile.getFileId();
+        this.label = diskFile.getPath();
+        this.value = diskFile.getFilename();
+        this.icon = "el-icon-lollipop";
+        this.children = new ArrayList<>();
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/MarkDay.java

@@ -0,0 +1,15 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+/**
+ * @author reghao
+ * @date 2024-08-31 20:41:12
+ */
+public class MarkDay {
+    private String day;
+    private String style;
+
+    public MarkDay(String day) {
+        this.day = day;
+        this.style = "red";
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/NamePath.java

@@ -0,0 +1,15 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2023-11-15 18:45:39
+ */
+@AllArgsConstructor
+@Getter
+public class NamePath {
+    private String filename;
+    private String path;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/NetDiskCount.java

@@ -0,0 +1,19 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * @author reghao
+ * @date 2025-08-21 21:44:21
+ */
+@AllArgsConstructor
+@NoArgsConstructor
+@Setter
+@Getter
+public class NetDiskCount {
+    private int fileType;
+    private long total;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/RecordInfo.java

@@ -0,0 +1,17 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.Getter;
+
+import java.time.LocalDateTime;
+
+/**
+ * @author reghao
+ * @date 2025-08-28 22:57:45
+ */
+@Getter
+public class RecordInfo {
+    private long camId;
+    private long recordId;
+    private LocalDateTime startAt;
+    private int duration;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/model/vo/ResultCount.java

@@ -0,0 +1,13 @@
+package cn.reghao.tnb.content.app.disk.model.vo;
+
+import lombok.Getter;
+
+/**
+ * @author reghao
+ * @date 2025-08-28 22:57:52
+ */
+@Getter
+public class ResultCount {
+    private String key;
+    private int value;
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/service/CamRecordService.java

@@ -0,0 +1,197 @@
+package cn.reghao.tnb.content.app.disk.service;
+
+import cn.reghao.file.api.iface.OssService;
+import cn.reghao.jutil.jdk.converter.DateTimeConverter;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.jutil.jdk.result.Result;
+import cn.reghao.jutil.tool.id.SnowFlake;
+import cn.reghao.oss.sdk.model.dto.ObjectInfo;
+import cn.reghao.oss.sdk.model.dto.media.ImageInfo;
+import cn.reghao.oss.sdk.model.dto.media.VideoInfo;
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.tnb.content.app.disk.db.mapper.CamDeviceMapper;
+import cn.reghao.tnb.content.app.disk.db.mapper.CamRecordMapper;
+import cn.reghao.tnb.content.app.disk.model.dto.CamRecordDto;
+import cn.reghao.tnb.content.app.disk.model.po.CamDevice;
+import cn.reghao.tnb.content.app.disk.model.po.CamRecord;
+import cn.reghao.tnb.content.app.disk.model.query.CamDeviceQuery;
+import cn.reghao.tnb.content.app.disk.model.vo.*;
+import org.apache.dubbo.config.annotation.DubboReference;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author reghao
+ * @date 2023-12-08 16:06:39
+ */
+@Service
+public class CamRecordService {
+    @DubboReference(check = false, timeout = 60_000)
+    private OssService ossService;
+
+    private final SnowFlake idGenerator;
+    private final CamDeviceMapper camDeviceMapper;
+    private final CamRecordMapper camRecordMapper;
+
+    public CamRecordService(CamDeviceMapper camDeviceMapper, CamRecordMapper camRecordMapper) {
+        this.idGenerator = new SnowFlake(1L, 1L);
+        this.camDeviceMapper = camDeviceMapper;
+        this.camRecordMapper = camRecordMapper;
+    }
+
+    @Deprecated
+    public Result add(CamRecordDto camRecordDto) {
+        try {
+            int coverChannelCode = camRecordDto.getCoverChannelCode();
+            String coverFileId = camRecordDto.getCoverFileId();
+            ImageInfo imageInfo = ossService.getImageInfo(coverChannelCode, coverFileId);
+            String coverUrl = imageInfo.getUrl();
+
+            int videoChannelCode = camRecordDto.getVideoChannelCode();
+            String videoFileId = camRecordDto.getVideoFileId();
+            VideoInfo videoInfo = ossService.getVideoInfo(videoChannelCode, videoFileId);
+
+            String camName = camRecordDto.getCamName();
+            CamDeviceQuery camDeviceQuery = new CamDeviceQuery.Builder()
+                    .camName(camName)
+                    .build();
+            Page page = new Page(1, 10);
+            List<CamDevice> camDeviceList = camDeviceMapper.findCamDeviceQueryByPage(camDeviceQuery, page);
+            long camId = camDeviceList.get(0).getCamId();
+            int duration = videoInfo.getDuration();
+            long recordId = idGenerator.nextId();
+            long startAt = camRecordDto.getStartAt();
+            LocalDateTime startAt1 = DateTimeConverter.localDateTime(startAt);
+            CamRecord camRecord = new CamRecord(camId, recordId, videoFileId, coverUrl, duration, startAt1);
+            camRecordMapper.save(camRecord);
+            return Result.success();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return Result.fail("");
+    }
+
+    public Result add(String videoFileId, CamRecordDto camRecordDto) {
+        String coverUrl = "";
+        String camName = camRecordDto.getCamName();
+        CamDeviceQuery camDeviceQuery = new CamDeviceQuery.Builder()
+                .camName(camName)
+                .build();
+        Page page = new Page(1, 10);
+        List<CamDevice> camDeviceList = camDeviceMapper.findCamDeviceQueryByPage(camDeviceQuery, page);
+        long camId = camDeviceList.get(0).getCamId();
+        int duration = camRecordDto.getDuration();
+        long recordId = idGenerator.nextId();
+        long startAt = camRecordDto.getStartAt();
+        LocalDateTime startAt1 = DateTimeConverter.localDateTime(startAt);
+        CamRecord camRecord = new CamRecord(camId, recordId, videoFileId, coverUrl, duration, startAt1);
+        camRecordMapper.save(camRecord);
+        return Result.success();
+    }
+
+    /**
+     * 一个天中的监控记录
+     *
+     * @param dayStr 2024-08-31 格式的字符串
+     * @return
+     * @date 2024-08-31 18:08:972
+     */
+    public List<CamRecordInfo> getCamRecords(Long camId, String dayStr) {
+        List<RecordInfo> list = camRecordMapper.findByCamIdAndStartAt(camId, dayStr);
+        return list.stream().map(CamRecordInfo::new).collect(Collectors.toList());
+    }
+
+    public CamRecordVo getCamRecord(long recordId) {
+        try {
+            CamRecord camRecord = camRecordMapper.findByRecordId(recordId);
+            if (camRecord != null) {
+                String recordTime = DateTimeConverter.format(camRecord.getStartAt());
+                String coverUrl = camRecord.getCoverUrl();
+                String videoFileId = camRecord.getVideoFileId();
+                ObjectInfo diskFile = ossService.getObjectInfo(111, videoFileId);
+                if (diskFile != null) {
+                    long loginUser = UserContext.getUserId();
+                    /*long owner = diskFile.getOwner();
+                    if (loginUser == owner) {
+                        String videoUrl = String.format("/%s", diskFile.getObjectName());
+                        return new CamRecordVo(camRecord.getCamId(), recordId, recordTime, coverUrl, videoUrl);
+                    }*/
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    /**
+     * 一个月中的哪些天有监控记录
+     *
+     * @param yearMonth 2024-08 格式的字符串
+     * @return
+     * @date 2024-08-31 20:08:873
+     */
+    public List<MarkDay> getDaysInMonth(Long camId, String yearMonth) {
+        return camRecordMapper.findGroupByYearMonth(camId, yearMonth).stream()
+                .map(resultCount -> {
+                    String day = resultCount.getKey();
+                    return new MarkDay(day);
+                })
+                .collect(Collectors.toList());
+    }
+
+    private List<String> findByYearMonth(long camId, String yearMonth) {
+        /*Specification<CamRecord> specification = (root, query, cb) -> {
+            Predicate fp = cb.conjunction();
+            Predicate p1 = cb.equal(root.get("camId").as(Long.class), camId);
+            fp = cb.and(fp, p1);
+            return query.where(fp).groupBy(root.get("startAt")).getRestriction();
+        };
+        camRecordMapper.findAll(specification);*/
+        return Collections.emptyList();
+    }
+
+    @Deprecated
+    public CamRecordVo getLatestRecord(long camId) {
+        CamDeviceQuery camDeviceQuery = new CamDeviceQuery.Builder()
+                .camId(camId)
+                .build();
+        Page page = new Page(1, 10);
+        List<CamDevice> camDeviceList = camDeviceMapper.findCamDeviceQueryByPage(camDeviceQuery, page);
+        CamDevice camDevice = camDeviceList.get(0);
+        if (camDevice.getState()) {
+            String videoUrl = camDevice.getPullUrl();
+            CamUrl camUrl = new CamUrl(videoUrl, true);
+        }
+
+        //PageRequest pageRequest = PageRequest.of(0, 1, Sort.by(Sort.Direction.DESC, "createTime"));
+        List<CamRecord> camRecordList = camRecordMapper.findByCamId(camId, page);
+        if (camRecordList.isEmpty()) {
+            return null;
+        }
+
+        CamRecord camRecord = camRecordList.get(0);
+        String recordTime = DateTimeConverter.format(camRecord.getStartAt());
+        long recordId = camRecord.getRecordId();
+        String coverUrl = camRecord.getCoverUrl();
+        String videoFileId = camRecord.getVideoFileId();
+
+        /*ObjectInfo diskFile = ossService.getObjectInfo(111, videoFileId);
+        if (diskFile != null) {
+            long loginUser = UserContext.getUserId();
+            long owner = diskFile.getOwner();
+            if (loginUser == owner) {
+                String videoUrl = String.format("/%s", diskFile.getObjectName());
+                return new CamRecordVo(camRecord.getCamId(), recordId, recordTime, coverUrl, videoUrl);
+            }
+        }*/
+
+        return null;
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/service/CamService.java

@@ -0,0 +1,122 @@
+package cn.reghao.tnb.content.app.disk.service;
+
+import cn.reghao.jutil.jdk.converter.DateTimeConverter;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.jutil.jdk.db.PageList;
+import cn.reghao.jutil.jdk.result.Result;
+import cn.reghao.jutil.tool.id.SnowFlake;
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.tnb.content.app.disk.db.mapper.CamDeviceMapper;
+import cn.reghao.tnb.content.app.disk.db.mapper.CamRecordMapper;
+import cn.reghao.tnb.content.app.disk.db.mapper.UserActivityMapper;
+import cn.reghao.tnb.content.app.disk.model.po.CamDevice;
+import cn.reghao.tnb.content.app.disk.model.po.CamRecord;
+import cn.reghao.tnb.content.app.disk.model.po.UserActivity;
+import cn.reghao.tnb.content.app.disk.model.query.CamDeviceQuery;
+import cn.reghao.tnb.content.app.disk.model.vo.CamRecordVo;
+import cn.reghao.tnb.content.app.geo.model.vo.SelectOption;
+import cn.reghao.tnb.content.app.util.RandomUtil;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author reghao
+ * @date 2024-08-27 19:50:56
+ */
+@Service
+public class CamService {
+    private final SnowFlake idGenerator;
+    private final CamDeviceMapper camDeviceMapper;
+    private final CamRecordMapper camRecordMapper;
+    private final UserActivityMapper userActivityMapper;
+
+    public CamService(CamDeviceMapper camDeviceMapper, CamRecordMapper camRecordMapper,
+                      UserActivityMapper userActivityMapper) {
+        this.idGenerator = new SnowFlake(1L, 1L);
+        this.camDeviceMapper = camDeviceMapper;
+        this.camRecordMapper = camRecordMapper;
+        this.userActivityMapper = userActivityMapper;
+    }
+
+    public Result addCam(String camName) {
+        long camId = idGenerator.nextId();
+        CamDevice camDevice = new CamDevice(camId, camName);
+
+        camDeviceMapper.save(camDevice);
+        return Result.success();
+    }
+
+    public List<SelectOption> getCamList() {
+        long loginUser = UserContext.getUserId();
+        CamDeviceQuery camDeviceQuery = new CamDeviceQuery.Builder()
+                .owner(loginUser)
+                .build();
+        Page page = new Page(1, 100);
+        List<CamDevice> camDeviceList = camDeviceMapper.findCamDeviceQueryByPage(camDeviceQuery, page);
+        int total = camDeviceList.size();
+
+        return camDeviceList.stream().map(camDevice -> {
+            long camId = camDevice.getCamId();
+            String camName = camDevice.getCamName();
+            return new SelectOption(camId+"", camName);
+        }).collect(Collectors.toList());
+    }
+
+    public PageList<CamDevice> getCamDevices(int pageNumber) {
+        int pageSize = 10;
+        long loginUser = UserContext.getUserId();
+        CamDeviceQuery camDeviceQuery = new CamDeviceQuery.Builder()
+                .owner(loginUser)
+                .build();
+        Page page = new Page(pageNumber, pageSize);
+        List<CamDevice> camDeviceList = camDeviceMapper.findCamDeviceQueryByPage(camDeviceQuery, page);
+        int total = camDeviceList.size();
+        return PageList.pageList(pageNumber, pageSize, total, camDeviceList);
+    }
+
+    public CamRecordVo getLatestRecord(long camId) {
+        int pageSize = 10;
+        Page page = new Page(1, pageSize);
+        //PageRequest pageRequest = PageRequest.of(0, 1, Sort.by(Sort.Direction.DESC, "createTime"));
+        List<CamRecord> camRecordList = camRecordMapper.findByCamId(camId, page);
+        CamRecord camRecord = camRecordList.get(0);
+        String recordTime = DateTimeConverter.format(camRecord.getStartAt());
+        long recordId = camRecord.getRecordId();
+        String coverUrl = camRecord.getCoverUrl();
+        String videoFileId = camRecord.getVideoFileId();
+        /*DiskFile diskFile = fileService.getDiskFile(videoFileId);
+        if (diskFile != null) {
+            long loginUser = UserContext.getUserId();
+            long owner = diskFile.getOwner();
+            if (loginUser == owner) {
+                String videoUrl = String.format("/%s", diskFile.getObjectName());
+                return new CamRecordVo(camRecord.getCamId(), recordId, recordTime, coverUrl, videoUrl);
+            }
+        }*/
+
+        return null;
+    }
+
+    public void setCamState(String deviceId) throws IOException {
+    }
+
+    public void updateCamState(String deviceId, boolean onStream) {
+    }
+
+    public void addActivity() {
+        int total = RandomUtil.getNumber(5, 20);
+        List<UserActivity> list = new ArrayList<>();
+        while (total-- > 0) {
+            UserActivity userActivity = new UserActivity();
+            userActivity.setCreateBy(-1L);
+            list.add(userActivity);
+        }
+
+        list.add(new UserActivity());
+        userActivityMapper.saveAll(list);
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/service/NetDiskQuery.java

@@ -0,0 +1,192 @@
+package cn.reghao.tnb.content.app.disk.service;
+
+import cn.reghao.jutil.jdk.converter.ByteConverter;
+import cn.reghao.jutil.jdk.converter.ByteType;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.jutil.jdk.db.PageList;
+import cn.reghao.oss.sdk.model.constant.ObjectType;
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.tnb.content.app.disk.db.mapper.NetDiskMapper;
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import cn.reghao.tnb.content.app.disk.model.query.DiskQuery;
+import cn.reghao.tnb.content.app.disk.model.vo.*;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+/**
+ * @author reghao
+ * @date 2023-11-10 15:16:35
+ */
+@Service
+public class NetDiskQuery {
+    private final NetDiskMapper netDiskMapper;
+    private final ByteConverter byteConverter;
+
+    public NetDiskQuery(NetDiskMapper netDiskMapper) {
+        this.netDiskMapper = netDiskMapper;
+        this.byteConverter = new ByteConverter();
+    }
+
+    public List<FolderTree> getFolders() {
+        long loginUser = UserContext.getUserId();
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileType(ObjectType.Dir.getCode())
+                .owner(loginUser)
+                .build();
+
+        Page page = new Page(1, 1000);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        Map<String, FolderTree> map = netDiskList.stream()
+                .map(FolderTree::new)
+                .collect(Collectors.toMap(FolderTree::getFileId, diskFile -> diskFile));
+
+        Map<String, FolderTree> tree = new TreeMap<>();
+        netDiskList.forEach(diskFile -> {
+            String pid = diskFile.getPid();
+            String fileId = diskFile.getFileId();
+            FolderTree folderTree = map.get(fileId);
+
+            if (pid.equals("0")) {
+                tree.put(fileId, folderTree);
+            } else {
+                FolderTree parent = map.get(pid);
+                parent.getChildren().add(folderTree);
+            }
+        });
+
+        String key = tree.keySet().iterator().next();
+        FolderTree root = tree.get(key);
+        return List.of(root);
+    }
+
+    public NetDisk findByPath(String path) {
+        long owner = UserContext.getUserId();
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .path(path)
+                .owner(owner)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        return netDiskList.isEmpty() ? null : netDiskList.get(0);
+    }
+
+    public PageList<FileInfo> findByPid(int pageSize, int pageNumber, String pid) {
+        String[] sortProps = {"fileType", "filename"};
+
+        long loginUser = UserContext.getUserId();
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .pid(pid)
+                .owner(loginUser)
+                .build();
+
+        Page page = new Page(pageSize, pageNumber);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+
+        List<FileInfo> list = netDiskList.stream().map(netDisk -> {
+            String sizeStr = byteConverter.convert(ByteType.Bytes, netDisk.getSize());
+            return new FileInfo(netDisk, sizeStr);
+        }).collect(Collectors.toList());
+
+        int total = list.size();
+        return PageList.pageList(pageNumber, pageSize, total, list);
+    }
+
+    public PageList<FileInfo> findByFileType(int pageSize, int pageNumber, int fileType) {
+        String[] sortProps = {"filename"};
+
+        long loginUser = UserContext.getUserId();
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileType(fileType)
+                .owner(loginUser)
+                .build();
+
+        Page page = new Page(pageSize, pageNumber);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        List<FileInfo> list = netDiskList.stream().map(netDisk -> {
+            String sizeStr = byteConverter.convert(ByteType.Bytes, netDisk.getSize());
+            return new FileInfo(netDisk, sizeStr);
+        }).collect(Collectors.toList());
+
+        int total = list.size();
+        return PageList.pageList(pageNumber, pageSize, total, list);
+    }
+
+    public PageList<DiskFileInfo> getImageFiles(ObjectType objectType, int pageSize, int pageNumber) {
+        String[] props = {"filename"};
+        long loginUser = UserContext.getUserId();
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileType(objectType.getCode())
+                .owner(loginUser)
+                .build();
+
+        Page page = new Page(pageSize, pageNumber);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        List<DiskFileInfo> list = netDiskList.stream().map(netDisk -> {
+            String fileId = netDisk.getFileId();
+            String filename = netDisk.getFilename();
+            /*DiskFile diskFile = fileService.getDiskFile(fileId);
+            if (diskFile != null) {
+                long owner = diskFile.getOwner();
+                if (owner == loginUser) {
+                    String url = String.format("/%s", diskFile.getObjectName());
+                    return new DiskFileInfo(fileId, filename, url);
+                }
+            }*/
+            return new DiskFileInfo(null, null, null);
+        }).filter(Objects::nonNull).collect(Collectors.toList());
+
+        int total = list.size();
+        return PageList.pageList(pageNumber, pageSize, total, list);
+    }
+
+    public FileUrl getFileUrl(String fileId) {
+        long loginUser = UserContext.getUserId();
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileId(fileId)
+                .owner(loginUser)
+                .build();
+
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        if (!netDiskList.isEmpty()) {
+            NetDisk netDisk = netDiskList.get(0);
+            long owner = netDisk.getOwner();
+            if (owner != loginUser) {
+                return null;
+            }
+
+            String objectId = netDisk.getFileId();
+            /*DiskFile diskFile = fileService.getDiskFile(objectId);
+            if (diskFile != null) {
+                return new FileUrl(diskFile);
+            }*/
+        }
+
+        return null;
+    }
+
+    @Cacheable(cacheNames = "netdisk", key = "#owner + '-' + #path")
+    public NetDisk getNetDisk(long owner, String path) {
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .path(path)
+                .owner(owner)
+                .build();
+
+
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        return netDiskList.isEmpty() ? null : netDiskList.get(0);
+    }
+
+    public Map<Integer, NetDiskCount> getFileTypeCount() {
+        long loginUser = UserContext.getUserId();
+        List<NetDiskCount> list = netDiskMapper.findFileTypeCountByGroup(loginUser);
+        return list.stream().collect(Collectors.toMap(NetDiskCount::getFileType, k -> k));
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/disk/service/NetDiskService.java

@@ -0,0 +1,645 @@
+package cn.reghao.tnb.content.app.disk.service;
+
+import cn.reghao.jutil.jdk.converter.DateTimeConverter;
+import cn.reghao.jutil.jdk.db.Page;
+import cn.reghao.jutil.jdk.result.Result;
+import cn.reghao.oss.sdk.model.constant.ObjectType;
+import cn.reghao.oss.sdk.model.dto.ObjectInfo;
+import cn.reghao.tnb.common.auth.UserContext;
+import cn.reghao.tnb.common.util.StringUtil;
+import cn.reghao.tnb.content.app.disk.db.mapper.NetDiskMapper;
+import cn.reghao.tnb.content.app.disk.model.dto.CreateDir;
+import cn.reghao.tnb.content.app.disk.model.dto.MoveFile;
+import cn.reghao.tnb.content.app.disk.model.po.NetDisk;
+import cn.reghao.tnb.content.app.disk.model.query.DiskQuery;
+import cn.reghao.tnb.content.app.disk.model.vo.NamePath;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author reghao
+ * @date 2023-11-10 23:48:48
+ */
+@Slf4j
+@Service
+public class NetDiskService {
+    private final NetDiskMapper netDiskMapper;
+
+    public NetDiskService(NetDiskMapper netDiskMapper) {
+        this.netDiskMapper = netDiskMapper;
+    }
+
+    public String createFolder(String parentPath, String folderName, long owner) {
+        String pid = getFolderId(parentPath, owner, false);
+        if (pid == null) {
+            return null;
+        }
+
+        NamePath namePath = getUniqueNamePath(parentPath, folderName, owner);
+        String fileId = UUID.randomUUID().toString().replace("-", "");
+        NetDisk diskFile = new NetDisk(fileId, pid, namePath.getPath(), namePath.getFilename());
+        netDiskMapper.save(diskFile);
+        return fileId;
+    }
+
+    public synchronized String createDirs(String dirPath, long owner) {
+        String pid = "0";
+        if (dirPath.equals("/")) {
+            return pid;
+        }
+
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .path(dirPath)
+                .owner(owner)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        if (!netDiskList.isEmpty()) {
+            return netDiskList.get(0).getFileId();
+        }
+
+        String savedDirPath = dirPath;
+        List<String> list = new ArrayList<>();
+        list.add(dirPath);
+
+        int idx = dirPath.lastIndexOf("/");
+        while (idx != 0) {
+            dirPath = dirPath.substring(0, idx);
+            list.add(dirPath);
+            idx = dirPath.lastIndexOf("/");
+        }
+        Collections.reverse(list);
+
+        for (String parent : list) {
+            diskQuery = new DiskQuery.Builder()
+                    .path(parent)
+                    .owner(owner)
+                    .build();
+            netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+            if (!netDiskList.isEmpty()) {
+                pid = netDiskList.get(0).getFileId();
+            } else {
+                String fileId = UUID.randomUUID().toString().replace("-", "");
+                String path = parent;
+                String dirname = parent.substring(parent.lastIndexOf("/")+1);
+                netDiskMapper.save(new NetDisk(fileId, pid, path, dirname));
+                pid = fileId;
+            }
+        }
+
+        diskQuery = new DiskQuery.Builder()
+                .path(savedDirPath)
+                .owner(owner)
+                .build();
+        netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        return netDiskList.get(0).getFileId();
+    }
+
+    public boolean checkFile(CreateDir createDir) {
+        long owner = UserContext.getUserId();
+        String path = createDir.getPath();
+        String sha256sum = createDir.getSha256sum();
+
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .path(path)
+                .sha256sum(sha256sum)
+                .owner(owner)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        return !netDiskList.isEmpty();
+    }
+
+    public Result addNetDisk(ObjectInfo diskFile, String path) {
+        long owner = UserContext.getUserId();
+        String uploadId = diskFile.getObjectId();
+        try {
+            String filename = diskFile.getFilename();
+            long size = diskFile.getSize();
+            int fileType = diskFile.getFileType();
+            String sha256sum = diskFile.getSha256sum();
+
+            String parentPath;
+            if (path.equals("/")) {
+                parentPath = "/";
+            } else {
+                File file = new File(path);
+                parentPath = file.getParent();
+            }
+            String pid = createDirs(parentPath, owner);
+            int channelCode = 111;
+            NetDisk netDisk = new NetDisk(channelCode, uploadId, pid, path, filename, fileType, sha256sum, size);
+            netDiskMapper.save(netDisk);
+            return Result.success();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return Result.fail("上传文件失败");
+    }
+
+    private String getFolderId(String parent, long owner, boolean isFileId) {
+        if ("/".equals(parent)) {
+            return "0";
+        }
+
+        NetDisk parentFile;
+        if (isFileId) {
+            DiskQuery diskQuery = new DiskQuery.Builder()
+                    .path(parent)
+                    .build();
+            Page page = new Page(1, 10);
+            List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+            parentFile = netDiskList.get(0);
+        } else {
+            DiskQuery diskQuery = new DiskQuery.Builder()
+                    .path(parent)
+                    .owner(owner)
+                    .build();
+            Page page = new Page(1, 10);
+            List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+            parentFile = netDiskList.get(0);
+        }
+
+        if (parentFile == null) {
+            String msg = String.format("目录 %s 不存在", parent);
+            return null;
+        }
+
+        if (parentFile.getFileType() != ObjectType.Dir.getCode()) {
+            String msg = String.format("%s 不是目录", parent);
+            return null;
+        }
+
+        return parentFile.getFileId();
+    }
+
+    public Result rename(String fileId, String newFilename, long owner) {
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileId(fileId)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        NetDisk current = netDiskList.get(0);
+        if (current == null) {
+            String msg = String.format("file %s not exist", fileId);
+            return Result.fail(msg);
+        }
+
+        String parentPath = getParentPath(current.getPath());
+        String newPath = String.format("%s/%s", parentPath, newFilename);
+
+        diskQuery = new DiskQuery.Builder()
+                .owner(owner)
+                .path(newPath)
+                .build();
+        page = new Page(1, 10);
+        netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        NetDisk netDisk = netDiskList.get(0);
+        if (netDisk != null) {
+            String msg = String.format("filename %s exist", newFilename);
+            return Result.fail(msg);
+        }
+
+        current.setPath(newPath);
+        current.setFilename(newFilename);
+        List<NetDisk> diskFileList = new ArrayList<>();
+        diskFileList.add(current);
+
+        if (current.getFileType() == ObjectType.Dir.getCode()) {
+            getChildren(current.getPath()).stream()
+                    .filter(childFile -> !childFile.getFileId().equals(fileId))
+                    .forEach(childFile -> {
+                        String filename = childFile.getFilename();
+                        NamePath namePath = getUniqueNamePath(newPath, filename, owner);
+
+                        childFile.setPath(namePath.getPath());
+                        childFile.setFilename(namePath.getFilename());
+                        diskFileList.add(childFile);
+                    });
+        }
+
+        if (!diskFileList.isEmpty()) {
+            //diskFile1Repository.updateFilenames(diskFileList);
+        }
+
+        return Result.success();
+    }
+
+    public Result move(MoveFile moveFile, long owner) {
+        String pid = moveFile.getPid();
+        List<String> fileIds = moveFile.getFileIds();
+        boolean copy = moveFile.getType() == 2;
+
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileId(pid)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        NetDisk parentFile = netDiskList.get(0);
+        if (parentFile == null) {
+            String msg = "文件被移动/复制到的位置不存在";
+            return Result.fail(msg);
+        }
+
+        if (parentFile.getFileType() != ObjectType.Dir.getCode()) {
+            String msg = "文件被移动/复制到的位置不是目录";
+            return Result.fail(msg);
+        }
+
+        Set<String> parents = new HashSet<>();
+        String pid1 = parentFile.getPid();
+        parents.add(pid1);
+        while (!pid1.equals("0")) {
+            diskQuery = new DiskQuery.Builder()
+                    .fileId(pid1)
+                    .build();
+            page = new Page(1, 10);
+            netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+            pid1 = netDiskList.get(0).getPid();
+            parents.add(pid1);
+        }
+
+        for (String fileId : fileIds) {
+            if (parents.contains(fileId)) {
+                String msg = "文件被移动/复制到的位置不能是其自身或子目录";
+                return Result.fail(msg);
+            }
+        }
+
+        List<NetDisk> list = findByFileIdContains(fileIds);
+        if (list.isEmpty()) {
+            String msg = "被移动/复制的文件不存在";
+            return Result.fail(msg);
+        }
+
+        String currentPid = list.get(0).getPid();
+        for (int i = 1; i < list.size(); i++) {
+            if (!list.get(i).getPid().equals(currentPid)) {
+                String msg = "被移动/复制的文件必须来自同一目录";
+                return Result.fail(msg);
+            }
+        }
+
+        List<NetDisk> copiedFiles = list.stream()
+                .filter(diskFile -> diskFile.getFileType() != ObjectType.Dir.getCode())
+                .peek(diskFile -> {
+                    setRootPath(diskFile, parentFile, owner);
+                    if (copy) {
+                        reinitDiskFile(diskFile);
+                    }
+                }).collect(Collectors.toList());
+
+        List<NetDisk> list1 = new ArrayList<>();
+        list.stream()
+                .filter(diskFile -> diskFile.getFileType() == ObjectType.Dir.getCode())
+                .forEach(dirFile -> {
+                    List<NetDisk> results = getChildren(dirFile.getPath());
+                    NetDisk diskFile = list2tree(dirFile.getFileId(), results);
+
+                    moveRoot(diskFile, parentFile, copy, owner);
+                    List<NetDisk> list2 = new ArrayList<>();
+                    tree2List(diskFile, list2);
+                    list1.addAll(list2);
+                });
+
+        copiedFiles.addAll(list1);
+        if (!copiedFiles.isEmpty()) {
+            if (copy) {
+                //diskFile1Repository.saveAll(copiedFiles);
+            } else {
+                // diskFile1Repository.updateDiskFiles(copiedFiles);
+            }
+        }
+        return Result.success();
+    }
+
+    public Result move(String pid, List<String> fileIds, boolean copy, long owner) {
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .fileId(pid)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        NetDisk parentFile = netDiskList.get(0);
+        if (parentFile == null) {
+            String msg = "文件被移动/复制到的位置不存在";
+            return Result.fail(msg);
+        }
+
+        if (parentFile.getFileType() != ObjectType.Dir.getCode()) {
+            String msg = "文件被移动/复制到的位置不是目录";
+            return Result.fail(msg);
+        }
+
+        Set<String> parents = new HashSet<>();
+        String pid1 = parentFile.getPid();
+        parents.add(pid1);
+        while (!pid1.equals("0")) {
+            diskQuery = new DiskQuery.Builder()
+                    .fileId(pid1)
+                    .build();
+            page = new Page(1, 10);
+            netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+            pid1 = netDiskList.get(0).getPid();
+            parents.add(pid1);
+        }
+
+        for (String fileId : fileIds) {
+            if (parents.contains(fileId)) {
+                String msg = "文件被移动/复制到的位置不能是其自身或子目录";
+                return Result.fail(msg);
+            }
+        }
+
+        List<NetDisk> list = findByFileIdContains(fileIds);
+        if (list.isEmpty()) {
+            String msg = "被移动/复制的文件不存在";
+            return Result.fail(msg);
+        }
+
+        String currentPid = list.get(0).getPid();
+        for (int i = 1; i < list.size(); i++) {
+            if (!list.get(i).getPid().equals(currentPid)) {
+                String msg = "被移动/复制的文件必须来自同一目录";
+                return Result.fail(msg);
+            }
+        }
+
+        List<NetDisk> copiedFiles = list.stream()
+                .filter(diskFile -> diskFile.getFileType() != ObjectType.Dir.getCode())
+                .peek(diskFile -> {
+                    setRootPath(diskFile, parentFile, owner);
+                    if (copy) {
+                        reinitDiskFile(diskFile);
+                    }
+                }).collect(Collectors.toList());
+
+        List<NetDisk> list1 = new ArrayList<>();
+        list.stream()
+                .filter(diskFile -> diskFile.getFileType() == ObjectType.Dir.getCode())
+                .forEach(dirFile -> {
+                    List<NetDisk> results = getChildren(dirFile.getPath());
+                    NetDisk diskFile = list2tree(dirFile.getFileId(), results);
+
+                    moveRoot(diskFile, parentFile, copy, owner);
+                    List<NetDisk> list2 = new ArrayList<>();
+                    tree2List(diskFile, list2);
+                    list1.addAll(list2);
+                });
+
+        copiedFiles.addAll(list1);
+        if (!copiedFiles.isEmpty()) {
+            if (copy) {
+                netDiskMapper.saveAll(copiedFiles);
+            } else {
+                //diskFile1Repository.updateDiskFiles(list1);
+            }
+        }
+        return Result.success();
+    }
+
+    private void moveRoot(NetDisk current, NetDisk parent, boolean reset, long owner) {
+        String oldParentPath1 = current.getPath();
+        setRootPath(current, parent, owner);
+        if (reset) {
+            reinitDiskFile(current);
+        }
+
+        List<NetDisk> list = current.getChildren();
+        if (!list.isEmpty()) {
+            for (NetDisk child : list) {
+                moveNode(child, current, oldParentPath1, reset);
+            }
+        }
+    }
+
+    private void moveNode(NetDisk current, NetDisk parent, String oldParentPath, boolean reset) {
+        String oldParentPath1 = current.getPath();
+        setNodePath(current, parent, oldParentPath, reset);
+        if (reset) {
+            reinitDiskFile(current);
+        }
+
+        List<NetDisk> list = current.getChildren();
+        if (!list.isEmpty()) {
+            for (NetDisk child : list) {
+                moveNode(child, current, oldParentPath1, reset);
+            }
+        }
+    }
+
+    private void setRootPath(NetDisk current, NetDisk parent, long owner) {
+        String pid = parent.getFileId();
+        String parentPath = parent.getPath();
+
+        String filename = current.getFilename();
+        NamePath namePath = getUniqueNamePath(parentPath, filename, owner);
+        current.setPid(pid);
+        current.setPath(namePath.getPath());
+        current.setFilename(namePath.getFilename());
+    }
+
+    private void setNodePath(NetDisk current, NetDisk parent, String oldParentPath, boolean resetPid) {
+        String pid = parent.getFileId();
+        String parentPath = parent.getPath();
+        String newPath = current.getPath().replace(oldParentPath, parentPath);
+        current.setPath(newPath);
+
+        if (resetPid) {
+            current.setPid(pid);
+        }
+    }
+
+    /**
+     * 重新初始化
+     *
+     * @param
+     * @return
+     * @date 2023-11-17 13:38:20
+     */
+    private void reinitDiskFile(NetDisk diskFile) {
+        String fileId = UUID.randomUUID().toString().replace("-", "");
+        diskFile.setFileId(fileId);
+        diskFile.setId(null);
+        diskFile.setCreateTime(null);
+        diskFile.setUpdateTime(null);
+    }
+
+    public void delete(List<String> fileIds) {
+        List<NetDisk> list = findByFileIdContains(fileIds);
+        List<String> files = list.stream()
+                .filter(diskFile -> diskFile.getFileType() != ObjectType.Dir.getCode())
+                .map(NetDisk::getFileId)
+                .collect(Collectors.toList());
+        if (!files.isEmpty()) {
+            //diskFile1Repository.updateDeleteFiles(files);
+        }
+
+        List<String> files1 = list.stream()
+                .filter(diskFile -> diskFile.getFileType() == ObjectType.Dir.getCode())
+                .map(diskFile1 -> getChildren(diskFile1.getPath()))
+                .flatMap(Collection::stream)
+                .map(NetDisk::getFileId)
+                .collect(Collectors.toList());
+        if (!files1.isEmpty()) {
+            //diskFile1Repository.updateDeleteFiles(files1);
+        }
+    }
+
+    public void restore(List<String> fileIds) {
+        List<NetDisk> list = findByFileIdContains(fileIds);
+        List<String> files = list.stream()
+                .filter(diskFile -> diskFile.getFileType() != ObjectType.Dir.getCode())
+                .map(NetDisk::getFileId)
+                .collect(Collectors.toList());
+
+        list.stream()
+                .filter(diskFile -> diskFile.getFileType() == ObjectType.Dir.getCode())
+                .map(diskFile1 -> getChildren(diskFile1.getPath()))
+                .flatMap(Collection::stream)
+                .forEach(diskFile -> {
+                    files.add(diskFile.getFileId());
+                });
+
+        if (!files.isEmpty()) {
+            //diskFile1Repository.updateRestoreFiles(files);
+        }
+    }
+
+    public void erase(List<String> fileIds) {
+        List<NetDisk> list = findByFileIdContains(fileIds);
+        List<String> files = list.stream()
+                .filter(diskFile -> diskFile.getFileType() != ObjectType.Dir.getCode())
+                .map(NetDisk::getFileId)
+                .collect(Collectors.toList());
+
+        list.stream()
+                .filter(diskFile -> diskFile.getFileType() == ObjectType.Dir.getCode())
+                .map(diskFile -> findByPathPrefix(diskFile.getPath()))
+                .flatMap(Collection::stream)
+                .forEach(diskFile -> {
+                    files.add(diskFile.getFileId());
+                });
+
+        if (!files.isEmpty()) {
+            //diskFile1Repository.deleteByFileIds(files);
+        }
+    }
+
+    public List<NetDisk> getChildren(String path) {
+        return findByPathPrefix(path);
+    }
+
+    public NetDisk list2tree(String rootId, List<NetDisk> list) {
+        Map<String, NetDisk> map = list.stream()
+                .collect(Collectors.toMap(NetDisk::getFileId, diskFile -> diskFile));
+        list.forEach(diskFile -> {
+            String pid = diskFile.getPid();
+            String fileId = diskFile.getFileId();
+            if (!fileId.equals(rootId)) {
+                NetDisk parent = map.get(pid);
+                parent.getChildren().add(diskFile);
+            }
+        });
+
+        return map.get(rootId);
+    }
+
+    public void tree2List(NetDisk root, List<NetDisk> list) {
+        list.add(root);
+        for (NetDisk child : root.getChildren()) {
+            tree2List(child, list);
+        }
+    }
+
+    public NamePath getUniqueNamePath(String parentPath, String filename, long owner) {
+        String path = getPath(parentPath, filename);
+        DiskQuery diskQuery = new DiskQuery.Builder()
+                .path(path)
+                .path(path)
+                .build();
+        Page page = new Page(1, 10);
+        List<NetDisk> netDiskList = netDiskMapper.findDiskQueryByPage(diskQuery, page);
+        NetDisk diskFile = netDiskList.get(0);
+        if (diskFile != null) {
+            filename = getNewFilename(filename);
+            path = getPath(parentPath, filename);
+        }
+
+        return new NamePath(filename, path);
+    }
+
+    private String getNewFilename(String filename) {
+        String suffix = StringUtil.getSuffix(filename);
+        String prefix = filename.replace(suffix, "");
+        // yyyymmdd_hh:mm:ss 格式字符串
+        String dateTimeStr = DateTimeConverter.format(LocalDateTime.now())
+                .replace(" ", "_")
+                .replace("-", "")
+                .replace(":", "");;
+        return String.format("%s-%s", prefix, dateTimeStr + suffix);
+    }
+
+    private String getPath(String parentPath, String filename) {
+        String path;
+        if (parentPath.equals("/")) {
+            path = parentPath + filename;
+        } else {
+            path = String.format("%s/%s" , parentPath, filename);
+        }
+
+        return path;
+    }
+
+    private String getParentPath(String path) {
+        int index = path.lastIndexOf("/");
+        return path.substring(0, index);
+    }
+
+    private List<NetDisk> findByPathPrefix(String pathPrefix) {
+        /*Specification<NetDisk> specification = (root, query, cb) -> {
+            List<Predicate> predicates = new ArrayList<>();
+            predicates.add(cb.like(root.get("path"), "%" + pathPrefix + "%"));
+
+            // select * from app_building where app_id like '%test%' and app_name like '%测试%'
+            return cb.and(predicates.toArray(new Predicate[0]));
+        };*/
+
+        return netDiskMapper.findAll();
+    }
+    
+    private List<NetDisk> findByFileIdContains(List<String> fileIds) {
+        return Collections.emptyList();
+    }
+
+    public List<NamePath> getPathList(String path) {
+        List<NamePath> pathList = new ArrayList<>();
+        if (path.equals("/")) {
+            NamePath namePath = new NamePath("/", "/");
+            //pathList.add(namePath);
+        } else {
+            while (!path.equals("/")) {
+                int index = path.lastIndexOf("/");
+                String name = path.substring(index+1);
+                NamePath namePath = new NamePath(name, path);
+                pathList.add(namePath);
+
+                if (index == 0) {
+                    path = path.substring(0, index+1);
+                } else {
+                    path = path.substring(0, index);
+                }
+            }
+
+            NamePath namePath = new NamePath("/", "/");
+            pathList.add(namePath);
+        }
+
+        Collections.reverse(pathList);
+        return pathList;
+    }
+}

content/content-service/src/main/java/cn/reghao/tnb/content/app/geo/model/vo/SelectOption.java

@@ -1,6 +1,7 @@
 package cn.reghao.tnb.content.app.geo.model.vo;
 
 import lombok.AllArgsConstructor;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 /**
@@ -9,6 +10,7 @@ import lombok.NoArgsConstructor;
  */
 @NoArgsConstructor
 @AllArgsConstructor
+@Getter
 public class SelectOption {
     private String label;
     private String value;

content/content-service/src/main/java/cn/reghao/tnb/content/app/util/RandomUtil.java

@@ -14,4 +14,25 @@ public class RandomUtil {
         int min = 0;
         return min + random.nextInt(max - min);
     }
+
+    /**
+     * 产生两个数之间的随机数
+     *
+     * @param min 最小值
+     * @param max 最大值
+     * @return 随机数
+     */
+    public static int getNumber(int min, int max) {
+        return min + random.nextInt(max - min);
+    }
+
+    /**
+     * 产生0-num的随机数,不包括num
+     *
+     * @param num 最大值
+     * @return 随机数
+     */
+    public static int getNumber(int num) {
+        return random.nextInt(num);
+    }
 }

content/content-service/src/main/java/cn/reghao/tnb/content/app/vod/controller/VideoController.java

@@ -1,15 +1,11 @@
 package cn.reghao.tnb.content.app.vod.controller;
 
-import cn.reghao.jutil.jdk.result.Result;
 import cn.reghao.jutil.web.WebResult;
 import cn.reghao.tnb.common.auth.AuthUser;
-import cn.reghao.tnb.content.app.vod.model.dto.VideoEdit;
-import cn.reghao.tnb.content.app.vod.model.dto.VideoErrorReport;
 import cn.reghao.tnb.content.app.vod.model.vo.DownloadUrl;
 import cn.reghao.tnb.content.app.vod.service.VideoService;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import io.swagger.v3.oas.annotations.Operation;
-import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
 /**

content/content-service/src/main/java/cn/reghao/tnb/content/app/vod/service/VideoService.java

@@ -4,7 +4,7 @@ import cn.reghao.file.api.iface.OssService;
 import cn.reghao.oss.sdk.model.dto.media.VideoUrlDto;
 import cn.reghao.tnb.common.auth.UserContext;
 import cn.reghao.tnb.content.app.vod.db.mapper.*;
-import cn.reghao.tnb.content.app.vod.model.po.*;
+import cn.reghao.tnb.content.app.vod.model.po.VideoPost;
 import cn.reghao.tnb.content.app.vod.model.vo.DownloadUrl;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.dubbo.config.annotation.DubboReference;

content/content-service/src/main/resources/mapper/disk/CamDeviceMapper.xml

@@ -0,0 +1,58 @@
+<?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.reghao.tnb.content.app.disk.db.mapper.CamDeviceMapper">
+    <insert id="save" useGeneratedKeys="true" keyProperty="id">
+        insert into my_cam_device
+        (`album_id`,`post_id`,`pos`,`added_at`)
+        values
+        (#{albumId},#{postId},#{pos},#{addedAt})
+    </insert>
+    <insert id="saveAll" useGeneratedKeys="true" keyProperty="id">
+        insert into my_cam_device
+        (`album_id`,`post_id`,`pos`,`added_at`)
+        values
+        <foreach collection="list" item="item" index="index" separator=",">
+            (#{item.albumId},#{item.postId},#{item.pos},#{item.addedAt})
+        </foreach>
+    </insert>
+
+    <select id="countByCamDeviceQuery" resultType="java.lang.Integer">
+        select count(*)
+        from my_cam_device
+        <where>
+            deleted=0
+            <if test="camId != null">
+                and cam_id=#{camId}
+            </if>
+            <if test="owner != null">
+                and owner=#{owner}
+            </if>
+            <if test="camName != null">
+                and cam_name=#{camName}
+            </if>
+            <if test="deviceId != null">
+                and device_id=#{deviceId}
+            </if>
+        </where>
+    </select>
+    <select id="findCamDeviceQueryByPage" resultType="cn.reghao.tnb.content.app.disk.model.po.NetDisk">
+        select *
+        from my_cam_device
+        <where>
+            deleted=0
+            <if test="camDeviceQuery.camId != null">
+                and cam_id=#{camDeviceQuery.camId}
+            </if>
+            <if test="camDeviceQuery.owner != null">
+                and owner=#{owner}
+            </if>
+            <if test="camDeviceQuery.camName != null">
+                and cam_name=#{camDeviceQuery.camName}
+            </if>
+            <if test="camDeviceQuery.deviceId != null">
+                and device_id=#{camDeviceQuery.deviceId}
+            </if>
+        </where>
+    </select>
+</mapper>

content/content-service/src/main/resources/mapper/disk/CamRecordMapper.xml

@@ -0,0 +1,46 @@
+<?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.reghao.tnb.content.app.disk.db.mapper.CamRecordMapper">
+    <insert id="save" useGeneratedKeys="true" keyProperty="id">
+        insert into my_cam_record
+        (`album_id`,`post_id`,`pos`,`added_at`)
+        values
+        (#{albumId},#{postId},#{pos},#{addedAt})
+    </insert>
+    <insert id="saveAll" useGeneratedKeys="true" keyProperty="id">
+        insert into my_cam_record
+        (`album_id`,`post_id`,`pos`,`added_at`)
+        values
+        <foreach collection="list" item="item" index="index" separator=",">
+            (#{item.albumId},#{item.postId},#{item.pos},#{item.addedAt})
+        </foreach>
+    </insert>
+
+    <delete id="deleteByAlbumIdAndPostId">
+        delete from my_cam_record
+        where album_id=#{albumId} and post_id=#{postId}
+    </delete>
+    
+    <select id="findByCamId" resultType="cn.reghao.tnb.content.app.disk.model.po.CamRecord">
+        select *
+        from my_cam_record
+        where cam_id=#{camId}
+    </select>
+    <select id="findByCamIdAndStartAt" resultType="cn.reghao.tnb.content.app.disk.model.vo.RecordInfo">
+        select *
+        from my_cam_record
+        where cam_id=#{camId} and DATE_FORMAT(start_at,'%Y-%m-%d')=#{dayStr}
+    </select>
+    <select id="findByRecordId" resultType="cn.reghao.tnb.content.app.disk.model.po.CamRecord">
+        select *
+        from my_cam_record
+        where record_id=#{recordId}
+    </select>
+    <select id="findGroupByYearMonth" resultType="cn.reghao.tnb.content.app.disk.model.vo.ResultCount">
+        select DATE_FORMAT(start_at,'%Y-%m-%d') as `key`, count(*) as `value`
+        from my_cam_record
+        where cam_id=#{camId} and DATE_FORMAT(start_at,'%Y-%m')=#{yearMonth}
+        group by `key`
+    </select>
+</mapper>

content/content-service/src/main/resources/mapper/disk/NetDiskMapper.xml

@@ -0,0 +1,81 @@
+<?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.reghao.tnb.content.app.disk.db.mapper.NetDiskMapper">
+    <insert id="save" useGeneratedKeys="true" keyProperty="id">
+        insert into my_net_disk
+        (`album_id`,`post_id`,`pos`,`added_at`)
+        values
+        (#{albumId},#{postId},#{pos},#{addedAt})
+    </insert>
+    <insert id="saveAll" useGeneratedKeys="true" keyProperty="id">
+        insert into my_net_disk
+        (`album_id`,`post_id`,`pos`,`added_at`)
+        values
+        <foreach collection="list" item="item" index="index" separator=",">
+            (#{item.albumId},#{item.postId},#{item.pos},#{item.addedAt})
+        </foreach>
+    </insert>
+
+    <delete id="deleteByAlbumIdAndPostId">
+        delete from my_net_disk
+        where album_id=#{albumId} and post_id=#{postId}
+    </delete>
+
+    <select id="countByDiskQuery" resultType="java.lang.Integer">
+        select count(*)
+        from my_net_disk
+        <where>
+            deleted=0
+            <if test="fileType != null">
+                and file_type=#{fileType}
+            </if>
+            <if test="owner != null">
+                and owner=#{owner}
+            </if>
+            <if test="pid != null">
+                and pid=#{pid}
+            </if>
+            <if test="fileId != null">
+                and file_id=#{fileId}
+            </if>
+            <if test="path != null">
+                and path=#{path}
+            </if>
+            <if test="sha256sum != null">
+                and sha256sum=#{sha256sum}
+            </if>
+        </where>
+    </select>
+    <select id="findAllByDiskQuery" resultType="cn.reghao.tnb.content.app.disk.model.po.NetDisk">
+        select *
+        from my_net_disk
+        <where>
+            deleted=0
+            <if test="diskQuery.fileType != null">
+                and file_type=#{diskQuery.fileType}
+            </if>
+            <if test="diskQuery.owner != null">
+                and owner=#{diskQuery.owner}
+            </if>
+            <if test="diskQuery.pid != null">
+                and pid=#{diskQuery.pid}
+            </if>
+            <if test="diskQuery.fileId != null">
+                and file_id=#{diskQuery.fileId}
+            </if>
+            <if test="diskQuery.path != null">
+                and path=#{diskQuery.path}
+            </if>
+            <if test="diskQuery.sha256sum != null">
+                and sha256sum=#{diskQuery.sha256sum}
+            </if>
+        </where>
+    </select>
+    <select id="findFileTypeCountByGroup" resultType="cn.reghao.tnb.content.app.disk.model.vo.NetDiskCount">
+        select file,count(*) as total
+        from my_net_disk
+        group by file_type
+        order by total desc
+    </select>
+</mapper>

content/content-service/src/main/resources/mapper/disk/UserActivityMapper.xml

@@ -0,0 +1,11 @@
+<?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.reghao.tnb.content.app.disk.db.mapper.UserActivityMapper">
+    <insert id="save" useGeneratedKeys="true" keyProperty="id">
+        insert into disk_user_activity
+        (`id`,`activity`,`create_time`,`create_by`)
+        values
+        (#{id},#{activity},#{createTime},#{createBy})
+    </insert>
+</mapper>