工作报告已读未读、详情导出以及工时统计代码优化

service-iot/service-iot-biz/pom.xml

@@ -89,6 +89,11 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>com.usky</groupId>
+            <artifactId>ruoyi-common-core</artifactId>
+        </dependency>
+
     </dependencies>
 
     <build>

service-iot/service-iot-biz/src/main/java/com/usky/iot/controller/web/PmProjectController.java

@@ -101,5 +101,15 @@ public class PmProjectController {
         return ApiResult.success(pmProjectService.userOrProject(identifying));
     }
 
+    /**
+     * 退出项目
+     *
+     * @param projectId 项目id
+     */
+    @GetMapping("/exitProject")
+    public void exitProject(@RequestParam Integer projectId) {
+        pmProjectService.exitProject(projectId);
+    }
+
 }
 

service-iot/service-iot-biz/src/main/java/com/usky/iot/controller/web/PmWorkContentController.java

@@ -1,15 +1,21 @@
 package com.usky.iot.controller.web;
 
 
+import com.ruoyi.common.core.utils.poi.ExcelUtil;
 import com.usky.common.core.bean.ApiResult;
 import com.usky.common.core.bean.CommonPage;
+import com.usky.common.log.annotation.Log;
+import com.usky.common.log.enums.BusinessType;
 import com.usky.iot.domain.PmWorkContent;
 import com.usky.iot.domain.PmWorkReport;
 import com.usky.iot.service.PmWorkContentService;
+import com.usky.iot.service.vo.WorkTimeExportVO;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
 import java.time.LocalDate;
 import java.time.temporal.TemporalAdjusters;
 import java.util.List;
@@ -66,10 +72,21 @@ public class PmWorkContentController {
     @GetMapping("/page")
     public ApiResult<CommonPage<PmWorkReport>> page(@RequestParam(value = "projectAscription", required = false, defaultValue = "2") Integer projectAscription,
                                                     @RequestParam(value = "pageNum") Integer pageNum,
-                                                    @RequestParam(value = "pageSize") Integer pageSize){
-        return ApiResult.success(pmWorkContentService.reportPage(projectAscription, pageNum, pageSize));
+                                                    @RequestParam(value = "pageSize") Integer pageSize,
+                                                    @RequestParam(value = "reportId", required = false) Integer reportId){
+        return ApiResult.success(pmWorkContentService.reportPage(projectAscription, pageNum, pageSize, reportId));
     }
 
+    /**
+     * 工时统计
+     * @param userId
+     * @param projectId
+     * @param filter
+     * @param startDate
+     * @param endDate
+     * @param workerOrProject
+     * @return
+     */
     @GetMapping("/workHourStatistic")
     public ApiResult<List<Object>> workHourStatistic(@RequestParam(value = "userId", required = false) Long userId,
                                                      @RequestParam(value = "projectId", required = false) Integer projectId,
@@ -83,5 +100,27 @@ public class PmWorkContentController {
         }
         return ApiResult.success(pmWorkContentService.workHourStatistic(userId, projectId, filter, startDate, endDate, workerOrProject));
     }
+
+    /**
+     * 工时明细导出
+     * @param response
+     * @param userId
+     * @param projectId
+     * @param startDate
+     * @param endDate
+     * @throws IOException
+     */
+    @Log(title = "工时统计", businessType = BusinessType.EXPORT)
+    @PostMapping("/workHourStatisticExport")
+    public void export(HttpServletResponse response,
+                       @RequestParam(value = "userId", required = false) Long userId,
+                       @RequestParam(value = "projectId", required = false) Integer projectId,
+                       @RequestParam(value = "startDate", required = false) String startDate,
+                       @RequestParam(value = "endDate", required = false) String endDate) throws IOException {
+        List<WorkTimeExportVO> list = pmWorkContentService.workHourStatisticExport(userId, projectId, startDate, endDate);
+        ExcelUtil<WorkTimeExportVO> util = new ExcelUtil<WorkTimeExportVO>(WorkTimeExportVO.class);
+        util.exportExcel(response, list, "工时统计", "工时统计");
+    }
+
 }
 

service-iot/service-iot-biz/src/main/java/com/usky/iot/mapper/PmWorkContentMapper.java

@@ -1,10 +1,10 @@
 package com.usky.iot.mapper;
 
-import com.usky.common.security.utils.SecurityUtils;
 import com.usky.iot.domain.PmWorkContent;
 import com.usky.common.mybatis.core.CrudMapper;
 import com.usky.iot.service.vo.PmProjectWorkTimeVo;
 import com.usky.iot.service.vo.WorkHoursStatisticsVO;
+import com.usky.iot.service.vo.WorkTimeExportVO;
 import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Repository;
 
@@ -27,10 +27,10 @@ public interface PmWorkContentMapper extends CrudMapper<PmWorkContent> {
                                             @Param("endTime") LocalDateTime endTime,
                                             @Param("userId") Long userId);
 
-    List<WorkHoursStatisticsVO> workHoursStatistics(@Param("startTime") LocalDate startTime,
+/*    List<WorkHoursStatisticsVO> workHoursStatistics(@Param("startTime") LocalDate startTime,
                                                     @Param("endTime") LocalDate endTime,
                                                     @Param("userId") Long userId,
-                                                    @Param("tenantId") Integer tenantId);
+                                                    @Param("tenantId") Integer tenantId);*/
 
     /**
      * 人员查询时增加部门隔离，项目维度不需要
@@ -41,10 +41,17 @@ public interface PmWorkContentMapper extends CrudMapper<PmWorkContent> {
      * @param tenantId
      * @return
      */
+/*
     List<WorkHoursStatisticsVO> statisticsDept(@Param("startTime") LocalDate startTime,
                                                @Param("endTime") LocalDate endTime,
                                                @Param("userId") Long userId,
                                                @Param("tenantId") Integer tenantId,
                                                @Param("deptId") Long deptId);
+*/
 
+    List<WorkTimeExportVO> workHourStatisticExport(@Param("userId") Long userId,
+                                                   @Param("projectId") Integer projectId,
+                                                   @Param("startTime") LocalDate startTime,
+                                                   @Param("endTime") LocalDate endTime,
+                                                   @Param("tenantId") Integer tenantId);
 }

