智慧建筑大屏
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
“mitao”
2026-04-01 b9b1c54aacf1d97e3a80104659696d1f6dbf61a5 
 ruoyi-admin/src/main/java/com/ruoyi/web/controller/api/ProjectController.java


@@ -1,8 +1,13 @@


package com.ruoyi.web.controller.api;




import cn.hutool.core.date.DateTime;


import cn.hutool.core.date.DateUtil;


import com.alibaba.fastjson2.JSONObject;


import com.baomidou.mybatisplus.core.conditions.Wrapper;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;


import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;


import com.icbc.hsm.utils.StringUtil;


import com.ruoyi.common.core.domain.R;


import com.ruoyi.system.dto.EditHiddenDangerResponsiblePersonDto;


import com.ruoyi.system.enums.DeviceType;


@@ -11,21 +16,32 @@


import com.ruoyi.system.query.*;


import com.ruoyi.system.service.*;


import com.ruoyi.system.vo.*;


import io.swagger.annotations.Api;


import io.swagger.annotations.ApiOperation;


import io.swagger.annotations.*;


import lombok.SneakyThrows;


import org.apache.commons.lang3.StringUtils;


import org.springframework.beans.BeanUtils;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.beans.factory.annotation.Value;


import org.springframework.beans.factory.parsing.Problem;


import org.springframework.core.io.InputStreamResource;


import org.springframework.format.annotation.DateTimeFormat;


import org.springframework.http.HttpHeaders;


import org.springframework.http.MediaType;


import org.springframework.http.ResponseEntity;


import org.springframework.web.bind.annotation.*;




import javax.annotation.PostConstruct;


import javax.annotation.Resource;


import javax.validation.Valid;


import java.io.IOException;


import java.math.BigDecimal;


import java.math.RoundingMode;


import java.util.ArrayList;


import java.util.Comparator;


import java.util.List;


import java.util.Map;


import java.net.URLEncoder;


import java.nio.file.Files;


import java.nio.file.Path;


import java.util.*;


import java.util.stream.Collectors;


import java.util.stream.Stream;




import static java.util.stream.Collectors.groupingBy;




@@ -65,6 +81,9 @@


    @Autowired


    private ScreenAccountService screenAccountService;




    @Autowired


    private ProjectProgressService projectProgressService;






    @ApiOperation(value = "获取项目/委托方列表",response = LoginNameVo.class)


    @GetMapping("/getLoginNameVoList")


@@ -85,6 +104,38 @@


    }






    @ApiOperation(value = "获取项目最新进度",response = ProjectProgress.class)


    @GetMapping("/getProjectProgress/{projectId}")


    public R<ProjectProgress> getProjectProgress(@PathVariable Integer projectId) {


        ProjectProgress projectProgress = projectProgressService.getOne(new LambdaQueryWrapper<ProjectProgress>().eq(ProjectProgress::getProjectId, projectId).eq(ProjectProgress::getDeleted,0).orderByDesc(ProjectProgress::getTime).last("limit 1"));


        return R.ok(projectProgress);


    }






    @ApiOperation(value = "获取项目进度历史列表",response = ProjectProgress.class)


    @PostMapping("/getProjectProgressList")


    public R<Page<ProjectProgress>> getProjectProgressList(@Valid @RequestBody ProjectProgressQuery query) {


        LambdaQueryWrapper<ProjectProgress> wrapper = new LambdaQueryWrapper<ProjectProgress>().eq(ProjectProgress::getProjectId, query.getProjectId()).eq(ProjectProgress::getDeleted, 0);


        if(query.getContent()!=null && !query.getContent().isEmpty()){


            wrapper.like(ProjectProgress::getDetail, query.getContent());


        }


        if(query.getStartTime()!=null && !query.getStartTime().isEmpty()){


            wrapper.ge(ProjectProgress::getTime, query.getStartTime());


        }


        if(query.getEndTime()!=null && !query.getEndTime().isEmpty()){


            wrapper.le(ProjectProgress::getTime, query.getEndTime());


        }




        wrapper.orderByDesc(ProjectProgress::getTime);


        Page<ProjectProgress> page = projectProgressService.page(new Page<>(query.getPageNum(), query.getPageSize()),wrapper);


        return R.ok(page);


    }


    @ApiOperation(value = "获取项目进度详情",response = ProjectProgress.class)


    @GetMapping("/getProjectProgressDetail/{id}")


    public R<ProjectProgress> getProjectProgressDetail(@PathVariable Integer id) {


        return R.ok(projectProgressService.getById(id));


    }






    @ApiOperation(value = "获取项目详情",response = Project.class)


    @GetMapping("/getProjectDetail/{id}")