service-iot/service-iot-biz/src/main/java/com/usky/iot/service/PmProjectService.java

@@ -83,4 +83,6 @@ public interface PmProjectService extends CrudService<PmProject> {
      * @return
      */
     List<Map<String, Object>> userOrProject(Integer identifying);
+
+    void exitProject(Integer projectId);
 }

service-iot/service-iot-biz/src/main/java/com/usky/iot/service/PmWorkContentService.java

@@ -4,6 +4,8 @@ import com.usky.common.core.bean.CommonPage;
 import com.usky.iot.domain.PmWorkContent;
 import com.usky.common.mybatis.core.CrudService;
 import com.usky.iot.domain.PmWorkReport;
+import com.usky.iot.service.vo.WorkTimeExportVO;
+
 import com.usky.system.domain.SysUser;
 
 import java.util.List;
@@ -58,7 +60,7 @@ public interface PmWorkContentService extends CrudService<PmWorkContent> {
      * @param pageSize 页大小
      * @return
      */
-    CommonPage<PmWorkReport> reportPage(Integer projectAscription, Integer pageNum, Integer pageSize);
+    CommonPage<PmWorkReport> reportPage(Integer projectAscription, Integer pageNum, Integer pageSize, Integer report);
 
     /** 工时统计页面
      * @param userId          用户id
@@ -70,4 +72,12 @@ public interface PmWorkContentService extends CrudService<PmWorkContent> {
      */
     List<Object> workHourStatistic(Long userId, Integer projectId, Integer filter, String startDate, String endDate, Integer workerOrProject);
 
+    /** 工时统计导出
+     * @param userId          用户id
+     * @param startDate       开始时间
+     * @param endDate         结束时间
+     * @return 返回项目名（或牛马名）以及项目工时
+     */
+    List<WorkTimeExportVO> workHourStatisticExport(Long userId, Integer projectId, String startDate, String endDate);
+
 }

service-iot/service-iot-biz/src/main/java/com/usky/iot/service/impl/PmProjectServiceImpl.java

@@ -294,4 +294,17 @@ public class PmProjectServiceImpl extends AbstractCrudService<PmProjectMapper, P
         return returnList;
     }
 
+    @Override
+    public void exitProject(Integer projectId){
+        Long userId = SecurityUtils.getUserId();
+        PmProject project = pmProjectMapper.selectById(projectId);
+        String projectMember =  project.getProjectMember();
+        String[] parts = projectMember.split(",");
+        String result = String.join(",", java.util.stream.Stream.of(parts)
+                .filter(part -> !part.equals(String.valueOf(userId)))
+                .collect(Collectors.toList()));
+        project.setProjectMember(result);
+        pmProjectMapper.updateById(project);
+    }
+
 }

service-iot/service-iot-biz/src/main/java/com/usky/iot/service/impl/PmWorkContentServiceImpl.java

@@ -4,8 +4,11 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.ruoyi.common.datascope.annotation.DataScope;
 import com.usky.common.core.bean.CommonPage;
+import com.usky.common.core.exception.BusinessException;
 import com.usky.common.security.utils.SecurityUtils;
+import com.usky.iot.domain.PmProject;
 import com.usky.iot.domain.PmReceive;
 import com.usky.iot.domain.PmWorkContent;
 import com.usky.iot.domain.PmWorkReport;
@@ -16,11 +19,13 @@ import com.usky.common.mybatis.core.AbstractCrudService;
 import com.usky.iot.service.vo.ProjectWorkTimeVO;
 import com.usky.iot.service.vo.UserWorkTimeVO;
 import com.usky.iot.service.vo.WorkHoursStatisticsVO;
+import com.usky.iot.service.vo.WorkTimeExportVO;
 import com.usky.system.domain.SysUser;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import com.ruoyi.common.datascope.context.DataScopeContextHolder;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;
@@ -50,6 +55,12 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
     @Autowired
     private PmReceiveMapper pmReceiveMapper;
 
+    @Autowired
+    private PmWorkContentMapper pmWorkContentMapper;
+
+    @Autowired
+    private PmProjectMapper pmProjectMapper;
+
     @Override
     public void deleteContent(Integer reportId) {
         LambdaQueryWrapper<PmWorkContent> deleteWrapper = Wrappers.lambdaQuery();
@@ -57,6 +68,80 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
         baseMapper.delete(deleteWrapper);
     }
 
+    private List<Integer> reportDateQuery(String startDate, String endDate) {
+
+        Integer tenantId = SecurityUtils.getTenantId();
+        LambdaQueryWrapper<PmWorkReport> reportQuery = Wrappers.lambdaQuery();
+        reportQuery.select(PmWorkReport::getId)
+                .eq(PmWorkReport::getTenantId, tenantId);
+        if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
+            LocalDate start = LocalDate.parse(startDate);
+            LocalDate end = LocalDate.parse(endDate);
+            reportQuery.between(PmWorkReport::getReportDate, start, end);
+        }
+        List<PmWorkReport> reportIds = pmWorkReportMapper.selectList(reportQuery);
+        List<Integer> rIds = new ArrayList<>();
+        for (PmWorkReport report : reportIds) {
+            rIds.add(report.getId());
+        }
+        return rIds;
+    }
+
+    private List<Integer> receive() {
+        Long userId = SecurityUtils.getUserId();
+        Integer tenantId = SecurityUtils.getTenantId();
+        LambdaQueryWrapper<PmWorkReport> reportQuery = Wrappers.lambdaQuery();
+        reportQuery.select(PmWorkReport::getId)
+                .eq(PmWorkReport::getTenantId, tenantId)
+                .apply("FIND_IN_SET(" + userId + ", cc_to) > 0");
+        List<PmWorkReport> reportIds = pmWorkReportMapper.selectList(reportQuery);
+        return reportIds.stream().map(PmWorkReport::getId).collect(Collectors.toList());
+    }
+
+    private List<Integer> sentOut() {
+        String username = SecurityUtils.getUsername();
+        Integer tenantId = SecurityUtils.getTenantId();
+        LambdaQueryWrapper<PmWorkReport> reportQuery = Wrappers.lambdaQuery();
+        reportQuery.select(PmWorkReport::getId)
+                .eq(PmWorkReport::getTenantId, tenantId)
+                .eq(PmWorkReport::getCreateBy, username);
+        List<PmWorkReport> reportIds = pmWorkReportMapper.selectList(reportQuery);
+        List<Integer> rIds = new ArrayList<>();
+        for (PmWorkReport report : reportIds) {
+            rIds.add(report.getId());
+        }
+        return rIds;
+    }
+
+    private List<Integer> head() {
+        Long userId = SecurityUtils.getUserId();
+        Integer tenantId = SecurityUtils.getTenantId();
+        LambdaQueryWrapper<PmProject> projectQuery = Wrappers.lambdaQuery();
+        projectQuery.select(PmProject::getId)
+                .eq(PmProject::getTenantId, tenantId)
+                .eq(PmProject::getProjectHead, userId);
+        List<PmProject> projectIds = pmProjectMapper.selectList(projectQuery);
+        List<Integer> rIds = new ArrayList<>();
+        for (PmProject project : projectIds) {
+            rIds.add(project.getId());
+        }
+        return rIds;
+    }
+
+    private List<Integer> reportList(String projectName) {
+        Integer tenantId = SecurityUtils.getTenantId();
+        LambdaQueryWrapper<PmWorkContent> projectQuery = Wrappers.lambdaQuery();
+        projectQuery.select(PmWorkContent::getReportId)
+                .eq(PmWorkContent::getProjectName, projectName)
+                .eq(PmWorkContent::getTenantId, tenantId);
+        List<PmWorkContent> projectIds = pmWorkContentMapper.selectList(projectQuery);
+        List<Integer> rIds = new ArrayList<>();
+        for (PmWorkContent contenReportId : projectIds) {
+            rIds.add(contenReportId.getId());
+        }
+        return rIds;
+    }
+
     @Override
     public List<PmWorkContent> projectQuery(String startDate, String endDate, String projectName, Integer projectAscription, Integer reportId) {
         if (reportId != null && reportId != 0) {
@@ -67,24 +152,38 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
             List<PmWorkContent> pmWorkContentList = this.list(contentLambdaQuery);
             return pmWorkContentList;
         }
-        LocalDate start = LocalDate.parse(startDate);
-        LocalDate end = LocalDate.parse(endDate);
-        String subQueryReports = "SELECT id FROM pm_work_report WHERE report_date BETWEEN '" + start + "' AND '" + end + "' AND tenant_id = " + SecurityUtils.getTenantId();
-        String subQueryReport = "SELECT id FROM pm_work_report WHERE FIND_IN_SET('" + SecurityUtils.getUserId() + "', cc_to) > 0 AND tenant_id = " + SecurityUtils.getTenantId();
-        String sentOut = "SELECT id FROM pm_work_report WHERE create_by = '" + SecurityUtils.getUsername() + "' AND tenant_id = " + SecurityUtils.getTenantId();
-        String subQueryProjects = "SELECT id FROM pm_project WHERE project_head = '" + SecurityUtils.getUserId() + "' AND tenant_id = " + SecurityUtils.getTenantId();
+        List<Integer> reportIds = reportDateQuery(startDate, endDate);
+        List<Integer> receiveList = receive();
+        List<Integer> sentOutList = sentOut();
+        List<Integer> headProjects = head();
+        //LocalDate start = LocalDate.parse(startDate);
+        //LocalDate end = LocalDate.parse(endDate);
+        //String subQueryReports = "SELECT id FROM pm_work_report WHERE report_date BETWEEN '" + start + "' AND '" + end + "' AND tenant_id = " + SecurityUtils.getTenantId();
+        //String subQueryReport = "SELECT id FROM pm_work_report WHERE FIND_IN_SET('" + SecurityUtils.getUserId() + "', cc_to) > 0 AND tenant_id = " + SecurityUtils.getTenantId();
+        //String sentOut = "SELECT id FROM pm_work_report WHERE create_by = '" + SecurityUtils.getUsername() + "' AND tenant_id = " + SecurityUtils.getTenantId();
+        //String subQueryProjects = "SELECT id FROM pm_project WHERE project_head = '" + SecurityUtils.getUserId() + "' AND tenant_id = " + SecurityUtils.getTenantId();
         LambdaQueryWrapper<PmWorkContent> contentLambdaQuery = Wrappers.lambdaQuery();
         contentLambdaQuery.select(PmWorkContent::getProjectId, PmWorkContent::getProjectName)
-                .inSql(PmWorkContent::getReportId, subQueryReports);
+                .in(PmWorkContent::getReportId, reportIds);
+        //.inSql(PmWorkContent::getReportId, subQueryReports);
         if (StringUtils.isNotBlank(projectName)) {
             contentLambdaQuery.like(PmWorkContent::getProjectName, projectName);
         }
         if (projectAscription == 1) {
-            contentLambdaQuery.inSql(PmWorkContent::getProjectId, subQueryProjects);
+            if (headProjects.isEmpty()) {
+                return new ArrayList<PmWorkContent>();
+            }
+            contentLambdaQuery.in(PmWorkContent::getProjectId, headProjects);
+            //contentLambdaQuery.inSql(PmWorkContent::getProjectId, subQueryProjects);
         } else if (projectAscription == 2) {
-            contentLambdaQuery.inSql(PmWorkContent::getReportId, subQueryReport);
+            //contentLambdaQuery.inSql(PmWorkContent::getReportId, subQueryReport);
+            if (receiveList.isEmpty()){
+                return new ArrayList<PmWorkContent>();
+            }
+            contentLambdaQuery.in(PmWorkContent::getReportId, receiveList);
         } else if (projectAscription == 3) {
-            contentLambdaQuery.inSql(PmWorkContent::getReportId, sentOut);
+            //contentLambdaQuery.in(PmWorkContent::getReportId, sentOutList);
+            contentLambdaQuery.in(PmWorkContent::getReportId, sentOutList);
         }
         contentLambdaQuery.groupBy(PmWorkContent::getProjectId, PmWorkContent::getProjectName);
         List<PmWorkContent> pmWorkContentList = this.list(contentLambdaQuery);
@@ -112,25 +211,36 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
                 userIds.add(c.getSubmitterId());
             }
         } else {
-            LocalDate start = LocalDate.parse(startDate);
-            LocalDate end = LocalDate.parse(endDate);
-            String subQueryReports = "SELECT id FROM pm_work_report WHERE report_date BETWEEN '" + start + "' AND '" + end + "' AND tenant_id = " + SecurityUtils.getTenantId();
-            String subQueryReport = "SELECT id FROM pm_work_report WHERE FIND_IN_SET('" + SecurityUtils.getUserId() + "', cc_to) > 0 AND tenant_id = " + SecurityUtils.getTenantId();
-            String subQueryProjects = "SELECT id FROM pm_project WHERE project_head = '" + SecurityUtils.getUserId() + "' AND tenant_id = " + SecurityUtils.getTenantId();
-            String sentOut = "SELECT id FROM pm_work_report WHERE create_by = '" + SecurityUtils.getUsername() + "' AND tenant_id = " + SecurityUtils.getTenantId();
-            String reportIdList = "SELECT report_id FROM pm_work_content WHERE project_name = '" + projectName + "' AND tenant_id = " + SecurityUtils.getTenantId();
+            //LocalDate start = LocalDate.parse(startDate);
+            //LocalDate end = LocalDate.parse(endDate);
+            List<Integer> reportIds2 = reportDateQuery(startDate, endDate);
+            List<Integer> receiveList2 = receive();
+            List<Integer> sentOutList = sentOut();
+            List<Integer> headProjects = head();
+            //String subQueryReports = "SELECT id FROM pm_work_report WHERE report_date BETWEEN '" + start + "' AND '" + end + "' AND tenant_id = " + SecurityUtils.getTenantId();
+            //String subQueryReport = "SELECT id FROM pm_work_report WHERE FIND_IN_SET('" + SecurityUtils.getUserId() + "', cc_to) > 0 AND tenant_id = " + SecurityUtils.getTenantId();
+            //String subQueryProjects = "SELECT id FROM pm_project WHERE project_head = '" + SecurityUtils.getUserId() + "' AND tenant_id = " + SecurityUtils.getTenantId();
+            //String sentOut = "SELECT id FROM pm_work_report WHERE create_by = '" + SecurityUtils.getUsername() + "' AND tenant_id = " + SecurityUtils.getTenantId();
+            //String reportIdList = "SELECT report_id FROM pm_work_content WHERE project_name = '" + projectName + "' AND tenant_id = " + SecurityUtils.getTenantId();
             LambdaQueryWrapper<PmWorkContent> contentLambdaQuery = Wrappers.lambdaQuery();
             contentLambdaQuery.select(PmWorkContent::getReportId, PmWorkContent::getWorkContent, PmWorkContent::getWorkTime, PmWorkContent::getProjectName)
-                    .inSql(PmWorkContent::getReportId, subQueryReports);
+                    .in(PmWorkContent::getReportId, reportIds2);
             if (projectAscription == 1) {
-                contentLambdaQuery.inSql(PmWorkContent::getProjectId, subQueryProjects);
+                //.inSql(PmWorkContent::getReportId, subQueryReports);
+                contentLambdaQuery.in(PmWorkContent::getProjectId, headProjects);
             } else if (projectAscription == 2) {
-                contentLambdaQuery.inSql(PmWorkContent::getReportId, subQueryReport);
+                //contentLambdaQuery.inSql(PmWorkContent::getReportId, subQueryReport);
+                contentLambdaQuery.in(PmWorkContent::getReportId, receiveList2);
             } else if (projectAscription == 3) {
-                contentLambdaQuery.inSql(PmWorkContent::getReportId, sentOut);
+                //contentLambdaQuery.inSql(PmWorkContent::getReportId, sentOut);
+                contentLambdaQuery.in(PmWorkContent::getReportId, sentOutList);
             }
+//            if (StringUtils.isNotBlank(projectName)) {
+//                contentLambdaQuery.inSql(PmWorkContent::getReportId, reportIdList);
+//            }
             if (StringUtils.isNotBlank(projectName)) {
-                contentLambdaQuery.inSql(PmWorkContent::getReportId, reportIdList);
+                List<Integer> list = reportList(projectName);
+                contentLambdaQuery.in(PmWorkContent::getReportId, list);
             }
             pmWorkContentList = this.list(contentLambdaQuery);
             if (pmWorkContentList.isEmpty()) {
@@ -229,55 +339,61 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
     }
 
     @Override
-    public CommonPage<PmWorkReport> reportPage(Integer projectAscription, Integer pageNum, Integer pageSize) {
+    public CommonPage<PmWorkReport> reportPage(Integer projectAscription, Integer pageNum, Integer pageSize, Integer reportId) {
         Integer tenantId = SecurityUtils.getTenantId();
         Long userId = SecurityUtils.getUserId();
+        String userName = SecurityUtils.getUsername();
+        List<Integer> headProjects = head();
+        List<Integer> receiveList2 = receive();
         List<Long> userIds = new ArrayList<>();
-        Page<PmWorkReport> page = new Page<>(pageNum, pageSize);
         LambdaQueryWrapper<PmWorkContent> contentLambdaQuery = Wrappers.lambdaQuery();
-        contentLambdaQuery.select(PmWorkContent::getReportId, PmWorkContent::getWorkContent, PmWorkContent::getWorkTime, PmWorkContent::getProjectName)
-                .apply("report_id IN (SELECT id FROM pm_work_report WHERE tenant_id = '" + tenantId + "')")
-                .apply("tenant_id = '" + tenantId + "'");
-
-        switch (projectAscription) {
-            case 1:
-                contentLambdaQuery.apply("project_id IN (SELECT id FROM pm_project WHERE project_head = '" + userId + "' AND tenant_id = '" + tenantId + "')");
-                break;
-            case 2:
-                contentLambdaQuery.apply("report_id IN (SELECT id FROM pm_work_report WHERE FIND_IN_SET('" + userId + "', cc_to) > 0 AND tenant_id = '" + tenantId + "')");
-                break;
-            case 3:
-                contentLambdaQuery.apply("create_by ='" + userId + "' AND tenant_id = '" + tenantId + "'");
-                break;
+        contentLambdaQuery.select(PmWorkContent::getReportId, PmWorkContent::getWorkContent, PmWorkContent::getWorkTime, PmWorkContent::getProjectName);
+        if (reportId != null && reportId != 0) {
+            contentLambdaQuery.eq(PmWorkContent::getReportId, reportId);
+        } else {
+            contentLambdaQuery.eq(PmWorkContent::getTenantId, tenantId);
+            switch (projectAscription) {
+                case 1:
+                    contentLambdaQuery.in(PmWorkContent::getReportId, headProjects);
+                    break;
+                case 2:
+                    contentLambdaQuery.in(PmWorkContent::getReportId, receiveList2);
+                    break;
+                case 3:
+                    contentLambdaQuery.eq(PmWorkContent::getCreateBy, userName);
+                    break;
+            }
         }
-
         List<PmWorkContent> pmWorkContentList = this.list(contentLambdaQuery);
         Set<Integer> reportIds = pmWorkContentList.stream().map(PmWorkContent::getReportId).collect(Collectors.toSet());
-
         if (reportIds.isEmpty()) {
             return new CommonPage<>(new ArrayList<>(), 0, pageSize, pageNum);
         }
 
         LambdaQueryWrapper<PmWorkReport> reportQuery = Wrappers.lambdaQuery();
         reportQuery.select(PmWorkReport::getId, PmWorkReport::getCoordinateWork, PmWorkReport::getTomorrowPlan, PmWorkReport::getCcTo, PmWorkReport::getSubmitterId,
-                PmWorkReport::getCreateTime, PmWorkReport::getReportDate)
-                .in(PmWorkReport::getId, reportIds)
-                .orderByDesc(PmWorkReport::getCreateTime);
-
+                PmWorkReport::getCreateTime, PmWorkReport::getReportDate);
+        if (reportId != null && reportId != 0) {
+            reportQuery.eq(PmWorkReport::getId, reportId);
+        } else {
+            reportQuery.in(PmWorkReport::getId, reportIds)
+                    .orderByDesc(PmWorkReport::getCreateTime);
+        }
         IPage<PmWorkReport> reportPage = pmWorkReportMapper.selectPage(new Page<>(pageNum, pageSize), reportQuery);
         List<PmWorkReport> reportList = reportPage.getRecords();
 
         LambdaQueryWrapper<PmReceive> statusQuery = Wrappers.lambdaQuery();
         statusQuery.select(PmReceive::getReportId, PmReceive::getReadFlag)
                 .eq(PmReceive::getReceiverId, userId)
-                .eq(PmReceive::getTenantId, tenantId)
-                .in(PmReceive::getReportId, reportIds);
-
+                .eq(PmReceive::getTenantId, tenantId);
+        if (reportId != null && reportId != 0) {
+            statusQuery.eq(PmReceive::getReportId, reportId);
+        } else {
+            statusQuery.in(PmReceive::getReportId, reportIds);
+        }
         List<PmReceive> receiveList = pmReceiveMapper.selectList(statusQuery);
-
         Map<Integer, Integer> reportReadFlags = receiveList.stream()
                 .collect(Collectors.toMap(PmReceive::getReportId, PmReceive::getReadFlag));
-
         reportList.forEach(report -> {
             List<PmWorkContent> contents = pmWorkContentList.stream()
                     .filter(content -> content.getReportId().equals(report.getId()))
@@ -292,7 +408,6 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
         List<SysUser> nickNames = nickNames(userIds);
         Map<Long, String> userNicknameMap = nickNames.stream()
                 .collect(Collectors.toMap(SysUser::getUserId, SysUser::getNickName));
-
         reportList.forEach(report -> {
             report.setCreateBy(userNicknameMap.get(report.getSubmitterId()));
         });
@@ -301,30 +416,193 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
     }
 
 
+/*    private List<Map<String, Object>> projectIdName(Integer projectId) {
+        List<Map<String, Object>> returnList = new ArrayList<>();
+        LambdaQueryWrapper<PmProject> wrapper = Wrappers.lambdaQuery();
+        wrapper.select(PmProject::getId, PmProject::getProjectName)
+                .eq(PmProject::getTenantId, SecurityUtils.getTenantId())
+                .eq(PmProject::getDelFlag, 0);
+        if (projectId != null) {
+            wrapper.eq(PmProject::getId, projectId);
+        }
+        List<PmProject> projects = pmProjectMapper.selectList(wrapper);
+        for (PmProject project : projects) {
+            Map<String, Object> returnMap = new HashMap<>();
+            returnMap.put("id", project.getId());
+            returnMap.put("name", project.getProjectName());
+            returnList.add(returnMap);
+        }
+        return returnList;
+    }*/
+
+    private List<Map<String, Object>> projectUsers(Long userId) {
+        List<Map<String, Object>> returnList = new ArrayList<>();
+        List<SysUser> userList = new ArrayList<>();
+        if (userId != null) {
+            LambdaQueryWrapper<SysUser> queryNameId = Wrappers.lambdaQuery();
+            queryNameId.select(SysUser::getUserId, SysUser::getNickName)
+                    .eq(SysUser::getUserId, userId);
+            userList = sysUserMapper.selectList(queryNameId);
+        } else {
+            LambdaQueryWrapper<PmProject> wrapper = Wrappers.lambdaQuery();
+            wrapper.select(PmProject::getProjectHead, PmProject::getProjectMember)
+                    .eq(PmProject::getTenantId, SecurityUtils.getTenantId())
+                    .eq(PmProject::getDelFlag, 0);
+            List<PmProject> users = pmProjectMapper.selectList(wrapper);
+            List<Long> userIds = new ArrayList<>();
+            for (PmProject user : users) {
+                Long projectHead = user.getProjectHead();
+                userIds.add(projectHead);
+                Set<Long> projectMembers = Arrays.stream(user.getProjectMember().split(","))
+                        .map(Long::parseLong)
+                        .collect(Collectors.toSet());
+                userIds.addAll(projectMembers);
+            }
+            List<Long> finalList = userIds.stream().distinct().collect(Collectors.toList());
+            LambdaQueryWrapper<SysUser> wrapper2 = Wrappers.lambdaQuery();
+            wrapper2.select(SysUser::getUserId, SysUser::getNickName)
+                    .in(SysUser::getUserId, finalList);
+            userList = sysUserMapper.selectList(wrapper2);
+        }
+        for (SysUser user : userList) {
+            Map<String, Object> map = new HashMap<>();
+            map.put("id", user.getUserId());
+            map.put("name", user.getNickName());
+            returnList.add(map);
+        }
+        return returnList;
+    }
+
+    private List<PmProject> projects(Integer projectId) {
+        Integer tenantId = SecurityUtils.getTenantId();
+        Long deptId = SecurityUtils.getLoginUser().getSysUser().getDeptId();
+        LambdaQueryWrapper<PmProject> projectsQuery = Wrappers.lambdaQuery();
+        projectsQuery.select(PmProject::getId, PmProject::getProjectName);
+        if (projectId != null && projectId != 0) {
+            projectsQuery.eq(PmProject::getId, projectId);
+            return pmProjectMapper.selectList(projectsQuery);
+        }
+        projectsQuery.eq(PmProject::getTenantId, tenantId).eq(PmProject::getDeptId, deptId);
+        return pmProjectMapper.selectList(projectsQuery);
+    }
+
+    private List<SysUser> userNameList(Long userId) {
+        Integer tenantId = SecurityUtils.getTenantId();
+        Long deptId = SecurityUtils.getLoginUser().getSysUser().getDeptId();
+        LambdaQueryWrapper<SysUser> userNameQuery = Wrappers.lambdaQuery();
+        userNameQuery.select(SysUser::getUserId, SysUser::getNickName);
+        userNameQuery.eq(SysUser::getDelFlag, 0).eq(SysUser::getStatus, 0);
+        if (userId != null && userId != 0) {
+            userNameQuery.eq(SysUser::getUserId, userId);
+            return sysUserMapper.selectList(userNameQuery);
+        }
+        userNameQuery.eq(SysUser::getTenantId, tenantId)
+                .eq(SysUser::getDeptId, deptId);
+        return sysUserMapper.selectList(userNameQuery);
+    }
+
+    @DataScope//数据权限注解
+    private List<PmWorkContent> workTimeCount(List<Long> users, List<Integer> reports) {
+        Long deptId = SecurityUtils.getLoginUser().getSysUser().getDeptId();
+        LambdaQueryWrapper<PmWorkContent> workTimeQuery = Wrappers.lambdaQuery();
+        workTimeQuery.select(PmWorkContent::getSubmitterId, PmWorkContent::getProjectName, PmWorkContent::getWorkTime);
+        if (!users.isEmpty()) {
+            workTimeQuery.in(PmWorkContent::getSubmitterId, users);
+        }
+        if (!reports.isEmpty()) {
+            workTimeQuery.in(PmWorkContent::getProjectId, reports); // 注意这里应该是 projectId 而不是 deptId
+        }
+        workTimeQuery.eq(PmWorkContent::getDeptId, deptId);
+        // workTimeQuery.apply(DataScopeContextHolder.getDataScopeSql());// 数据权限设置
+        List<PmWorkContent> pmWorkContentList = pmWorkContentMapper.selectList(workTimeQuery);
+
+        // 使用 TreeMap 来存储每个 (SubmitterId, ProjectName) 组合及其对应的工时总和
+        Map<String, BigDecimal> workTimeSumMap = new TreeMap<>();
+
+        for (PmWorkContent content : pmWorkContentList) {
+            String key = content.getSubmitterId() + "_" + content.getProjectName();
+            workTimeSumMap.put(key, workTimeSumMap.getOrDefault(key, BigDecimal.ZERO).add(content.getWorkTime()));
+        }
+
+        List<PmWorkContent> result = new ArrayList<>();
+        for (Map.Entry<String, BigDecimal> entry : workTimeSumMap.entrySet()) {
+            String[] parts = entry.getKey().split("_");
+            Long submitterId = Long.parseLong(parts[0]);
+            String projectName = parts[1];
+            BigDecimal workTimeSum = entry.getValue();
+
+            PmWorkContent aggregatedContent = new PmWorkContent();
+            aggregatedContent.setSubmitterId(submitterId);
+            aggregatedContent.setProjectName(projectName);
+            aggregatedContent.setWorkTime(workTimeSum);
+            result.add(aggregatedContent);
+        }
+
+        return result;
+    }
+
+
+
     @Override
     public List<Object> workHourStatistic(Long userId, Integer projectId, Integer filter, String startDate, String endDate, Integer workerOrProject) {
         List<ProjectWorkTimeVO> projectWorkTime = new ArrayList<>();
         List<UserWorkTimeVO> userWorkTimeVO = new ArrayList<>();
         Integer tenantId = SecurityUtils.getTenantId();
         List<Object> returnList = new ArrayList<>();
-        LocalDate start = LocalDate.parse(startDate);
-        LocalDate end = LocalDate.parse(endDate);
-        //找出租户下所有项目
-        List<Map<String, Object>> projectIdName = pmProjectService.projectIdName(projectId);
-        List<String> pmProjectName = projectIdName.stream()
-                .map(map -> (String) map.get("name"))
-                .collect(Collectors.toList());
-        //所有人员id和nickName
-        List<Map<String, Object>> users = pmProjectService.projectUsers(userId);
+        LocalDate start = null;
+        LocalDate end = null;
+        if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
+            start = LocalDate.parse(startDate);
+            end = LocalDate.parse(endDate);
+        } else {
+            throw new BusinessException("导出数据过多请输入正确时间进行筛选");
+        }
+
+        List<PmProject> pmProjects = projects(projectId);
+        List<String> pmProjectName = new ArrayList<>();
+        List<Integer> pmProjectId = new ArrayList<>();
+        for (PmProject project : pmProjects) {
+            pmProjectName.add(project.getProjectName());
+            pmProjectId.add(project.getId());
+        }
+
+        List<SysUser> users = userNameList(userId);
+        List<Long> userIds = new ArrayList<>();
         List<String> nickName = new ArrayList<>();
-        for (Map<String, Object> map : users) {
-            Object name = map.get("name");
-            nickName.add((String) name);
+        for (SysUser user : users) {
+            userIds.add(user.getUserId());
+            nickName.add(user.getNickName());
         }
+
         //统计userId每个项目所需工时
-        List<WorkHoursStatisticsVO> userAndProject = baseMapper.workHoursStatistics(start, end, userId, tenantId);
-        Long deptId = SecurityUtils.getLoginUser().getSysUser().getDeptId();
-        List<WorkHoursStatisticsVO> userAndProjectD = baseMapper.statisticsDept(start, end, userId, tenantId, deptId);
+        List<WorkHoursStatisticsVO> userAndProject = new ArrayList<>();
+        List<PmWorkContent> pmWorkContentList = workTimeCount(userIds, pmProjectId);
+        for (PmWorkContent content : pmWorkContentList) {
+            WorkHoursStatisticsVO workHoursStatisticsVO = new WorkHoursStatisticsVO();
+            Long submitterId = content.getSubmitterId();
+            String projectName1 = content.getProjectName();
+            BigDecimal workTime = content.getWorkTime();
+            workHoursStatisticsVO.setWorkTime(workTime);
+            for (SysUser user : users) {
+                Long userId1 = user.getUserId();
+                String nickName1 = user.getNickName();
+                if (userId1.equals(submitterId)) {
+                    workHoursStatisticsVO.setNickName(nickName1);
+                }
+            }
+            for (PmProject project : pmProjects){
+                String projectName = project.getProjectName();
+                if (projectName.equals(projectName1)){
+                    workHoursStatisticsVO.setProjectName(projectName);
+                }
+            }
+            userAndProject.add(workHoursStatisticsVO);
+        }
+        List<WorkHoursStatisticsVO> userAndProjectD = userAndProject;
+
+        //userAndProject = baseMapper.workHoursStatistics(start, end, userId, tenantId);
+        //Long deptId = SecurityUtils.getLoginUser().getSysUser().getDeptId();
+        //List<WorkHoursStatisticsVO> userAndProjectD = baseMapper.statisticsDept(start, end, userId, tenantId, deptId);
         if (workerOrProject != 1) {
             returnList.add(nickName);
             //重组返回数据结构
@@ -373,7 +651,7 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
                         String userNickName = workHoursStatisticsVO.getNickName();
                         String projectName = workHoursStatisticsVO.getProjectName();
                         BigDecimal userProjectWorkTime = workHoursStatisticsVO.getWorkTime();
-                        if (userNickName.equals(name) && projectName.equals(currentNickName)) {
+                        if (userNickName == name && projectName == currentNickName) {
                             workTime.add(userProjectWorkTime);
                             if (userProjectWorkTime.compareTo(BigDecimal.ZERO) != 0) {
                                 hasNonZeroWorkTime = true;
@@ -396,4 +674,19 @@ public class PmWorkContentServiceImpl extends AbstractCrudService<PmWorkContentM
         return returnList;
     }
 
+    @Override
+    public List<WorkTimeExportVO> workHourStatisticExport(Long userId, Integer projectId, String startDate, String endDate) {
+        Integer tenantId = SecurityUtils.getTenantId();
+        LocalDate start = null;
+        LocalDate end = null;
+        if (StringUtils.isNotBlank(startDate) && StringUtils.isNotBlank(endDate)) {
+            start = LocalDate.parse(startDate);
+            end = LocalDate.parse(endDate);
+        }
+//        else {
+//            throw new BusinessException("导出数据过多请输入正确时间进行筛选");
+//        }
+        return pmWorkContentMapper.workHourStatisticExport(userId, projectId, start, end, tenantId);
+    }
+
 }

service-iot/service-iot-biz/src/main/java/com/usky/iot/service/impl/PmWorkReportServiceImpl.java

@@ -235,6 +235,7 @@ public class PmWorkReportServiceImpl extends AbstractCrudService<PmWorkReportMap
         List<PmWorkReport> repeat = this.list(reportWrapper);
         //判断是否携带reportId，不写带则为新增报告，携带则为编辑（更新）项目
         if (pmWorkReport.getId() == null) {
+
             PmWorkReport newReport = new PmWorkReport();
             newReport.setReportDate(pmWorkReport.getReportDate());
             newReport.setSubmitterId(userId);

service-iot/service-iot-biz/src/main/java/com/usky/iot/service/vo/WorkTimeExportVO.java

@@ -0,0 +1,67 @@
+package com.usky.iot.service.vo;
+
+import com.ruoyi.common.core.annotation.Excel;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.time.LocalDate;
+
+/**
+ * @description：TODO
+ * @author： fu
+ * @create： 2024-07-16 11:03
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class WorkTimeExportVO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    /**
+     * 日期
+     */
+    @Excel(name = "日期")
+    private LocalDate reportDate;
+
+    /**
+     *
+     */
+    @Excel(name = "账号名")
+    private String userName;
+
+    /**
+     *
+     */
+    @Excel(name = "员工名")
+    private String fullName;
+
+    /**
+     * 项目名
+     */
+    @Excel(name = "项目名")
+    private String projectName;
+
+    /**
+     * 工时
+     */
+    @Excel(name = "耗时")
+    private BigDecimal workTime;
+
+    /**
+     * 工作内容
+     */
+    @Excel(name = "工作内容", width = 48, align = Excel.Align.LEFT)
+    private String workContent;
+
+}
+

service-iot/service-iot-biz/src/main/resources/mapper/iot/PmWorkContentMapper.xml

@@ -27,7 +27,7 @@
     GROUP BY pc.project_name
     </select>
 
-    <select id="workHoursStatistics" resultType="com.usky.iot.service.vo.WorkHoursStatisticsVO">
+<!--    <select id="workHoursStatistics" resultType="com.usky.iot.service.vo.WorkHoursStatisticsVO">
         SELECT u.nick_name as nickName, pc.project_name as projectName, SUM(pc.work_time) as workTime
         FROM pm_work_content pc
         JOIN pm_work_report pr ON pc.report_id = pr.id
@@ -38,9 +38,9 @@
         AND pr.report_date BETWEEN #{startTime} AND #{endTime}
         AND pc.tenant_id = #{tenantId}
         GROUP BY u.nick_name, pc.project_name
-    </select>
+    </select>-->
 
-    <select id="statisticsDept" resultType="com.usky.iot.service.vo.WorkHoursStatisticsVO">
+<!--    <select id="statisticsDept" resultType="com.usky.iot.service.vo.WorkHoursStatisticsVO">
         SELECT u.nick_name as nickName, pc.project_name as projectName, SUM(pc.work_time) as workTime
         FROM pm_work_content pc
         JOIN pm_work_report pr ON pc.report_id = pr.id
@@ -52,6 +52,26 @@
         AND pc.dept_id = #{deptId}
         AND pr.report_date BETWEEN #{startTime} AND #{endTime}
         GROUP BY u.nick_name, pc.project_name
+    </select>-->
+
+    <select id="workHourStatisticExport" resultType="com.usky.iot.service.vo.WorkTimeExportVO">
+        SELECT pr.report_date AS reportDate, pr.create_by AS userName, pc.project_name AS projectName, pc.work_time AS workTime, pc.work_content AS workContent, u.nick_name AS fullName
+        FROM pm_work_content pc
+        JOIN pm_work_report pr ON pc.report_id = pr.id
+        JOIN sys_user u ON pc.submitter_id = u.user_id
+        <if test="tenantId != null and tenantId != '' and tenantId != 0">
+            AND pr.tenant_id = #{tenantId}
+        </if>
+        <if test="projectId != null and projectId != '' and projectId != 0">
+            AND pr.id = #{projectId}
+        </if>
+        <if test="userId != null and userId != '' and userId != 0">
+            AND pr.submitter_id = #{userId}
+        </if>
+        <if test="startTime != null and startTime != '' and endTime != null and endTime != ''">
+            AND pr.report_date BETWEEN #{startTime} AND #{endTime}
+        </if>
+        ORDER BY pr.report_date DESC
     </select>
 
 </mapper>