@@ -94,6 +145,7 @@


        BeanUtils.copyProperties(project,projectVo);




        List<String> properties = deviceUsageService.getDeviceUsageList(id);


        properties = properties.stream().filter(e -> JSONObject.parseObject(e).containsKey("工程起重机械租赁单位") && JSONObject.parseObject(e).getString("工程起重机械租赁单位") != null && !JSONObject.parseObject(e).getString("工程起重机械租赁单位").isEmpty()).collect(Collectors.toList());


        projectVo.setProperties( properties);




        ProjectInfo projectInfo = projectInfoService.getOne(new LambdaUpdateWrapper<ProjectInfo>().eq(ProjectInfo::getProjectId, id).eq(ProjectInfo::getDeleted,false).orderByDesc(ProjectInfo::getCreateTime).last("limit 1"));


@@ -106,6 +158,10 @@


            projectVo.setCheckTime(task.getUpdateTime());


        }


        List<DeviceCountVo> list = deviceUsageService.getProjectDeviceCount(id);


        list.forEach(item->{


            DeviceType value = DeviceType.values()[item.getType()];


            item.setName(value.getDesc());


        });


        projectVo.setDeviceCountVos(list);


        return R.ok(projectVo);


    }


@@ -166,10 +222,10 @@


    }






    @ApiOperation(value = "获取隐患详情")


    @GetMapping("/getHiddenDangerDetail/{problemId}")


    public R<?> getHiddenDangerDetail(@PathVariable Integer problemId) {


        var record = recordService.getHiddenDangerDetail(problemId);


    @ApiOperation(value = "获取隐患详情",response = ProblemVo.class)


    @GetMapping("/getHiddenDangerDetail/{id}")


    public R<ProblemVo> getHiddenDangerDetail(@PathVariable Integer id) {


        ProblemVo record = recordService.getHiddenDangerDetail(id);


        return R.ok(record);


    }




@@ -185,7 +241,7 @@


    }






    @ApiOperation(value = "获取设备详情检查列表",response = DeviceDetailCheckListVo.class)


    @ApiOperation(value = "获取检查计划列表",response = DeviceDetailCheckListVo.class)


    @PostMapping("/getDeviceDetailCheckList")


    public R<Page<DeviceDetailCheckListVo>> getDeviceDetailCheckList(@RequestBody DeviceDetailCheckListQuery query) {


        Page<DeviceDetailCheckListVo> page = new Page<>(query.getPageNum(), query.getPageSize());


@@ -195,20 +251,31 @@


    }






    @ApiOperation(value = "获取设备详情检查资料列表")


    @ApiOperation(value = "获取检查资料列表")


    @GetMapping("/getDeviceDetailCheckPlanList")


    public R<List<Check>> getDeviceDetailCheckPlanList(@RequestParam Integer planId) {


        List<Check> list = checkService.list(new LambdaQueryWrapper<Check>().eq(Check::getPlanId,planId).orderByDesc(Check::getTime));


    public R<List<Check>> getDeviceDetailCheckPlanList(@RequestParam Integer planId,@RequestParam Integer projectId) {


        List<Check> list = checkService.list(new LambdaQueryWrapper<Check>().eq(Check::getPlanId,planId).eq(projectId!=null,Check::getProjectId,projectId).orderByDesc(Check::getTime));


        if(!list.isEmpty()){


            List<Integer> planIds = list.stream().map(Check::getPlanId).toList();


            List<Plan> plans = planService.listByIds(planIds);




            List<Integer> projectIds = list.stream().map(Check::getProjectId).toList();


            List<Project> projects = projectService.listByIds(projectIds);


            list.forEach(check -> {


                check.setPlanName(Objects.requireNonNull(plans.stream().filter(plan -> plan.getId().equals(check.getPlanId())).findFirst().orElse(null)).getName());


                check.setProjectName(Objects.requireNonNull(projects.stream().filter(project -> project.getId().equals(check.getProjectId())).findFirst().orElse(null)).getName());


            });


        }


        return R.ok(list);


    }




    @ApiOperation(value = "获取设备详情检查资料详情")




    @ApiOperation(value = "获取检查资料详情")


    @GetMapping("/getDeviceDetailCheckPlanDetail")


    public R<Check> getDeviceDetailCheckPlanDetail(@RequestParam Integer id) {


        Check check = checkService.getDeviceDetailCheckPlanDetail(id);


        return R.ok(check);


    }








    @ApiOperation(value = "获取大屏人员在岗信息")


@@ -245,10 +312,24 @@




    @ApiOperation(value = "获取计划下拉框信息",response = Plan.class)


    @GetMapping("/getPlanList")


    public R<List<Plan>> getPlanList() {


        List<Plan> list = planService.list(new LambdaQueryWrapper<Plan>().eq(Plan::getDeleted, false));


    public R<List<Plan>> getPlanList(Integer projectId) {


        List<Plan> list = planService.list(new LambdaQueryWrapper<Plan>().eq(projectId!=null,Plan::getProjectId,projectId).eq(Plan::getDeleted, false));


        return R.ok(list);


    }






    @ApiOperation(value = "获取计划下拉框信息",response = Plan.class)


    @GetMapping("/getPlanListFromOnDuty")


    public R<List<Plan>> getPlanListFromOnDuty(Integer projectId) {


        List<OnDuty> list = onDutyService.list(new LambdaQueryWrapper<OnDuty>().eq(OnDuty::getProjectId, projectId));


        if(list.isEmpty()){


            return R.ok(new ArrayList<>());


        }


        List<Integer> ids = list.stream().map(OnDuty::getPlanId).toList();


        List<Plan> resultList = planService.list(new LambdaQueryWrapper<Plan>().in(Plan::getId,ids).eq(Plan::getDeleted, false));


        return R.ok(resultList);


    }






    @ApiOperation(value = "获取人员在岗列表",response = ProjectPersonOnDutyListVo.class)


    @PostMapping("/getProjectOnDutyList")


@@ -346,4 +427,92 @@


        return R.ok(list);


    }




    @ApiOperation(value = "获取项目列表")


    @GetMapping("/list")


    @ApiImplicitParams({


            @ApiImplicitParam(name = "clientId", value = "委托方ID", dataType = "int", paramType = "query"),


            @ApiImplicitParam(name = "projectName", value = "项目名称", dataType = "string", paramType = "query"),


            @ApiImplicitParam(name = "startDate", value = "开始日期", dataType = "date", paramType = "query"),


            @ApiImplicitParam(name = "endDate", value = "结束日期", dataType = "date", paramType = "query"),


            @ApiImplicitParam(name = "projectCategory", value = "项目类型 ongoing-在建工程，fixed-固定资产 ", dataType = "string", paramType = "query")


    })


    public R<List<Project>> getList(@RequestParam("clientId") Integer clientId, String projectName,


                                    @DateTimeFormat(pattern = "yyyy-MM-dd") Date startDate,


                                    @DateTimeFormat(pattern = "yyyy-MM-dd") Date endDate,


                                    @RequestParam("projectCategory") String projectCategory) {


        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<Project>().eq(Project::getDeleted, false);


        if (clientId != null) {


            queryWrapper.eq(Project::getClientId, clientId);


        }


        if (projectName != null && !projectName.isEmpty()) {


            queryWrapper.like(Project::getName, projectName);


        }


        if (Objects.isNull(startDate)) {


            // 获取本月日期


            Date date = new Date();


            startDate = DateUtil.beginOfMonth(date);


        }


        Date finalStartDate = startDate;


        queryWrapper.and(wrapper -> wrapper


                .eq(Project::getStatus, 1)  // 在建项目


                .or(w -> w


                        .eq(Project::getStatus, 2)  // 已完成项目


                        .ge(Project::getSuccessTime, finalStartDate)  // 完成时间 >= 开始日期// 完成时间 <= 结束日期


                ));


        if ("ongoing".equals(projectCategory)) {


            queryWrapper.ne(Project::getType, 2);


        } else if ("fixed".equals(projectCategory)) {


            queryWrapper.eq(Project::getType, 2);


        }


        List<Project> list = projectService.list(queryWrapper);


        return R.ok(list);




    }






    @Resource


    UserFileService userFileService;




    @SneakyThrows


    @ApiOperation(value = "下载文件（名称）")


    @GetMapping("/download/{name}")


    public ResponseEntity<org.springframework.core.io.Resource> downloadFileByName(@PathVariable String name) {


        var userFile = userFileService.getOne(new LambdaQueryWrapper<UserFile>().eq(UserFile::getName, name));


        return downloadFile(userFile);


    }




    private ResponseEntity<org.springframework.core.io.Resource> downloadFile(UserFile userFile) throws IOException {


        InputStreamResource resource =userFileService.resolveResource(userFile);


        var fileSize = userFile.getSize();


//        if(resource == null) {


//            resource = new InputStreamResource(getClass().getClassLoader().getResourceAsStream("images/wukong.png"));


//            fileSize = 6215360L;// resource.contentLength();


//        }




        String encodedFileName = URLEncoder.encode(userFile.getOriginFileName(), "UTF-8");


        String headerValue = String.format("attachment; filename=\"%s\"", encodedFileName);


        return ResponseEntity.ok()


                .contentType(MediaType.parseMediaType(userFile.getContentType()))


                .contentLength(fileSize)


                .header(HttpHeaders.CONTENT_DISPOSITION, headerValue)


                .body(resource);


    }










    @Value("${file.upload.dir}/files")


    private String UPLOAD_DIR;






//    @PostConstruct


//    void init(){


//        fileLocation  = Path.of(UPLOAD_DIR).toAbsolutePath().normalize();


//        try {


//            Files.createDirectories(this.fileLocation);


//        } catch (Exception ex) {


//            throw new RuntimeException("Could not create the directory where the uploaded files will be stored.", ex);


//        }


//    }




}